feat: add various system and theme icons, configuration files, and support assets

squashfs-root/usr/share/python3/debpython/__init__.py

@@ -0,0 +1,58 @@
+try:
+    from datetime import datetime
+except ImportError:
+    datetime = None
+import logging
+import re
+from subprocess import PIPE, Popen
+from pickle import dumps
+
+log = logging.getLogger(__name__)
+PUBLIC_DIR_RE = re.compile(r'.*?/usr/lib/python(\d(?:.\d+)?)/(site|dist)-packages')
+
+
+class memoize:
+    def __init__(self, func):
+        self.func = func
+        self.cache = {}
+
+    def __call__(self, *args, **kwargs):
+        key = dumps((args, kwargs))
+        if key not in self.cache:
+            self.cache[key] = self.func(*args, **kwargs)
+        return self.cache[key]
+
+
+def execute(command, cwd=None, env=None, log_output=None):
+    """Execute external commad.
+
+    :param cdw: currennt working directory
+    :param env: environment
+    :param log_output:
+        * opened log file or path to this file, or
+        * None if output should be included in the returned dict, or
+        * False if output should be redirectored to stdout/stderr
+    """
+    args = {'shell': False, 'cwd': cwd, 'env': env}
+    close = False
+    if log_output is False:
+        pass
+    elif log_output is None:
+        args.update(stdout=PIPE, stderr=PIPE)
+    elif log_output:
+        if isinstance(log_output, str):
+            close = True
+            log_output = open(log_output, 'a')
+        if datetime:
+            log_output.write('\n# command executed on {}'.format(datetime.now().isoformat()))
+        log_output.write('\n$ {}\n'.format(repr(command)))
+        log_output.flush()
+        args.update(stdout=log_output, stderr=log_output)
+
+    log.debug('invoking: %r', command)
+    with Popen(command, **args) as process:
+        stdout, stderr = process.communicate()
+        close and log_output.close()
+        return dict(returncode=process.returncode,
+                    stdout=stdout and str(stdout, 'utf-8'),
+                    stderr=stderr and str(stderr, 'utf-8'))

squashfs-root/usr/share/python3/debpython/files.py

@@ -0,0 +1,86 @@
+# Copyright © 2012 Piotr Ożarowski <piotr@debian.org>
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+# THE SOFTWARE.
+
+import logging
+from os import walk, environ
+from os.path import abspath, isfile, join
+from subprocess import Popen, PIPE
+from debpython import PUBLIC_DIR_RE
+
+log = logging.getLogger(__name__)
+
+
+def from_directory(dname, extensions=('.py',)):
+    """Generate *.py file names available in given directory."""
+    extensions = tuple(extensions)  # .endswith doesn't like list
+    if isinstance(dname, (list, tuple)):
+        for item in dname:
+            for fn in from_directory(item):
+                yield fn
+    elif isfile(dname) and dname.endswith(extensions):
+        yield dname
+    else:
+        for root, dirs, file_names in walk(abspath(dname)):
+            for fn in file_names:
+                if fn.endswith(extensions):
+                    yield join(root, fn)
+
+
+def from_package(package_name, extensions=('.py',)):
+    """Generate *.py file names available in given package."""
+    extensions = tuple(extensions)  # .endswith doesn't like list
+    env = environ.copy()
+    env['LC_ALL'] = 'C.UTF-8'
+    process = Popen(('/usr/bin/dpkg', '-L', package_name), stdout=PIPE,
+                         stderr=PIPE, env=env)
+    stdout, stderr = process.communicate()
+    if process.returncode != 0:
+        raise Exception("cannot get content of %s" % package_name)
+    stdout = stdout.decode('utf-8', errors='replace')
+    for line in stdout.splitlines():
+        if line.endswith(extensions):
+            yield line
+
+
+def filter_directory(files, dname):
+    """Generate *.py file names that match given directory."""
+    for fn in files:
+        if fn.startswith(dname):
+            yield fn
+
+
+def filter_public(files, versions):
+    """Generate *.py file names that match given versions."""
+    vstr = set("%d.%d" % i for i in versions)
+    shared_vstr = set(str(i[0]) for i in versions)
+    for fn in files:
+        public_dir = PUBLIC_DIR_RE.match(fn)
+        if public_dir:
+            vers = public_dir.group(1)
+            if vers in shared_vstr or vers in vstr:
+                yield fn
+
+
+def filter_out_ext(files, extensions):
+    """Removes files with matching extensions from given generator."""
+    extensions = tuple(extensions)  # .endswith doesn't like list
+    for fn in files:
+        if not fn.endswith(extensions):
+            yield fn

squashfs-root/usr/share/python3/debpython/interpreter.py

@@ -0,0 +1,369 @@
+# Copyright © 2012 Piotr Ożarowski <piotr@debian.org>
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+# THE SOFTWARE.
+
+import logging
+import os
+import re
+from os.path import join, split
+from debpython import execute
+from debpython.version import Version
+
+SHEBANG_RE = re.compile(r'''
+    (?:\#!\s*){0,1}  # shebang prefix
+    (?P<path>
+        .*?/bin/.*?)?
+    (?P<name>
+        python|pypy)
+    (?P<version>
+        \d[\.\d]*)?
+    (?P<debug>
+        -dbg)?
+    (?P<options>.*)
+    ''', re.VERBOSE)
+EXTFILE_RE = re.compile(r'''
+    (?P<name>.*?)
+    (?:\.
+        (?P<stableabi>abi\d+)
+     |(?:\.
+        (?P<soabi>
+            (?P<impl>cpython|pypy)
+            -
+            (?P<ver>\d{2})
+            (?P<flags>[a-z]*?)
+        )
+        (?:
+            -(?P<multiarch>[^/]*?)
+        )?
+    ))?
+    (?P<debug>_d)?
+    \.so$''', re.VERBOSE)
+log = logging.getLogger(__name__)
+
+
+class Interpreter:
+    path = None
+    name = 'python'
+    version = None
+    debug = False
+    impl = 'cpython'  # implementation
+    options = ()
+    _cache = {}
+
+    def __init__(self, value=None, path=None, name=None, version=None,
+                 debug=None, impl=None, options=None):
+        params = locals()
+        del params['self']
+        del params['value']
+
+        if isinstance(value, Interpreter):
+            for key in params.keys():
+                if params[key] is None:
+                    params[key] = getattr(value, key)
+        elif value:
+            if value.replace('.', '').isdigit() and not version:
+                params['version'] = Version(value)
+            else:
+                for key, val in self.parse(value).items():
+                    if params[key] is None:
+                        params[key] = val
+
+        for key, val in params.items():
+            setattr(self, key, val)
+
+    def __setattr__(self, name, value):
+        if name == 'name' and value:
+            if value.startswith('python'):
+                self.__dict__['impl'] = 'cpython'
+            elif value.startswith('pypy'):
+                self.__dict__['impl'] = 'pypy'
+            if '-dbg' in value:
+                self.__dict__['debug'] = True
+        elif name == 'version' and value is not None:
+            value = Version(value)
+        if name in ('name', 'impl', 'debug', 'options') and value is None:
+            # get the class default instead
+            self.__dict__[name] = getattr(Interpreter, name)
+        else:
+            self.__dict__[name] = value
+
+    def __repr__(self):
+        result = self.path or ''
+        result += self._vstr(self.version)
+        if self.options:
+            result += ' ' + ' '.join(self.options)
+        return result
+
+    def __str__(self):
+        return self._vstr(self.version)
+
+    def _vstr(self, version):
+        if self.impl == 'pypy':
+            # TODO: will Debian support more than one PyPy version?
+            return self.name
+        if version and str(version) not in self.name:
+            if self.debug:
+                return 'python{}-dbg'.format(version)
+            return self.name + str(version)
+        return self.name
+
+    @staticmethod
+    def parse(shebang):
+        """Return dict with parsed shebang
+
+        >>> sorted(Interpreter.parse('pypy').items())
+        [('debug', None), ('name', 'pypy'), ('options', ()), ('path', None), ('version', None)]
+        >>> sorted(Interpreter.parse('/usr/bin/python3.3-dbg').items())
+        [('debug', '-dbg'), ('name', 'python'), ('options', ()), ('path', '/usr/bin/'), ('version', '3.3')]
+        >>> sorted(Interpreter.parse('#! /usr/bin/pypy --foo').items())
+        [('debug', None), ('name', 'pypy'), ('options', ('--foo',)), ('path', '/usr/bin/'), ('version', None)]
+        >>> sorted(Interpreter.parse('#! /usr/bin/python3.2').items())
+        [('debug', None), ('name', 'python'), ('options', ()), ('path', '/usr/bin/'), ('version', '3.2')]
+        >>> sorted(Interpreter.parse('/usr/bin/python3.2-dbg --foo --bar').items())
+        [('debug', '-dbg'), ('name', 'python'), ('options', ('--foo', '--bar')),\
+ ('path', '/usr/bin/'), ('version', '3.2')]
+        """
+        result = SHEBANG_RE.search(shebang)
+        if not result:
+            return {}
+        result = result.groupdict()
+        if 'options' in result:
+            # TODO: do we need "--key value" here?
+            result['options'] = tuple(result['options'].split())
+        return result
+
+    def sitedir(self, gdb=False, package=None, version=None):
+        """Return path to site-packages directory.
+
+        Note that returned path is not the final location of .py files
+
+        >>> i = Interpreter('python')
+        >>> i.sitedir(version='3.1')
+        '/usr/lib/python3/dist-packages/'
+        >>> i.sitedir(version='2.5')
+        '/usr/lib/python2.5/site-packages/'
+        >>> i.sitedir(version=Version('2.7'))
+        '/usr/lib/python2.7/dist-packages/'
+        >>> i.sitedir(version='3.1', gdb=True, package='python3-foo')
+        'debian/python3-foo/usr/lib/debug/usr/lib/python3/dist-packages/'
+        >>> i.sitedir(version=Version('3.2'))
+        '/usr/lib/python3/dist-packages/'
+        >>> Interpreter('pypy').sitedir(version='2.0')
+        '/usr/lib/pypy/dist-packages/'
+        """
+        version = Version(version or self.version)
+        #if not version:
+        #    version = Version(DEFAULT)
+        if self.impl == 'pypy':
+            path = '/usr/lib/pypy/dist-packages/'
+        elif version << Version('2.6'):
+            path = "/usr/lib/python%s/site-packages/" % version
+        elif version << Version('3.0'):
+            path = "/usr/lib/python%s/dist-packages/" % version
+        else:
+            path = '/usr/lib/python3/dist-packages/'
+
+        if gdb:
+            path = "/usr/lib/debug%s" % path
+        if package:
+            path = "debian/%s%s" % (package, path)
+
+        return path
+
+    def cache_file(self, fpath, version=None):
+        """Given path to a .py file, return path to its .pyc/.pyo file.
+
+        This function is inspired by Python 3.2's imp.cache_from_source.
+
+        :param fpath: path to file name
+        :param version: Python version
+
+        >>> i = Interpreter('python')
+        >>> i.cache_file('foo.py', Version('3.1'))
+        'foo.pyc'
+        >>> i.cache_file('bar/foo.py', '3.2')
+        'bar/__pycache__/foo.cpython-32.pyc'
+        """
+        version = Version(version or self.version)
+        last_char = 'o' if '-O' in self.options else 'c'
+        if version <= Version('3.1'):
+            return fpath + last_char
+
+        fdir, fname = split(fpath)
+        if not fname.endswith('.py'):
+            fname += '.py'
+        return join(fdir, '__pycache__', "%s.%s.py%s" %
+                    (fname[:-3], self.magic_tag(version), last_char))
+
+    def ext_file(self, name, version=None):
+        """Return extension name with soname and multiarch tags."""
+        version = Version(version or self.version)
+        soabi, multiarch = self._get_config(version)
+        result = name.split('.', 1)[0]
+        if soabi:
+            result += '.{}'.format(soabi)
+            if multiarch:
+                result += '-{}'.format(multiarch)
+        if self.debug and self.impl == 'cpython'\
+                and version << Version('3'):
+            result += '_d'
+        return '{}.so'.format(result)
+
+    def magic_number(self, version=None):
+        """Return magic number."""
+        version = Version(version or self.version)
+        if self.impl == 'cpython' and version << Version('3'):
+            return ''
+        result = self._execute('import importlib.util; print(importlib.util.MAGIC_NUMBER)', version)
+        return eval(result)
+
+    def magic_tag(self, version=None):
+        """Return Python magic tag (used in __pycache__ dir to tag files).
+
+        >>> i = Interpreter('python')
+        >>> i.magic_tag(version='3.2')
+        'cpython-32'
+        """
+        version = Version(version or self.version)
+        if self.impl == 'cpython' and version << Version('3.2'):
+            return ''
+        return self._execute('import sys; print(sys.implementation.cache_tag)', version)
+
+    def multiarch(self, version=None):
+        """Return multiarch tag."""
+        version = Version(version or self.version)
+        try:
+            soabi, multiarch = self._get_config(version)
+        except Exception:
+            log.debug('cannot get multiarch', exc_info=True)
+            # interpreter without multiach support
+            return ''
+        return multiarch
+
+    def stableabi(self, version=None):
+        version = Version(version or self.version)
+        # stable ABI was introduced in Python 3.3
+        if self.impl == 'cpython' and version >> Version('3.2'):
+            return 'abi{}'.format(version.major)
+
+    def soabi(self, version=None):
+        """Return SOABI flag (used to in .so files).
+
+        >>> i = Interpreter('python')
+        >>> i.soabi(version=Version('3.3'))
+        'cpython-33m'
+        """
+        version = Version(version or self.version)
+        # NOTE: it's not the same as magic_tag
+        try:
+            soabi, multiarch = self._get_config(version)
+        except Exception:
+            log.debug('cannot get soabi', exc_info=True)
+            # interpreter without soabi support
+            return ''
+        return soabi
+
+    def check_extname(self, fname, version=None):
+        """Return extension file name if file can be renamed.
+
+        >>> i = Interpreter('python')
+        >>> i.check_extname('foo.so', version='3.3') # doctest: +ELLIPSIS
+        'foo.cpython-33m-....so'
+        >>> i.check_extname('foo.abi3.so', version='3.3')
+        >>> i.check_extname('foo/bar/bazmodule.so', version='3.3') # doctest: +ELLIPSIS
+        'foo/bar/baz.cpython-33m-....so'
+        """
+        version = Version(version or self.version)
+
+        if '/' in fname:
+            fdir, fname = fname.rsplit('/', 1)  # in case full path was passed
+        else:
+            fdir = ''
+
+        info = EXTFILE_RE.search(fname)
+        if not info:
+            return
+        info = info.groupdict()
+
+        if info['stableabi']:
+            # files with stable ABI in name don't need changes
+            return
+
+        i = Interpreter(self, version=version)
+        if info['ver']:
+            i.version = "{}.{}".format(info['ver'][0], info['ver'][1])
+        if not i.debug and (info['debug'] or 'd' in (info['flags'] or '')):
+            i.debug = True
+        try:
+            soabi, multiarch = i._get_config()
+        except Exception:
+            log.debug('cannot get soabi/multiarch', exc_info=True)
+            return
+        result = info['name']
+        if i.impl == 'cpython' and i.version >> '3.2' and result.endswith('module'):
+            result = result[:-6]
+        if info['soabi'] or soabi:
+            result = "{}.{}".format(result, info['soabi'] or soabi)
+            if info['multiarch'] or multiarch:
+                result = "{}-{}".format(result, info['multiarch'] or multiarch)
+
+        result += '.so'
+        if fname == result:
+            return
+        return join(fdir, result)
+
+    def _get_config(self, version=None):
+        version = Version(version or self.version)
+        # sysconfig module is available since Python 3.2
+        # (also backported to Python 2.7)
+        if self.impl == 'pypy' or self.impl == 'cpython' and (
+                version >> '2.6' and version << '3'
+                or version >> '3.1' or version == '3'):
+            cmd = 'import sysconfig as s;'
+        else:
+            cmd = 'from distutils import sysconfig as s;'
+        cmd += 'print("__SEP__".join(i or "" ' \
+               'for i in s.get_config_vars("SOABI", "MULTIARCH")))'
+        conf_vars = self._execute(cmd, version).split('__SEP__')
+        try:
+            conf_vars[1] = os.environ['DEB_HOST_MULTIARCH']
+        except KeyError:
+            pass
+        return conf_vars
+
+    def _execute(self, command, version=None, cache=True):
+        version = Version(version or self.version)
+        command = (self._vstr(version), "-c", command)
+        if cache and command in self.__class__._cache:
+            return self.__class__._cache[command]
+
+        output = execute(command)
+        if output['returncode'] != 0:
+            log.debug(output['stderr'])
+            raise Exception('{} failed with status code {}'.format(command, output['returncode']))
+
+        result = output['stdout'].splitlines()
+
+        if len(result) == 1:
+            result = result[0]
+
+        if cache:
+            self.__class__._cache[command] = result
+
+        return result

squashfs-root/usr/share/python3/debpython/option.py

@@ -0,0 +1,47 @@
+# -*- coding: UTF-8 -*-
+# Copyright © 2010-2012 Piotr Ożarowski <piotr@debian.org>
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+# THE SOFTWARE.
+
+import re
+import optparse
+from copy import copy
+from debpython.version import parse_vrange
+
+
+def parse_version_range(option, opt, value):
+    try:
+        return parse_vrange(value)
+    except ValueError:
+        raise optparse.OptionValueError("version range is invalid: %s" % value)
+
+
+def compile_regexpr(option, opt, value):
+    try:
+        pattern = re.compile(value)
+    except Exception:
+        raise optparse.OptionValueError('regular expression is not valid')
+    return pattern
+
+
+class Option(optparse.Option):
+    TYPES = optparse.Option.TYPES + ('version_range', 'regexpr')
+    TYPE_CHECKER = copy(optparse.Option.TYPE_CHECKER)
+    TYPE_CHECKER['version_range'] = parse_version_range
+    TYPE_CHECKER['regexpr'] = compile_regexpr

squashfs-root/usr/share/python3/debpython/version.py

@@ -0,0 +1,459 @@
+# -*- coding: UTF-8 -*-
+# Copyright © 2010-2012 Piotr Ożarowski <piotr@debian.org>
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+# THE SOFTWARE.
+
+import logging
+import re
+from os import environ
+from os.path import exists
+from configparser import ConfigParser
+from types import GeneratorType
+
+RANGE_PATTERN = r'(-)?(\d\.\d+)(?:(-)(\d\.\d+)?)?'
+RANGE_RE = re.compile(RANGE_PATTERN)
+VERSION_RE = re.compile(r'''
+    (?P<major>\d+)\.?
+    (?P<minor>\d+)?\.?
+    (?P<micro>\d+)?[.\s]?
+    (?P<releaselevel>alpha|beta|candidate|final)?[.\s]?
+    (?P<serial>\d+)?''', re.VERBOSE)
+
+log = logging.getLogger(__name__)
+
+# try to read debian_defaults and get a list of supported Python versions and
+# the default one from there
+_supported = environ.get('DEBPYTHON3_SUPPORTED')
+_default = environ.get('DEBPYTHON3_DEFAULT')
+if not _supported or not _default:
+    _config = ConfigParser()
+    _config.read('/usr/share/python3/debian_defaults')
+    if not _default:
+        _default = _config.get('DEFAULT', 'default-version')[6:]
+    if not _supported:
+        _supported = _config.get('DEFAULT', 'supported-versions')\
+            .replace('python', '')
+try:
+    DEFAULT = tuple(int(i) for i in _default.split('.'))
+except Exception:
+    log.exception('cannot read debian_defaults')
+try:
+    SUPPORTED = tuple(tuple(int(j) for j in i.strip().split('.'))
+                      for i in _supported.split(','))
+except Exception:
+    log.exception('cannot read debian_defaults')
+
+
+class Version:
+    def __init__(self, value=None, major=None, minor=None, micro=None,
+                 releaselevel=None, serial=None):
+        if isinstance(value, (tuple, list)):
+            value = '.'.join(str(i) for i in value)
+        if isinstance(value, Version):
+            for name in ('major', 'minor', 'micro', 'releaselevel', 'serial'):
+                setattr(self, name, getattr(value, name))
+            return
+        comp = locals()
+        del comp['self']
+        del comp['value']
+        if value:
+            match = VERSION_RE.match(value)
+            for name, value in match.groupdict().items() if match else []:
+                if value is not None and comp[name] is None:
+                    comp[name] = value
+        for name, value in comp.items():
+            if name != 'releaselevel' and value is not None:
+                value = int(value)
+            setattr(self, name, value)
+        if not self.major:
+            raise ValueError('major component is required')
+
+    def __str__(self):
+        """Return major.minor or major string.
+
+        >>> str(Version(major=3, minor=2, micro=1, releaselevel='final', serial=4))
+        '3.2'
+        >>> str(Version(major=2))
+        '2'
+        """
+        result = str(self.major)
+        if self.minor is not None:
+            result += '.{}'.format(self.minor)
+        return result
+
+    def __hash__(self):
+        return hash(repr(self))
+
+    def __repr__(self):
+        """Return full version string.
+
+        >>> repr(Version(major=3, minor=2, micro=1, releaselevel='final', serial=4))
+        "Version('3.2.1.final.4')"
+        >>> repr(Version(major=2))
+        "Version('2')"
+        """
+        result = "Version('{}".format(self)
+        for name in ('micro', 'releaselevel', 'serial'):
+            value = getattr(self, name)
+            if not value:
+                break
+            result += '.{}'.format(value)
+        return result + "')"
+
+    def __add__(self, other):
+        """Return next version.
+
+        >>> Version('3.1') + 1
+        Version('3.2')
+        >>> Version('2') + '1'
+        Version('3')
+        """
+        result = Version(self)
+        if self.minor is None:
+            result.major += int(other)
+        else:
+            result.minor += int(other)
+        return result
+
+    def __sub__(self, other):
+        """Return previous version.
+
+        >>> Version('3.1') - 1
+        Version('3.0')
+        >>> Version('3') - '1'
+        Version('2')
+        """
+        result = Version(self)
+        if self.minor is None:
+            result.major -= int(other)
+            new = result.major
+        else:
+            result.minor -= int(other)
+            new = result.minor
+        if new < 0:
+            raise ValueError('cannot decrease version further')
+        return result
+
+    def __eq__(self, other):
+        return self.__cmp(other) == 0
+
+    def __lt__(self, other):
+        return self.__cmp(other) < 0
+
+    def __le__(self, other):
+        return self.__cmp(other) <= 0
+
+    def __gt__(self, other):
+        return self.__cmp(other) > 0
+
+    def __ge__(self, other):
+        return self.__cmp(other) >= 0
+
+    def __lshift__(self, other):
+        """Compare major.minor or major only (if minor is not set).
+
+        >>> Version('2.6') << Version('2.7')
+        True
+        >>> Version('2.6') << Version('2.6.6')
+        False
+        >>> Version('3') << Version('2')
+        False
+        >>> Version('3.1') << Version('2')
+        False
+        >>> Version('2') << Version('3.2.1.alpha.3')
+        True
+        """
+        if not isinstance(other, Version):
+            other = Version(other)
+        if self.minor is None or other.minor is None:
+            return self.__cmp(other, ignore='minor') < 0
+        else:
+            return self.__cmp(other, ignore='micro') < 0
+
+    def __rshift__(self, other):
+        """Compare major.minor or major only (if minor is not set).
+
+        >>> Version('2.6') >> Version('2.7')
+        False
+        >>> Version('2.6.7') >> Version('2.6.6')
+        False
+        >>> Version('3') >> Version('2')
+        True
+        >>> Version('3.1') >> Version('2')
+        True
+        >>> Version('2.1') >> Version('3.2.1.alpha.3')
+        False
+        """
+        if not isinstance(other, Version):
+            other = Version(other)
+        if self.minor is None or other.minor is None:
+            return self.__cmp(other, ignore='minor') > 0
+        else:
+            return self.__cmp(other, ignore='micro') > 0
+
+    def __cmp(self, other, ignore=None):
+        if not isinstance(other, Version):
+            other = Version(other)
+        for name in ('major', 'minor', 'micro', 'releaselevel', 'serial'):
+            if name == ignore:
+                break
+            value1 = getattr(self, name) or 0
+            value2 = getattr(other, name) or 0
+            if name == 'releaselevel':
+                rmap = {'alpha': -3, 'beta': -2, 'candidate': -1, 'final': 0}
+                value1 = rmap.get(value1, 0)
+                value2 = rmap.get(value2, 0)
+            if value1 == value2:
+                continue
+            return (value1 > value2) - (value1 < value2)
+        return 0
+
+
+def get_requested_versions(vrange=None, available=None):
+    """Return a set of requested and supported Python versions.
+
+    :param available: if set to `True`, return installed versions only,
+        if set to `False`, return requested versions that are not installed.
+        By default returns all requested versions.
+    :type available: bool
+
+    >>> sorted(get_requested_versions([(3, 0), None]))
+    [(3, 2), (3, 3)]
+    >>> sorted(get_requested_versions('')) == sorted(SUPPORTED)
+    True
+    >>> sorted(get_requested_versions([None, None])) == sorted(SUPPORTED)
+    True
+    >>> get_requested_versions([(5, 0), None]) == set()
+    True
+    """
+    if isinstance(vrange, str):
+        vrange = parse_vrange(vrange)
+
+    if not vrange or list(vrange) == [None, None]:
+        versions = set(SUPPORTED)
+    else:
+        minv = (0, 0) if vrange[0] is None else vrange[0]
+        maxv = (99, 99) if vrange[1] is None else vrange[1]
+        if minv == maxv:
+            versions = set((minv,) if minv in SUPPORTED else tuple())
+        else:
+            versions = set(v for v in SUPPORTED if minv <= v < maxv)
+
+    if available:
+        versions = set(v for v in versions
+                       if exists("/usr/bin/python%d.%d" % v))
+    elif available is False:
+        versions = set(v for v in versions
+                       if not exists("/usr/bin/python%d.%d" % v))
+
+    return versions
+
+
+def parse_vrange(value):
+    """Return minimum and maximum Python version from given range.
+
+    >>> parse_vrange('3.0-')
+    ((3, 0), None)
+    >>> parse_vrange('3.1-3.3')
+    ((3, 1), (3, 3))
+    >>> parse_vrange('3.2-4.0')
+    ((3, 2), (4, 0))
+    >>> parse_vrange('-3.7')
+    (None, (3, 7))
+    >>> parse_vrange('3.2')
+    ((3, 2), (3, 2))
+    >>> parse_vrange('') == parse_vrange('-') == (None, None)
+    True
+    """
+    if value in ('', '-'):
+        return None, None
+
+    match = RANGE_RE.match(value)
+    if not match:
+        raise ValueError("version range is invalid: %s" % value)
+    groups = match.groups()
+
+    if list(groups).count(None) == 3:  # only one version is allowed
+        minv = tuple(int(i) for i in groups[1].split('.'))
+        return minv, minv
+
+    minv = maxv = None
+    if groups[0]:  # maximum version only
+        maxv = groups[1]
+    else:
+        minv = groups[1]
+        maxv = groups[3]
+
+    minv = tuple(int(i) for i in minv.split('.')) if minv else None
+    maxv = tuple(int(i) for i in maxv.split('.')) if maxv else None
+
+    if maxv and minv and minv > maxv:
+        raise ValueError("version range is invalid: %s" % value)
+
+    return minv, maxv
+
+
+def parse_pycentral_vrange(value):
+    """Parse X-Python3-Version.
+
+    >>> parse_pycentral_vrange('>= 3.1')
+    ((3, 1), None)
+    >>> parse_pycentral_vrange('<< 4.0')
+    (None, (4, 0))
+    >>> parse_pycentral_vrange('3.1')
+    ((3, 1), (3, 1))
+    >>> parse_pycentral_vrange('3.1, 3.2')
+    ((3, 1), None)
+    """
+    #get = lambda x: get_requested_versions(parse_vrange(x))
+
+    minv = maxv = None
+    hardcoded = set()
+
+    for item in value.split(','):
+        item = item.strip()
+
+        match = re.match(r'>=\s*([\d\.]+)', item)
+        if match:
+            minv = "%.3s" % match.group(1)
+            continue
+        match = re.match(r'<<\s*([\d\.]+)', item)
+        if match:
+            maxv = "%.3s" % match.group(1)
+            continue
+        match = re.match(r'^[\d\.]+$', item)
+        if match:
+            hardcoded.add("%.3s" % match.group(0))
+
+    if len(hardcoded) == 1:
+        ver = hardcoded.pop()
+        return getver(ver), getver(ver)
+
+    if not minv and hardcoded:
+        # yeah, no maxv!
+        minv = sorted(hardcoded)[0]
+
+    return getver(minv) if minv else None, getver(maxv) if maxv else None
+
+
+def vrange_str(vrange):
+    """Return version range string from given range.
+
+    >>> vrange_str(((3, 4), None))
+    '3.4-'
+    >>> vrange_str(((3, 4), (3, 6)))
+    '3.4-3.6'
+    >>> vrange_str(((3, 4), (4, 0)))
+    '3.4-4.0'
+    >>> vrange_str((None, (3, 7)))
+    '-3.7'
+    >>> vrange_str(((3, 5), (3, 5)))
+    '3.5'
+    >>> vrange_str((None, None))
+    '-'
+    """
+    if vrange[0] is vrange[1] is None:
+        return '-'
+    if vrange[0] == vrange[1]:
+        return '.'.join(str(i) for i in vrange[0])
+    elif vrange[0] is None:
+        return '-' + '.'.join(str(i) for i in vrange[1])
+    elif vrange[1] is None:
+        return '.'.join(str(i) for i in vrange[0]) + '-'
+    else:
+        return "%s-%s" % ('.'.join(str(i) for i in vrange[0]),
+                          '.'.join(str(i) for i in vrange[1]))
+
+
+def vrepr(value):
+    """
+    >>> vrepr(([3, 4], [3, 2]))
+    ['3.4', '3.2']
+    >>> vrepr(('2.6', '3.1'))
+    ['2.6', '3.1']
+    >>> vrepr('3.2')
+    '3.2'
+    >>> vrepr((3, 2))
+    '3.2'
+    """
+    if isinstance(value, str):
+        return value
+    elif not isinstance(value, (GeneratorType, set)) and isinstance(value[0], int):
+        return '.'.join(str(i) for i in value)
+
+    result = []
+    for version in value:
+        if isinstance(version, str):
+            result.append(version)
+        else:
+            result.append('.'.join(str(i) for i in version))
+    return result
+
+
+def getver(value):
+    """Return pair of integers that represent version.
+
+    >>> getver('3.2')
+    (3, 2)
+    >>> getver('3.1.4')
+    (3, 1)
+    >>> getver((3, 3, 1))
+    (3, 3)
+    >>> getver(None)
+    ''
+    """
+    if not value:
+        return ''
+    if isinstance(value, tuple):
+        return value[:2]
+    return tuple(int(i) for i in value.split('.', 2))[:2]
+
+
+def debsorted(versions, return_str=None):
+    """Return sorted list of versions starting with default Python
+    version (if available) then list of suppored versions greater than default
+    one followed by reversed list of older versions.
+
+    List of versions sorted this way can be used in Depends field.
+
+    :param vrepr: return string represenatations of versions, by default the
+        same format is used as in :param:`versions`
+
+    >>> debsorted([(2, 6), (3, 1), (3, 2), (3, 3), (2, 7)])[0] == DEFAULT
+    True
+    >>> debsorted(('2.4', '3.2', '2.6', '2.7'))[-1]
+    (2, 4)
+    >>> debsorted(set([(2, 1), (2, 2)]))
+    [(2, 2), (2, 1)]
+    >>> debsorted([(2, 1), (2, 2)], return_str=True)
+    ['2.2', '2.1']
+    """
+    result = []
+    old_versions = []
+    for version in sorted(versions):
+        if isinstance(version, str):
+            version = getver(version)
+        if version < DEFAULT:
+            old_versions.append(version)
+        else:
+            result.append(version)
+    result.extend(reversed(old_versions))
+    if return_str and result:
+        return vrepr(result)
+    return result