[ramdisk] add cvitek pre-built ramdisk

Change-Id: Ic7d2046a23358129eaf621b5558984a64fa7361d

ramdisk/rootfs/public/python3.7/arm64/lib/site-packages/incremental/__init__.py

@@ -0,0 +1,353 @@
+# Copyright (c) Twisted Matrix Laboratories.
+# See LICENSE for details.
+
+"""
+Versions for Python packages.
+
+See L{Version}.
+"""
+
+from __future__ import division, absolute_import
+
+import sys
+import warnings
+
+#
+# Compat functions
+#
+
+if sys.version_info < (3, 0):
+    _PY3 = False
+else:
+    _PY3 = True
+
+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.
+    """
+    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 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
+        """
+        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)
+
+    base = public
+    short = public
+    local = public
+
+    def __repr__(self):
+
+        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)' % (
+            self.__class__.__name__,
+            self.package,
+            self.major,
+            self.minor,
+            self.micro,
+            release_candidate,
+            dev)
+
+    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 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"]

ramdisk/rootfs/public/python3.7/arm64/lib/site-packages/incremental/_version.py

@@ -0,0 +1,11 @@
+"""
+Provides Incremental version information.
+"""
+
+# This file is auto-generated! Do not edit!
+# Use `python -m incremental.update Incremental` to change this file.
+
+from incremental import Version
+
+__version__ = Version('Incremental', 17, 5, 0)
+__all__ = ["__version__"]

ramdisk/rootfs/public/python3.7/arm64/lib/site-packages/incremental/tests/test_update.py

@@ -0,0 +1,715 @@
+# Copyright (c) Twisted Matrix Laboratories.
+# See LICENSE for details.
+
+"""
+Tests for L{incremental.update}.
+"""
+
+from __future__ import division, absolute_import
+
+import sys
+import os
+import datetime
+
+from twisted.python.filepath import FilePath
+from twisted.python.compat import NativeStringIO
+from twisted.trial.unittest import TestCase
+
+from incremental.update import _run, run
+
+
+class NonCreatedUpdateTests(TestCase):
+
+    def setUp(self):
+
+        self.srcdir = FilePath(self.mktemp())
+        self.srcdir.makedirs()
+
+        packagedir = self.srcdir.child('inctestpkg')
+        packagedir.makedirs()
+
+        packagedir.child('__init__.py').setContent(b"""
+from incremental import Version
+introduced_in = Version('inctestpkg', 'NEXT', 0, 0).short()
+next_released_version = "inctestpkg NEXT"
+""")
+        self.getcwd = lambda: self.srcdir.path
+        self.packagedir = packagedir
+
+        class Date(object):
+            year = 2016
+            month = 8
+
+        self.date = Date()
+
+    def test_create(self):
+        """
+        `incremental.update package --create` initialises the version.
+        """
+        self.assertFalse(self.packagedir.child("_version.py").exists())
+
+        out = []
+        _run('inctestpkg', path=None, newversion=None, patch=False, rc=False,
+             dev=False, create=True, _date=self.date, _getcwd=self.getcwd,
+             _print=out.append)
+
+        self.assertTrue(self.packagedir.child("_version.py").exists())
+        self.assertEqual(self.packagedir.child("_version.py").getContent(),
+                         b'''"""
+Provides inctestpkg version information.
+"""
+
+# This file is auto-generated! Do not edit!
+# Use `python -m incremental.update inctestpkg` to change this file.
+
+from incremental import Version
+
+__version__ = Version('inctestpkg', 16, 8, 0)
+__all__ = ["__version__"]
+''')
+
+
+class MissingTests(TestCase):
+
+    def setUp(self):
+
+        self.srcdir = FilePath(self.mktemp())
+        self.srcdir.makedirs()
+
+        self.srcdir.child('srca').makedirs()
+
+        packagedir = self.srcdir.child('srca').child('inctestpkg')
+        packagedir.makedirs()
+
+        packagedir.child('__init__.py').setContent(b"""
+from incremental import Version
+introduced_in = Version('inctestpkg', 'NEXT', 0, 0).short()
+next_released_version = "inctestpkg NEXT"
+""")
+        packagedir.child('_version.py').setContent(b"""
+from incremental import Version
+__version__ = Version('inctestpkg', 1, 2, 3)
+__all__ = ["__version__"]
+""")
+        self.getcwd = lambda: self.srcdir.path
+        self.packagedir = packagedir
+
+        class Date(object):
+            year = 2016
+            month = 8
+
+        self.date = Date()
+
+    def test_path(self):
+        """
+        `incremental.update package --dev` raises and quits if it can't find
+        the package.
+        """
+        out = []
+        with self.assertRaises(ValueError):
+            _run(u'inctestpkg', path=None, newversion=None,
+                 patch=False, rc=False, dev=True, create=False,
+                 _date=self.date, _getcwd=self.getcwd, _print=out.append)
+
+
+class CreatedUpdateInSrcTests(TestCase):
+
+    def setUp(self):
+
+        self.srcdir = FilePath(self.mktemp())
+        self.srcdir.makedirs()
+
+        self.srcdir.child('src').makedirs()
+
+        packagedir = self.srcdir.child('src').child('inctestpkg')
+        packagedir.makedirs()
+
+        packagedir.child('__init__.py').setContent(b"""
+from incremental import Version
+introduced_in = Version('inctestpkg', 'NEXT', 0, 0).short()
+next_released_version = "inctestpkg NEXT"
+""")
+        packagedir.child('_version.py').setContent(b"""
+from incremental import Version
+__version__ = Version('inctestpkg', 1, 2, 3)
+__all__ = ["__version__"]
+""")
+        self.getcwd = lambda: self.srcdir.path
+        self.packagedir = packagedir
+
+        class Date(object):
+            year = 2016
+            month = 8
+
+        self.date = Date()
+
+    def test_path(self):
+        """
+        `incremental.update package --path=<path> --dev` increments the dev
+        version of the package on the given path
+        """
+        out = []
+        _run(u'inctestpkg', path=None, newversion=None,
+             patch=False, rc=False, dev=True, create=False, _date=self.date,
+             _getcwd=self.getcwd, _print=out.append)
+
+        self.assertTrue(self.packagedir.child("_version.py").exists())
+        self.assertEqual(self.packagedir.child("_version.py").getContent(),
+                         b'''"""
+Provides inctestpkg version information.
+"""
+
+# This file is auto-generated! Do not edit!
+# Use `python -m incremental.update inctestpkg` to change this file.
+
+from incremental import Version
+
+__version__ = Version('inctestpkg', 1, 2, 3, dev=0)
+__all__ = ["__version__"]
+''')
+
+        _run(u'inctestpkg', path=None, newversion=None,
+             patch=False, rc=False, dev=True, create=False, _date=self.date,
+             _getcwd=self.getcwd, _print=out.append)
+
+        self.assertTrue(self.packagedir.child("_version.py").exists())
+        self.assertEqual(self.packagedir.child("_version.py").getContent(),
+                         b'''"""
+Provides inctestpkg version information.
+"""
+
+# This file is auto-generated! Do not edit!
+# Use `python -m incremental.update inctestpkg` to change this file.
+
+from incremental import Version
+
+__version__ = Version('inctestpkg', 1, 2, 3, dev=1)
+__all__ = ["__version__"]
+''')
+
+
+class CreatedUpdateTests(TestCase):
+
+    maxDiff = None
+
+    def setUp(self):
+
+        self.srcdir = FilePath(self.mktemp())
+        self.srcdir.makedirs()
+
+        packagedir = self.srcdir.child('inctestpkg')
+        packagedir.makedirs()
+
+        packagedir.child('__init__.py').setContent(b"""
+from incremental import Version
+introduced_in = Version('inctestpkg', 'NEXT', 0, 0).short()
+next_released_version = "inctestpkg NEXT"
+""")
+        packagedir.child('_version.py').setContent(b"""
+from incremental import Version
+__version__ = Version('inctestpkg', 1, 2, 3)
+__all__ = ["__version__"]
+""")
+        self.getcwd = lambda: self.srcdir.path
+        self.packagedir = packagedir
+
+        class Date(object):
+            year = 2016
+            month = 8
+
+        self.date = Date()
+
+    def test_path(self):
+        """
+        `incremental.update package --path=<path> --dev` increments the dev
+        version of the package on the given path
+        """
+        out = []
+        _run(u'inctestpkg', path=self.packagedir.path, newversion=None,
+             patch=False, rc=False, dev=True, create=False, _date=self.date,
+             _print=out.append)
+
+        self.assertTrue(self.packagedir.child("_version.py").exists())
+        self.assertEqual(self.packagedir.child("_version.py").getContent(),
+                         b'''"""
+Provides inctestpkg version information.
+"""
+
+# This file is auto-generated! Do not edit!
+# Use `python -m incremental.update inctestpkg` to change this file.
+
+from incremental import Version
+
+__version__ = Version('inctestpkg', 1, 2, 3, dev=0)
+__all__ = ["__version__"]
+''')
+
+    def test_dev(self):
+        """
+        `incremental.update package --dev` increments the dev version.
+        """
+        out = []
+        _run(u'inctestpkg', path=None, newversion=None, patch=False, rc=False,
+             dev=True, create=False, _date=self.date, _getcwd=self.getcwd,
+             _print=out.append)
+
+        self.assertTrue(self.packagedir.child("_version.py").exists())
+        self.assertEqual(self.packagedir.child("_version.py").getContent(),
+                         b'''"""
+Provides inctestpkg version information.
+"""
+
+# This file is auto-generated! Do not edit!
+# Use `python -m incremental.update inctestpkg` to change this file.
+
+from incremental import Version
+
+__version__ = Version('inctestpkg', 1, 2, 3, dev=0)
+__all__ = ["__version__"]
+''')
+
+    def test_patch(self):
+        """
+        `incremental.update package --patch` increments the patch version.
+        """
+        out = []
+        _run(u'inctestpkg', path=None, newversion=None, patch=True, rc=False,
+             dev=False, create=False, _date=self.date, _getcwd=self.getcwd,
+             _print=out.append)
+
+        self.assertEqual(self.packagedir.child("_version.py").getContent(),
+                         b'''"""
+Provides inctestpkg version information.
+"""
+
+# This file is auto-generated! Do not edit!
+# Use `python -m incremental.update inctestpkg` to change this file.
+
+from incremental import Version
+
+__version__ = Version('inctestpkg', 1, 2, 4)
+__all__ = ["__version__"]
+''')
+        self.assertEqual(self.packagedir.child("__init__.py").getContent(),
+                         b"""
+from incremental import Version
+introduced_in = Version('inctestpkg', 1, 2, 4).short()
+next_released_version = "inctestpkg 1.2.4"
+""")
+
+    def test_patch_with_prerelease_and_dev(self):
+        """
+        `incremental.update package --patch` increments the patch version, and
+        disregards any old prerelease/dev versions.
+        """
+        self.packagedir.child('_version.py').setContent(b"""
+from incremental import Version
+__version__ = Version('inctestpkg', 1, 2, 3, release_candidate=1, dev=2)
+__all__ = ["__version__"]
+""")
+
+        out = []
+        _run(u'inctestpkg', path=None, newversion=None, patch=True, rc=False,
+             dev=False, create=False, _date=self.date, _getcwd=self.getcwd,
+             _print=out.append)
+
+        self.assertEqual(self.packagedir.child("_version.py").getContent(),
+                         b'''"""
+Provides inctestpkg version information.
+"""
+
+# This file is auto-generated! Do not edit!
+# Use `python -m incremental.update inctestpkg` to change this file.
+
+from incremental import Version
+
+__version__ = Version('inctestpkg', 1, 2, 4)
+__all__ = ["__version__"]
+''')
+
+    def test_rc_patch(self):
+        """
+        `incremental.update package --patch --rc` increments the patch
+        version and makes it a release candidate.
+        """
+        out = []
+        _run(u'inctestpkg', path=None, newversion=None, patch=True, rc=True,
+             dev=False, create=False, _date=self.date, _getcwd=self.getcwd,
+             _print=out.append)
+
+        self.assertEqual(self.packagedir.child("_version.py").getContent(),
+                         b'''"""
+Provides inctestpkg version information.
+"""
+
+# This file is auto-generated! Do not edit!
+# Use `python -m incremental.update inctestpkg` to change this file.
+
+from incremental import Version
+
+__version__ = Version('inctestpkg', 1, 2, 4, release_candidate=1)
+__all__ = ["__version__"]
+''')
+        self.assertEqual(self.packagedir.child("__init__.py").getContent(),
+                         b"""
+from incremental import Version
+introduced_in = Version('inctestpkg', 1, 2, 4, release_candidate=1).short()
+next_released_version = "inctestpkg 1.2.4rc1"
+""")
+
+    def test_rc_with_existing_rc(self):
+        """
+        `incremental.update package --rc` increments the rc version if the
+        existing version is an rc, and discards any dev version.
+        """
+        self.packagedir.child('_version.py').setContent(b"""
+from incremental import Version
+__version__ = Version('inctestpkg', 1, 2, 3, release_candidate=1, dev=2)
+__all__ = ["__version__"]
+""")
+
+        out = []
+        _run(u'inctestpkg', path=None, newversion=None, patch=False, rc=True,
+             dev=False, create=False, _date=self.date, _getcwd=self.getcwd,
+             _print=out.append)
+
+        self.assertEqual(self.packagedir.child("_version.py").getContent(),
+                         b'''"""
+Provides inctestpkg version information.
+"""
+
+# This file is auto-generated! Do not edit!
+# Use `python -m incremental.update inctestpkg` to change this file.
+
+from incremental import Version
+
+__version__ = Version('inctestpkg', 1, 2, 3, release_candidate=2)
+__all__ = ["__version__"]
+''')
+        self.assertEqual(self.packagedir.child("__init__.py").getContent(),
+                         b"""
+from incremental import Version
+introduced_in = Version('inctestpkg', 1, 2, 3, release_candidate=2).short()
+next_released_version = "inctestpkg 1.2.3rc2"
+""")
+
+    def test_rc_with_no_rc(self):
+        """
+        `incremental.update package --rc`, when the package is not a release
+        candidate, will issue a new major/minor rc, and disregards the micro
+        and dev.
+        """
+        self.packagedir.child('_version.py').setContent(b"""
+from incremental import Version
+__version__ = Version('inctestpkg', 1, 2, 3, dev=2)
+__all__ = ["__version__"]
+""")
+
+        out = []
+        _run(u'inctestpkg', path=None, newversion=None, patch=False, rc=True,
+             dev=False, create=False, _date=self.date, _getcwd=self.getcwd,
+             _print=out.append)
+
+        self.assertEqual(self.packagedir.child("_version.py").getContent(),
+                         b'''"""
+Provides inctestpkg version information.
+"""
+
+# This file is auto-generated! Do not edit!
+# Use `python -m incremental.update inctestpkg` to change this file.
+
+from incremental import Version
+
+__version__ = Version('inctestpkg', 16, 8, 0, release_candidate=1)
+__all__ = ["__version__"]
+''')
+        self.assertEqual(self.packagedir.child("__init__.py").getContent(),
+                         b"""
+from incremental import Version
+introduced_in = Version('inctestpkg', 16, 8, 0, release_candidate=1).short()
+next_released_version = "inctestpkg 16.8.0rc1"
+""")
+
+    def test_full_with_rc(self):
+        """
+        `incremental.update package`, when the package is a release
+        candidate, will issue the major/minor, sans release candidate or dev.
+        """
+        out = []
+        _run(u'inctestpkg', path=None, newversion=None, patch=False, rc=True,
+             dev=False, create=False, _date=self.date, _getcwd=self.getcwd,
+             _print=out.append)
+
+        self.assertEqual(self.packagedir.child("_version.py").getContent(),
+                         b'''"""
+Provides inctestpkg version information.
+"""
+
+# This file is auto-generated! Do not edit!
+# Use `python -m incremental.update inctestpkg` to change this file.
+
+from incremental import Version
+
+__version__ = Version('inctestpkg', 16, 8, 0, release_candidate=1)
+__all__ = ["__version__"]
+''')
+        self.assertEqual(self.packagedir.child("__init__.py").getContent(),
+                         b"""
+from incremental import Version
+introduced_in = Version('inctestpkg', 16, 8, 0, release_candidate=1).short()
+next_released_version = "inctestpkg 16.8.0rc1"
+""")
+
+        _run(u'inctestpkg', path=None, newversion=None, patch=False, rc=False,
+             dev=False, create=False, _date=self.date, _getcwd=self.getcwd,
+             _print=out.append)
+
+        self.assertEqual(self.packagedir.child("_version.py").getContent(),
+                         b'''"""
+Provides inctestpkg version information.
+"""
+
+# This file is auto-generated! Do not edit!
+# Use `python -m incremental.update inctestpkg` to change this file.
+
+from incremental import Version
+
+__version__ = Version('inctestpkg', 16, 8, 0)
+__all__ = ["__version__"]
+''')
+        self.assertEqual(self.packagedir.child("__init__.py").getContent(),
+                         b"""
+from incremental import Version
+introduced_in = Version('inctestpkg', 16, 8, 0).short()
+next_released_version = "inctestpkg 16.8.0"
+""")
+
+    def test_full_without_rc(self):
+        """
+        `incremental.update package`, when the package is NOT a release
+        candidate, will raise an error.
+        """
+        out = []
+        with self.assertRaises(ValueError) as e:
+            _run(u'inctestpkg', path=None, newversion=None, patch=False,
+                 rc=False, dev=False, create=False, _date=self.date,
+                 _getcwd=self.getcwd, _print=out.append)
+
+        self.assertEqual(
+            e.exception.args[0],
+            "You need to issue a rc before updating the major/minor")
+
+    def test_no_mix_newversion(self):
+        """
+        The `--newversion` flag can't be mixed with --patch, --rc, or --dev.
+        """
+        out = []
+        with self.assertRaises(ValueError) as e:
+            _run(u'inctestpkg', path=None, newversion="1", patch=True,
+                 rc=False, dev=False, create=False, _date=self.date,
+                 _getcwd=self.getcwd, _print=out.append)
+        self.assertEqual(e.exception.args[0], "Only give --newversion")
+
+        with self.assertRaises(ValueError) as e:
+            _run(u'inctestpkg', path=None, newversion="1", patch=False,
+                 rc=True, dev=False, create=False, _date=self.date,
+                 _getcwd=self.getcwd, _print=out.append)
+        self.assertEqual(e.exception.args[0], "Only give --newversion")
+
+        with self.assertRaises(ValueError) as e:
+            _run(u'inctestpkg', path=None, newversion="1", patch=False,
+                 rc=False, dev=True, create=False, _date=self.date,
+                 _getcwd=self.getcwd, _print=out.append)
+        self.assertEqual(e.exception.args[0], "Only give --newversion")
+
+    def test_no_mix_dev(self):
+        """
+        The `--dev` flag can't be mixed with --patch, or --rc.
+        """
+        out = []
+        with self.assertRaises(ValueError) as e:
+            _run(u'inctestpkg', path=None, newversion=None, patch=True,
+                 rc=False, dev=True, create=False, _date=self.date,
+                 _getcwd=self.getcwd, _print=out.append)
+        self.assertEqual(e.exception.args[0], "Only give --dev")
+
+        with self.assertRaises(ValueError) as e:
+            _run(u'inctestpkg', path=None, newversion=None, patch=False,
+                 rc=True, dev=True, create=False, _date=self.date,
+                 _getcwd=self.getcwd, _print=out.append)
+        self.assertEqual(e.exception.args[0], "Only give --dev")
+
+    def test_no_mix_create(self):
+        """
+        The `--create` flag can't be mixed with --patch, --rc, --dev, or
+        --newversion.
+        """
+        out = []
+        with self.assertRaises(ValueError) as e:
+            _run(u'inctestpkg', path=None, newversion=None, patch=True,
+                 rc=False, dev=False, create=True, _date=self.date,
+                 _getcwd=self.getcwd, _print=out.append)
+        self.assertEqual(e.exception.args[0], "Only give --create")
+
+        with self.assertRaises(ValueError) as e:
+            _run(u'inctestpkg', path=None, newversion="1", patch=False,
+                 rc=False, dev=False, create=True, _date=self.date,
+                 _getcwd=self.getcwd, _print=out.append)
+        self.assertEqual(e.exception.args[0], "Only give --create")
+
+        with self.assertRaises(ValueError) as e:
+            _run(u'inctestpkg', path=None, newversion=None, patch=False,
+                 rc=True, dev=False, create=True, _date=self.date,
+                 _getcwd=self.getcwd, _print=out.append)
+        self.assertEqual(e.exception.args[0], "Only give --create")
+
+        with self.assertRaises(ValueError) as e:
+            _run(u'inctestpkg', path=None, newversion=None, patch=False,
+                 rc=False, dev=True, create=True, _date=self.date,
+                 _getcwd=self.getcwd, _print=out.append)
+        self.assertEqual(e.exception.args[0], "Only give --create")
+
+    def test_newversion(self):
+        """
+        `incremental.update package --newversion=1.2.3rc1dev3`, will set that
+        version in the package.
+        """
+        out = []
+        _run(u'inctestpkg', path=None, newversion="1.2.3rc1dev3", patch=False,
+             rc=False, dev=False, create=False, _date=self.date,
+             _getcwd=self.getcwd, _print=out.append)
+
+        self.assertEqual(self.packagedir.child("_version.py").getContent(),
+                         b'''"""
+Provides inctestpkg version information.
+"""
+
+# This file is auto-generated! Do not edit!
+# Use `python -m incremental.update inctestpkg` to change this file.
+
+from incremental import Version
+
+__version__ = Version('inctestpkg', 1, 2, 3, release_candidate=1, dev=3)
+__all__ = ["__version__"]
+''')
+        self.assertEqual(self.packagedir.child("__init__.py").getContent(),
+                         (b"""
+from incremental import Version
+introduced_in = Version('inctestpkg', 1, 2, 3, """
+                         b"""release_candidate=1, dev=3).short()
+next_released_version = "inctestpkg 1.2.3rc1dev3"
+"""))
+
+    def test_newversion_bare(self):
+        """
+        `incremental.update package --newversion=1`, will set that
+        version in the package.
+        """
+        out = []
+        _run(u'inctestpkg', path=None, newversion="1", patch=False,
+             rc=False, dev=False, create=False, _date=self.date,
+             _getcwd=self.getcwd, _print=out.append)
+
+        self.assertEqual(self.packagedir.child("_version.py").getContent(),
+                         b'''"""
+Provides inctestpkg version information.
+"""
+
+# This file is auto-generated! Do not edit!
+# Use `python -m incremental.update inctestpkg` to change this file.
+
+from incremental import Version
+
+__version__ = Version('inctestpkg', 1, 0, 0)
+__all__ = ["__version__"]
+''')
+        self.assertEqual(self.packagedir.child("__init__.py").getContent(),
+                         b"""
+from incremental import Version
+introduced_in = Version('inctestpkg', 1, 0, 0).short()
+next_released_version = "inctestpkg 1.0.0"
+""")
+
+
+class ScriptTests(TestCase):
+
+    def setUp(self):
+
+        self.srcdir = FilePath(self.mktemp())
+        self.srcdir.makedirs()
+
+        self.srcdir.child('src').makedirs()
+
+        packagedir = self.srcdir.child('src').child('inctestpkg')
+        packagedir.makedirs()
+
+        packagedir.child('__init__.py').setContent(b"""
+from incremental import Version
+introduced_in = Version('inctestpkg', 'NEXT', 0, 0).short()
+next_released_version = "inctestpkg NEXT"
+""")
+        packagedir.child('_version.py').setContent(b"""
+from incremental import Version
+__version__ = Version('inctestpkg', 1, 2, 3)
+__all__ = ["__version__"]
+""")
+        self.getcwd = lambda: self.srcdir.path
+        self.packagedir = packagedir
+
+        class Date(object):
+            year = 2016
+            month = 8
+
+        class DateModule(object):
+            def today(self):
+                return Date()
+
+        self.date = DateModule()
+
+    def test_run(self):
+        """
+        Calling run() with no args will cause it to print help.
+        """
+        stringio = NativeStringIO()
+        self.patch(sys, 'stdout', stringio)
+
+        with self.assertRaises(SystemExit) as e:
+            run(["--help"])
+
+        self.assertEqual(e.exception.args[0], 0)
+        self.assertIn("Show this message and exit", stringio.getvalue())
+
+    def test_insufficient_args(self):
+        """
+        Calling run() with no args will cause it to print help.
+        """
+        stringio = NativeStringIO()
+        self.patch(sys, 'stdout', stringio)
+        self.patch(os, 'getcwd', self.getcwd)
+        self.patch(datetime, 'date', self.date)
+
+        with self.assertRaises(SystemExit) as e:
+            run(["inctestpkg", "--rc"])
+
+        self.assertEqual(e.exception.args[0], 0)
+        self.assertIn("Updating codebase", stringio.getvalue())
+
+        self.assertEqual(self.packagedir.child("_version.py").getContent(),
+                         b'''"""
+Provides inctestpkg version information.
+"""
+
+# This file is auto-generated! Do not edit!
+# Use `python -m incremental.update inctestpkg` to change this file.
+
+from incremental import Version
+
+__version__ = Version('inctestpkg', 16, 8, 0, release_candidate=1)
+__all__ = ["__version__"]
+''')
+        self.assertEqual(self.packagedir.child("__init__.py").getContent(),
+                         b"""
+from incremental import Version
+introduced_in = Version('inctestpkg', 16, 8, 0, release_candidate=1).short()
+next_released_version = "inctestpkg 16.8.0rc1"
+""")

ramdisk/rootfs/public/python3.7/arm64/lib/site-packages/incremental/tests/test_version.py

@@ -0,0 +1,415 @@
+# Copyright (c) Twisted Matrix Laboratories.
+# See LICENSE for details.
+
+"""
+Tests for L{incremental}.
+"""
+
+from __future__ import division, absolute_import
+
+import operator
+
+from incremental import getVersionString, IncomparableVersions
+from incremental import Version, _inf
+
+from twisted.trial.unittest import TestCase
+
+
+class VersionsTests(TestCase):
+
+    def test_localIsShort(self):
+        """
+        The local version is the same as the short version.
+        """
+        va = Version("dummy", 1, 0, 0, release_candidate=1, dev=3)
+        self.assertEqual(va.local(), va.short())
+
+    def test_versionComparison(self):
+        """
+        Versions can be compared for equality and order.
+        """
+        va = Version("dummy", 1, 0, 0)
+        vb = Version("dummy", 0, 1, 0)
+        self.assertTrue(va > vb)
+        self.assertTrue(vb < va)
+        self.assertTrue(va >= vb)
+        self.assertTrue(vb <= va)
+        self.assertTrue(va != vb)
+        self.assertTrue(vb == Version("dummy", 0, 1, 0))
+        self.assertTrue(vb == vb)
+
+    def test_versionComparisonCaseInsensitive(self):
+        """
+        Version package names are case insensitive.
+        """
+        va = Version("dummy", 1, 0, 0)
+        vb = Version("DuMmY", 0, 1, 0)
+        self.assertTrue(va > vb)
+        self.assertTrue(vb < va)
+        self.assertTrue(va >= vb)
+        self.assertTrue(vb <= va)
+        self.assertTrue(va != vb)
+        self.assertTrue(vb == Version("dummy", 0, 1, 0))
+        self.assertTrue(vb == vb)
+
+    def test_comparingNEXTReleases(self):
+        """
+        NEXT releases are always larger than numbered releases.
+        """
+        va = Version("whatever", "NEXT", 0, 0)
+        vb = Version("whatever", 1, 0, 0)
+        self.assertTrue(va > vb)
+        self.assertFalse(va < vb)
+        self.assertNotEquals(vb, va)
+
+    def test_NEXTMustBeAlone(self):
+        """
+        NEXT releases must always have the rest of the numbers set to 0.
+        """
+        with self.assertRaises(ValueError):
+            Version("whatever", "NEXT", 1, 0, release_candidate=0, dev=0)
+
+        with self.assertRaises(ValueError):
+            Version("whatever", "NEXT", 0, 1, release_candidate=0, dev=0)
+
+        with self.assertRaises(ValueError):
+            Version("whatever", "NEXT", 0, 0, release_candidate=1, dev=0)
+
+        with self.assertRaises(ValueError):
+            Version("whatever", "NEXT", 0, 0, release_candidate=0, dev=1)
+
+    def test_comparingNEXTReleasesEqual(self):
+        """
+        NEXT releases are equal to each other.
+        """
+        va = Version("whatever", "NEXT", 0, 0)
+        vb = Version("whatever", "NEXT", 0, 0)
+        self.assertEquals(vb, va)
+
+    def test_comparingPrereleasesWithReleases(self):
+        """
+        Prereleases are always less than versions without prereleases.
+        """
+        va = Version("whatever", 1, 0, 0, prerelease=1)
+        vb = Version("whatever", 1, 0, 0)
+        self.assertTrue(va < vb)
+        self.assertFalse(va > vb)
+        self.assertNotEquals(vb, va)
+
+    def test_prereleaseDeprecated(self):
+        """
+        Passing 'prerelease' to Version is deprecated.
+        """
+        Version("whatever", 1, 0, 0, prerelease=1)
+        warnings = self.flushWarnings([self.test_prereleaseDeprecated])
+        self.assertEqual(len(warnings), 1)
+        self.assertEqual(
+            warnings[0]['message'],
+            ("Passing prerelease to incremental.Version was deprecated in "
+             "Incremental 16.9.0. Please pass release_candidate instead."))
+
+    def test_prereleaseAttributeDeprecated(self):
+        """
+        Accessing 'prerelease' on a Version is deprecated.
+        """
+        va = Version("whatever", 1, 0, 0, release_candidate=1)
+        va.prerelease
+        warnings = self.flushWarnings(
+            [self.test_prereleaseAttributeDeprecated])
+        self.assertEqual(len(warnings), 1)
+        self.assertEqual(
+            warnings[0]['message'],
+            ("Accessing incremental.Version.prerelease was deprecated in "
+             "Incremental 16.9.0. Use Version.release_candidate instead."))
+
+    def test_comparingReleaseCandidatesWithReleases(self):
+        """
+        Release Candidates are always less than versions without release
+        candidates.
+        """
+        va = Version("whatever", 1, 0, 0, release_candidate=1)
+        vb = Version("whatever", 1, 0, 0)
+        self.assertTrue(va < vb)
+        self.assertFalse(va > vb)
+        self.assertNotEquals(vb, va)
+
+    def test_comparingDevReleasesWithReleases(self):
+        """
+        Dev releases are always less than versions without dev releases.
+        """
+        va = Version("whatever", 1, 0, 0, dev=1)
+        vb = Version("whatever", 1, 0, 0)
+        self.assertTrue(va < vb)
+        self.assertFalse(va > vb)
+        self.assertNotEquals(vb, va)
+
+    def test_rcEqualspre(self):
+        """
+        Release Candidates are equal to prereleases.
+        """
+        va = Version("whatever", 1, 0, 0, release_candidate=1)
+        vb = Version("whatever", 1, 0, 0, prerelease=1)
+        self.assertTrue(va == vb)
+        self.assertFalse(va != vb)
+
+    def test_rcOrpreButNotBoth(self):
+        """
+        Release Candidate and prerelease can't both be given.
+        """
+        with self.assertRaises(ValueError):
+            Version("whatever", 1, 0, 0,
+                    prerelease=1, release_candidate=1)
+
+    def test_comparingReleaseCandidates(self):
+        """
+        The value specified as the release candidate is used in version
+        comparisons.
+        """
+        va = Version("whatever", 1, 0, 0, release_candidate=1)
+        vb = Version("whatever", 1, 0, 0, release_candidate=2)
+        self.assertTrue(va < vb)
+        self.assertTrue(vb > va)
+        self.assertTrue(va <= vb)
+        self.assertTrue(vb >= va)
+        self.assertTrue(va != vb)
+        self.assertTrue(vb == Version("whatever", 1, 0, 0,
+                                      release_candidate=2))
+        self.assertTrue(va == va)
+
+    def test_comparingDev(self):
+        """
+        The value specified as the dev release is used in version comparisons.
+        """
+        va = Version("whatever", 1, 0, 0, dev=1)
+        vb = Version("whatever", 1, 0, 0, dev=2)
+        self.assertTrue(va < vb)
+        self.assertTrue(vb > va)
+        self.assertTrue(va <= vb)
+        self.assertTrue(vb >= va)
+        self.assertTrue(va != vb)
+        self.assertTrue(vb == Version("whatever", 1, 0, 0,
+                                      dev=2))
+        self.assertTrue(va == va)
+
+    def test_comparingDevAndRC(self):
+        """
+        The value specified as the dev release and release candidate is used in
+        version comparisons.
+        """
+        va = Version("whatever", 1, 0, 0, release_candidate=1, dev=1)
+        vb = Version("whatever", 1, 0, 0, release_candidate=1, dev=2)
+        self.assertTrue(va < vb)
+        self.assertTrue(vb > va)
+        self.assertTrue(va <= vb)
+        self.assertTrue(vb >= va)
+        self.assertTrue(va != vb)
+        self.assertTrue(vb == Version("whatever", 1, 0, 0,
+                                      release_candidate=1, dev=2))
+        self.assertTrue(va == va)
+
+    def test_comparingDevAndRCDifferent(self):
+        """
+        The value specified as the dev release and release candidate is used in
+        version comparisons.
+        """
+        va = Version("whatever", 1, 0, 0, release_candidate=1, dev=1)
+        vb = Version("whatever", 1, 0, 0, release_candidate=2, dev=1)
+        self.assertTrue(va < vb)
+        self.assertTrue(vb > va)
+        self.assertTrue(va <= vb)
+        self.assertTrue(vb >= va)
+        self.assertTrue(va != vb)
+        self.assertTrue(vb == Version("whatever", 1, 0, 0,
+                                      release_candidate=2, dev=1))
+        self.assertTrue(va == va)
+
+    def test_infComparison(self):
+        """
+        L{_inf} is equal to L{_inf}.
+
+        This is a regression test.
+        """
+        self.assertEqual(_inf, _inf)
+
+    def test_disallowBuggyComparisons(self):
+        """
+        The package names of the Version objects need to be the same.
+        """
+        self.assertRaises(IncomparableVersions,
+                          operator.eq,
+                          Version("dummy", 1, 0, 0),
+                          Version("dumym", 1, 0, 0))
+
+    def test_notImplementedComparisons(self):
+        """
+        Comparing a L{Version} to some other object type results in
+        C{NotImplemented}.
+        """
+        va = Version("dummy", 1, 0, 0)
+        vb = ("dummy", 1, 0, 0)  # a tuple is not a Version object
+        self.assertEqual(va.__cmp__(vb), NotImplemented)
+
+    def test_repr(self):
+        """
+        Calling C{repr} on a version returns a human-readable string
+        representation of the version.
+        """
+        self.assertEqual(repr(Version("dummy", 1, 2, 3)),
+                         "Version('dummy', 1, 2, 3)")
+
+    def test_reprWithPrerelease(self):
+        """
+        Calling C{repr} on a version with a prerelease returns a human-readable
+        string representation of the version including the prerelease as a
+        release candidate..
+        """
+        self.assertEqual(repr(Version("dummy", 1, 2, 3, prerelease=4)),
+                         "Version('dummy', 1, 2, 3, release_candidate=4)")
+
+    def test_reprWithReleaseCandidate(self):
+        """
+        Calling C{repr} on a version with a release candidate returns a
+        human-readable string representation of the version including the rc.
+        """
+        self.assertEqual(repr(Version("dummy", 1, 2, 3, release_candidate=4)),
+                         "Version('dummy', 1, 2, 3, release_candidate=4)")
+
+    def test_devWithReleaseCandidate(self):
+        """
+        Calling C{repr} on a version with a dev release returns a
+        human-readable string representation of the version including the dev
+        release.
+        """
+        self.assertEqual(repr(Version("dummy", 1, 2, 3, dev=4)),
+                         "Version('dummy', 1, 2, 3, dev=4)")
+
+    def test_str(self):
+        """
+        Calling C{str} on a version returns a human-readable string
+        representation of the version.
+        """
+        self.assertEqual(str(Version("dummy", 1, 2, 3)),
+                         "[dummy, version 1.2.3]")
+
+    def test_strWithPrerelease(self):
+        """
+        Calling C{str} on a version with a prerelease includes the prerelease
+        as a release candidate.
+        """
+        self.assertEqual(str(Version("dummy", 1, 0, 0, prerelease=1)),
+                         "[dummy, version 1.0.0rc1]")
+
+    def test_strWithReleaseCandidate(self):
+        """
+        Calling C{str} on a version with a release candidate includes the
+        release candidate.
+        """
+        self.assertEqual(str(Version("dummy", 1, 0, 0, release_candidate=1)),
+                         "[dummy, version 1.0.0rc1]")
+
+    def test_strWithDevAndReleaseCandidate(self):
+        """
+        Calling C{str} on a version with a release candidate and dev release
+        includes the release candidate and the dev release.
+        """
+        self.assertEqual(str(Version("dummy", 1, 0, 0,
+                                     release_candidate=1, dev=2)),
+                         "[dummy, version 1.0.0rc1dev2]")
+
+    def test_strWithDev(self):
+        """
+        Calling C{str} on a version with a dev release includes the dev
+        release.
+        """
+        self.assertEqual(str(Version("dummy", 1, 0, 0, dev=1)),
+                         "[dummy, version 1.0.0dev1]")
+
+    def testShort(self):
+        self.assertEqual(Version('dummy', 1, 2, 3).short(), '1.2.3')
+
+    def test_getVersionString(self):
+        """
+        L{getVersionString} returns a string with the package name and the
+        short version number.
+        """
+        self.assertEqual(
+            'Twisted 8.0.0', getVersionString(Version('Twisted', 8, 0, 0)))
+
+    def test_getVersionStringWithPrerelease(self):
+        """
+        L{getVersionString} includes the prerelease as a release candidate, if
+        any.
+        """
+        self.assertEqual(
+            getVersionString(Version("whatever", 8, 0, 0, prerelease=1)),
+            "whatever 8.0.0rc1")
+
+    def test_getVersionStringWithReleaseCandidate(self):
+        """
+        L{getVersionString} includes the release candidate, if any.
+        """
+        self.assertEqual(
+            getVersionString(Version("whatever", 8, 0, 0,
+                                     release_candidate=1)),
+            "whatever 8.0.0rc1")
+
+    def test_getVersionStringWithDev(self):
+        """
+        L{getVersionString} includes the dev release, if any.
+        """
+        self.assertEqual(
+            getVersionString(Version("whatever", 8, 0, 0,
+                                     dev=1)),
+            "whatever 8.0.0dev1")
+
+    def test_getVersionStringWithDevAndRC(self):
+        """
+        L{getVersionString} includes the dev release and release candidate, if
+        any.
+        """
+        self.assertEqual(
+            getVersionString(Version("whatever", 8, 0, 0,
+                                     release_candidate=2, dev=1)),
+            "whatever 8.0.0rc2dev1")
+
+    def test_baseWithNEXT(self):
+        """
+        The C{base} method returns just "NEXT" when NEXT is the major version.
+        """
+        self.assertEqual(Version("foo", "NEXT", 0, 0).base(), "NEXT")
+
+    def test_base(self):
+        """
+        The C{base} method returns a very simple representation of the version.
+        """
+        self.assertEqual(Version("foo", 1, 0, 0).base(), "1.0.0")
+
+    def test_baseWithPrerelease(self):
+        """
+        The base version includes 'rcX' for versions with prereleases.
+        """
+        self.assertEqual(Version("foo", 1, 0, 0, prerelease=8).base(),
+                         "1.0.0rc8")
+
+    def test_baseWithDev(self):
+        """
+        The base version includes 'devX' for versions with dev releases.
+        """
+        self.assertEqual(Version("foo", 1, 0, 0, dev=8).base(),
+                         "1.0.0dev8")
+
+    def test_baseWithReleaseCandidate(self):
+        """
+        The base version includes 'rcX' for versions with prereleases.
+        """
+        self.assertEqual(Version("foo", 1, 0, 0, release_candidate=8).base(),
+                         "1.0.0rc8")
+
+    def test_baseWithDevAndRC(self):
+        """
+        The base version includes 'rcXdevX' for versions with dev releases and
+        a release candidate.
+        """
+        self.assertEqual(Version("foo", 1, 0, 0,
+                                 release_candidate=2, dev=8).base(),
+                         "1.0.0rc2dev8")

ramdisk/rootfs/public/python3.7/arm64/lib/site-packages/incremental/update.py

@@ -0,0 +1,209 @@
+# Copyright (c) Twisted Matrix Laboratories.
+# See LICENSE for details.
+
+from __future__ import absolute_import, division, print_function
+
+import click
+import os
+import datetime
+
+from incremental import Version
+from twisted.python.filepath import FilePath
+
+_VERSIONPY_TEMPLATE = '''"""
+Provides %s version information.
+"""
+
+# This file is auto-generated! Do not edit!
+# Use `python -m incremental.update %s` to change this file.
+
+from incremental import Version
+
+__version__ = %s
+__all__ = ["__version__"]
+'''
+
+_YEAR_START = 2000
+
+
+def _findPath(path, package):
+
+    cwd = FilePath(path)
+
+    src_dir = cwd.child("src").child(package.lower())
+    current_dir = cwd.child(package.lower())
+
+    if src_dir.isdir():
+        return src_dir
+    elif current_dir.isdir():
+        return current_dir
+    else:
+        raise ValueError(("Can't find under `./src` or `./`. Check the "
+                          "package name is right (note that we expect your "
+                          "package name to be lower cased), or pass it using "
+                          "'--path'."))
+
+
+def _existing_version(path):
+    version_info = {}
+
+    with path.child("_version.py").open('r') as f:
+        exec(f.read(), version_info)
+
+    return version_info["__version__"]
+
+
+def _run(package, path, newversion, patch, rc, dev, create,
+         _date=None, _getcwd=None, _print=print):
+
+    if not _getcwd:
+        _getcwd = os.getcwd
+
+    if not _date:
+        _date = datetime.date.today()
+
+    if type(package) != str:
+        package = package.encode('utf8')
+
+    if not path:
+        path = _findPath(_getcwd(), package)
+    else:
+        path = FilePath(path)
+
+    if newversion and patch or newversion and dev or newversion and rc:
+        raise ValueError("Only give --newversion")
+
+    if dev and patch or dev and rc:
+        raise ValueError("Only give --dev")
+
+    if create and dev or create and patch or create and rc or \
+       create and newversion:
+        raise ValueError("Only give --create")
+
+    if newversion:
+        from pkg_resources import parse_version
+        existing = _existing_version(path)
+        st_version = parse_version(newversion)._version
+
+        release = list(st_version.release)
+
+        if len(release) == 1:
+            release.append(0)
+        if len(release) == 2:
+            release.append(0)
+
+        v = Version(
+            package, *release,
+            release_candidate=st_version.pre[1] if st_version.pre else None,
+            dev=st_version.dev[1] if st_version.dev else None)
+
+    elif create:
+        v = Version(package, _date.year - _YEAR_START, _date.month, 0)
+        existing = v
+
+    elif rc and not patch:
+        existing = _existing_version(path)
+
+        if existing.release_candidate:
+            v = Version(package, existing.major, existing.minor,
+                        existing.micro, existing.release_candidate + 1)
+        else:
+            v = Version(package, _date.year - _YEAR_START, _date.month, 0, 1)
+
+    elif patch:
+        if rc:
+            rc = 1
+        else:
+            rc = None
+
+        existing = _existing_version(path)
+        v = Version(package, existing.major, existing.minor,
+                    existing.micro + 1, rc)
+
+    elif dev:
+        existing = _existing_version(path)
+
+        if existing.dev is None:
+            _dev = 0
+        else:
+            _dev = existing.dev + 1
+
+        v = Version(package, existing.major, existing.minor,
+                    existing.micro, existing.release_candidate, dev=_dev)
+
+    else:
+        existing = _existing_version(path)
+
+        if existing.release_candidate:
+            v = Version(package,
+                        existing.major, existing.minor, existing.micro)
+        else:
+            raise ValueError(
+                "You need to issue a rc before updating the major/minor")
+
+    NEXT_repr = repr(Version(package, "NEXT", 0, 0)).split("#")[0]
+    NEXT_repr_bytes = NEXT_repr.encode('utf8')
+
+    version_repr = repr(v).split("#")[0]
+    version_repr_bytes = version_repr.encode('utf8')
+
+    existing_version_repr = repr(existing).split("#")[0]
+    existing_version_repr_bytes = existing_version_repr.encode('utf8')
+
+    _print("Updating codebase to %s" % (v.public()))
+
+    for x in path.walk():
+
+        if not x.isfile():
+            continue
+
+        original_content = x.getContent()
+        content = original_content
+
+        # Replace previous release_candidate calls to the new one
+        if existing.release_candidate:
+            content = content.replace(existing_version_repr_bytes,
+                                      version_repr_bytes)
+            content = content.replace(
+                (package.encode('utf8') + b" " +
+                 existing.public().encode('utf8')),
+                (package.encode('utf8') + b" " +
+                 v.public().encode('utf8')))
+
+        # Replace NEXT Version calls with the new one
+        content = content.replace(NEXT_repr_bytes,
+                                  version_repr_bytes)
+        content = content.replace(NEXT_repr_bytes.replace(b"'", b'"'),
+                                  version_repr_bytes)
+
+        # Replace <package> NEXT with <package> <public>
+        content = content.replace(package.encode('utf8') + b" NEXT",
+                                  (package.encode('utf8') + b" " +
+                                   v.public().encode('utf8')))
+
+        if content != original_content:
+            _print("Updating %s" % (x.path,))
+            with x.open('w') as f:
+                f.write(content)
+
+    _print("Updating %s/_version.py" % (path.path))
+    with path.child("_version.py").open('w') as f:
+        f.write(
+            (_VERSIONPY_TEMPLATE % (
+                package, package, version_repr)).encode('utf8'))
+
+
+@click.command()
+@click.argument('package')
+@click.option('--path', default=None)
+@click.option('--newversion', default=None)
+@click.option('--patch', is_flag=True)
+@click.option('--rc', is_flag=True)
+@click.option('--dev', is_flag=True)
+@click.option('--create', is_flag=True)
+def run(*args, **kwargs):
+    return _run(*args, **kwargs)
+
+
+if __name__ == '__main__':  # pragma: no cover
+    run()