Tryag File Manager

//lib/python3/dist-packages/incremental/__init__.py

# Copyright (c) Twisted Matrix Laboratories.
# See LICENSE for details.

"""
Versions for Python packages.

See L{Version}.
"""

from __future__ import division, absolute_import

import os
import sys
import warnings

#
# Compat functions
#

if sys.version_info < (3, 0):
    _PY3 = False
else:
    _PY3 = True
    unicode = str

def _nativeString(s):
    """
    Convert C{bytes} or C{unicode} to the native C{str} type, using ASCII
    encoding if conversion is necessary.

@raise UnicodeError: The input string is not ASCII encodable/decodable.
    @raise TypeError: The input is neither C{bytes} nor C{unicode}.
    """
    if not isinstance(s, (bytes, unicode)):
        raise TypeError("%r is neither bytes nor unicode" % s)
    if _PY3:
        if isinstance(s, bytes):
            return s.decode("ascii")
        else:
            # Ensure we're limited to ASCII subset:
            s.encode("ascii")
    else:
        if isinstance(s, unicode):
            return s.encode("ascii")
        else:
            # Ensure we're limited to ASCII subset:
            s.decode("ascii")
    return s

try:
    _cmp = cmp
except NameError:
    def _cmp(a, b):
        """
        Compare two objects.

Returns a negative number if C{a < b}, zero if they are equal, and a
        positive number if C{a > b}.
        """
        if a < b:
            return -1
        elif a == b:
            return 0
        else:
            return 1

def _comparable(klass):
    """
    Class decorator that ensures support for the special C{__cmp__} method.

On Python 2 this does nothing.

On Python 3, C{__eq__}, C{__lt__}, etc. methods are added to the class,
    relying on C{__cmp__} to implement their comparisons.
    """
    # On Python 2, __cmp__ will just work, so no need to add extra methods:
    if not _PY3:
        return klass

def __eq__(self, other):
        c = self.__cmp__(other)
        if c is NotImplemented:
            return c
        return c == 0

def __ne__(self, other):
        c = self.__cmp__(other)
        if c is NotImplemented:
            return c
        return c != 0

def __lt__(self, other):
        c = self.__cmp__(other)
        if c is NotImplemented:
            return c
        return c < 0

def __le__(self, other):
        c = self.__cmp__(other)
        if c is NotImplemented:
            return c
        return c <= 0

def __gt__(self, other):
        c = self.__cmp__(other)
        if c is NotImplemented:
            return c
        return c > 0

def __ge__(self, other):
        c = self.__cmp__(other)
        if c is NotImplemented:
            return c
        return c >= 0

klass.__lt__ = __lt__
    klass.__gt__ = __gt__
    klass.__le__ = __le__
    klass.__ge__ = __ge__
    klass.__eq__ = __eq__
    klass.__ne__ = __ne__
    return klass

#
# Versioning
#

@_comparable
class _inf(object):
    """
    An object that is bigger than all other objects.
    """
    def __cmp__(self, other):
        """
        @param other: Another object.
        @type other: any

@return: 0 if other is inf, 1 otherwise.
        @rtype: C{int}
        """
        if other is _inf:
            return 0
        return 1

_inf = _inf()

class IncomparableVersions(TypeError):
    """
    Two versions could not be compared.
    """

@_comparable
class Version(object):
    """
    An encapsulation of a version for a project, with support for outputting
    PEP-440 compatible version strings.

This class supports the standard major.minor.micro[rcN] scheme of
    versioning, with support for "local versions" which may include a SVN
    revision or Git SHA1 hash.
    """
    def __init__(self, package, major, minor, micro, release_candidate=None,
                 prerelease=None, dev=None):
        """
        @param package: Name of the package that this is a version of.
        @type package: C{str}
        @param major: The major version number.
        @type major: C{int} or C{str} (for the "NEXT" symbol)
        @param minor: The minor version number.
        @type minor: C{int}
        @param micro: The micro version number.
        @type micro: C{int}
        @param release_candidate: The release candidate number.
        @type release_candidate: C{int}
        @param prerelease: The prerelease number. (Deprecated)
        @type prerelease: C{int}
        @param dev: The development release number.
        @type dev: C{int}
        """
        if release_candidate and prerelease:
            raise ValueError("Please only return one of these.")
        elif prerelease and not release_candidate:
            release_candidate = prerelease
            warnings.warn(("Passing prerelease to incremental.Version was "
                           "deprecated in Incremental 16.9.0. Please pass "
                           "release_candidate instead."),
                          DeprecationWarning, stacklevel=2)

if major == "NEXT":
            if minor or micro or release_candidate or dev:
                raise ValueError(("When using NEXT, all other values except "
                                  "Package must be 0."))

self.package = package
        self.major = major
        self.minor = minor
        self.micro = micro
        self.release_candidate = release_candidate
        self.dev = dev

@property
    def prerelease(self):
        warnings.warn(("Accessing incremental.Version.prerelease was "
                       "deprecated in Incremental 16.9.0. Use "
                       "Version.release_candidate instead."),
                      DeprecationWarning, stacklevel=2),
        return self.release_candidate

def short(self):
        """
        Return a string in canonical short version format,
        <major>.<minor>.<micro>[+rSVNVer/+gitsha1].
        """
        s = self.base()
        gitver = self._getGitVersion()

if not gitver:
            svnver = self._getSVNVersion()
            if svnver:
                s += '+r' + _nativeString(svnver)
        else:
            s += '+' + gitver
        return s

def local(self):
        """
        Return a PEP440-compatible "local" representation of this L{Version}.

This includes a SVN revision or Git commit SHA1 hash, if available.

Examples:

- 14.4.0+r1223
          - 1.2.3rc1+rb2e812003b5d5fcf08efd1dffed6afa98d44ac8c
          - 12.10.1
          - 3.4.8rc2
          - 11.93.0rc1dev3
        """
        return self.short()

def public(self):
        """
        Return a PEP440-compatible "public" representation of this L{Version}.

Examples:

- 14.4.0
          - 1.2.3rc1
          - 14.2.1rc1dev9
          - 16.04.0dev0
        """
        return self.base()

def base(self):
        """
        Like L{short}, but without the +rSVNVer or @gitsha1.
        """
        if self.major == "NEXT":
            return self.major

if self.release_candidate is None:
            rc = ""
        else:
            rc = "rc%s" % (self.release_candidate,)

if self.dev is None:
            dev = ""
        else:
            dev = "dev%s" % (self.dev,)

return '%r.%d.%d%s%s' % (self.major,
                                 self.minor,
                                 self.micro,
                                 rc, dev)

def __repr__(self):
        # Git repr
        gitver = self._formatGitVersion()
        if gitver:
            gitver = '  #' + gitver

# SVN repr
        svnver = self._formatSVNVersion()
        if svnver:
            svnver = '  #' + svnver

if self.release_candidate is None:
            release_candidate = ""
        else:
            release_candidate = ", release_candidate=%r" % (
                self.release_candidate,)

if self.dev is None:
            dev = ""
        else:
            dev = ", dev=%r" % (self.dev,)

return '%s(%r, %r, %d, %d%s%s)%s' % (
            self.__class__.__name__,
            self.package,
            self.major,
            self.minor,
            self.micro,
            release_candidate,
            dev,
            gitver or svnver)

def __str__(self):
        return '[%s, version %s]' % (
            self.package,
            self.short())

def __cmp__(self, other):
        """
        Compare two versions, considering major versions, minor versions, micro
        versions, then release candidates. Package names are case insensitive.

A version with a release candidate is always less than a version
        without a release candidate. If both versions have release candidates,
        they will be included in the comparison.

@param other: Another version.
        @type other: L{Version}

@return: NotImplemented when the other object is not a Version, or one
            of -1, 0, or 1.

@raise IncomparableVersions: when the package names of the versions
            differ.
        """
        if not isinstance(other, self.__class__):
            return NotImplemented
        if self.package.lower() != other.package.lower():
            raise IncomparableVersions("%r != %r"
                                       % (self.package, other.package))

if self.major == "NEXT":
            major = _inf
        else:
            major = self.major

if self.release_candidate is None:
            release_candidate = _inf
        else:
            release_candidate = self.release_candidate

if self.dev is None:
            dev = _inf
        else:
            dev = self.dev

if other.major == "NEXT":
            othermajor = _inf
        else:
            othermajor = other.major

if other.release_candidate is None:
            otherrc = _inf
        else:
            otherrc = other.release_candidate

if other.dev is None:
            otherdev = _inf
        else:
            otherdev = other.dev

x = _cmp((major,
                  self.minor,
                  self.micro,
                  release_candidate,
                  dev),
                 (othermajor,
                  other.minor,
                  other.micro,
                  otherrc,
                  otherdev))
        return x

def _parseGitDir(self, directory):

headFile = os.path.abspath(os.path.join(directory, 'HEAD'))

with open(headFile, "r") as f:
            headContent = f.read().strip()

if headContent.startswith("ref: "):
            with open(os.path.abspath(
                    os.path.join(directory,
                                 headContent.split(" ")[1]))) as f:
                commit = f.read()
                return commit.strip()

return headContent

def _getGitVersion(self):
        """
        Given a package directory, walk up and find the git commit sha.
        """
        mod = sys.modules.get(self.package)
        if mod:
            basepath = os.path.dirname(mod.__file__)

upOne = os.path.abspath(os.path.join(basepath, '..'))

if ".git" in os.listdir(upOne):
                return self._parseGitDir(os.path.join(upOne, '.git'))

while True:

upOneMore = os.path.abspath(os.path.join(upOne, '..'))

if upOneMore == upOne:
                    return None

if ".git" in os.listdir(upOneMore):
                    return self._parseGitDir(os.path.join(upOneMore, '.git'))

upOne = upOneMore

def _parseSVNEntries_4(self, entriesFile):
        """
        Given a readable file object which represents a .svn/entries file in
        format version 4, return the revision as a string.  We do this by
        reading first XML element in the document that has a 'revision'
        attribute.
        """
        from xml.dom.minidom import parse
        doc = parse(entriesFile).documentElement
        for node in doc.childNodes:
            if hasattr(node, 'getAttribute'):
                rev = node.getAttribute('revision')
                if rev is not None:
                    return rev.encode('ascii')

def _parseSVNEntries_8(self, entriesFile):
        """
        Given a readable file object which represents a .svn/entries file in
        format version 8, return the revision as a string.
        """
        entriesFile.readline()
        entriesFile.readline()
        entriesFile.readline()
        return entriesFile.readline().strip()

# Add handlers for version 9 and 10 formats, which are the same as
    # version 8 as far as revision information is concerned.
    _parseSVNEntries_9 = _parseSVNEntries_8
    _parseSVNEntriesTenPlus = _parseSVNEntries_8

def _getSVNVersion(self):
        """
        Figure out the SVN revision number based on the existence of
        <package>/.svn/entries, and its contents. This requires discovering the
        format version from the 'format' file and parsing the entries file
        accordingly.

@return: None or string containing SVN Revision number.
        """
        mod = sys.modules.get(self.package)
        if mod:
            svn = os.path.join(os.path.dirname(mod.__file__), '.svn')
            if not os.path.exists(svn):
                # It's not an svn working copy
                return None

formatFile = os.path.join(svn, 'format')
            if os.path.exists(formatFile):
                # It looks like a less-than-version-10 working copy.
                with open(formatFile, 'rb') as fObj:
                    format = fObj.read().strip()
                parser = getattr(self,
                                 '_parseSVNEntries_' + format.decode('ascii'),
                                 None)
            else:
                # It looks like a version-10-or-greater working copy, which
                # has version information in the entries file.
                parser = self._parseSVNEntriesTenPlus

if parser is None:
                return b'Unknown'

entriesFile = os.path.join(svn, 'entries')
            entries = open(entriesFile, 'rb')
            try:
                try:
                    return parser(entries)
                finally:
                    entries.close()
            except:
                return b'Unknown'

def _formatSVNVersion(self):
        ver = self._getSVNVersion()
        if ver is None:
            return ''
        return ' (SVN r%s)' % (ver,)

def _formatGitVersion(self):
        ver = self._getGitVersion()
        if ver is None:
            return ''
        return ' (Git %s)' % (ver,)

def getVersionString(version):
    """
    Get a friendly string for the given version object.

@param version: A L{Version} object.
    @return: A string containing the package and short version number.
    """
    result = '%s %s' % (version.package, version.short())
    return result

def _get_version(dist, keyword, value):
    """
    Get the version from the package listed in the Distribution.
    """
    if not value:
        return

from distutils.command import build_py

sp_command = build_py.build_py(dist)
    sp_command.finalize_options()

for item in sp_command.find_all_modules():
        if item[1] == "_version":
            version_file = {}

with open(item[2]) as f:
                exec(f.read(), version_file)

dist.metadata.version = version_file["__version__"].public()
            return None

raise Exception("No _version.py found.")

from ._version import __version__ # noqa

__all__ = ["__version__", "Version", "getVersionString"]