pax_global_header00006660000000000000000000000064144513123250014512gustar00rootroot0000000000000052 comment=c3bc66cbea65938d0a5711eeb535e2d6ca4d93be looseversion-1.3.0/000077500000000000000000000000001445131232500142425ustar00rootroot00000000000000looseversion-1.3.0/.github/000077500000000000000000000000001445131232500156025ustar00rootroot00000000000000looseversion-1.3.0/.github/workflows/000077500000000000000000000000001445131232500176375ustar00rootroot00000000000000looseversion-1.3.0/.github/workflows/package.yml000066400000000000000000000034651445131232500217650ustar00rootroot00000000000000name: build-test-deploy on: push: branches: [main] tags: ["*"] pull_request: {branches: [main]} schedule: - cron: '0 0 * * MON' jobs: build: runs-on: ubuntu-latest strategy: matrix: python: [3] steps: - uses: actions/checkout@v3 - name: Set up Python ${{ matrix.python }} uses: actions/setup-python@v4 with: python-version: ${{ matrix.python }} - name: Build package run: pipx run build - name: Check package metadata run: pipx run twine check dist/* - name: Save packages uses: actions/upload-artifact@v3 with: name: dist path: dist/ test: runs-on: ubuntu-latest strategy: matrix: python: - "3.7" - "3.8" - "3.9" - "3.10" - "3.11" - "3.12" - "pypy-3.7" steps: - uses: actions/checkout@v3 - name: Set up Python ${{ matrix.python }} uses: actions/setup-python@v4 with: python-version: ${{ matrix.python }} allow-prereleases: true - name: Install tox run: pip install --upgrade pip tox tox-gh-actions - name: Test run: tox deploy: needs: [build, test] runs-on: ubuntu-latest permissions: # IMPORTANT: this permission is mandatory for trusted publishing id-token: write steps: - name: Load packages uses: actions/download-artifact@v3 with: name: dist path: dist/ - name: Test PyPI upload uses: pypa/gh-action-pypi-publish@release/v1 with: repository_url: https://test.pypi.org/legacy/ skip_existing: true - name: Upload to PyPI (on tags) if: github.event_name == 'push' && startsWith(github.ref, 'refs/tags') uses: pypa/gh-action-pypi-publish@release/v1 looseversion-1.3.0/.gitignore000066400000000000000000000034171445131232500162370ustar00rootroot00000000000000# Byte-compiled / optimized / DLL files __pycache__/ *.py[cod] *$py.class # C extensions *.so # Distribution / packaging .Python build/ develop-eggs/ dist/ downloads/ eggs/ .eggs/ lib/ lib64/ parts/ sdist/ var/ wheels/ pip-wheel-metadata/ share/python-wheels/ *.egg-info/ .installed.cfg *.egg MANIFEST # PyInstaller # Usually these files are written by a python script from a template # before PyInstaller builds the exe, so as to inject date/other infos into it. *.manifest *.spec # Installer logs pip-log.txt pip-delete-this-directory.txt # Unit test / coverage reports htmlcov/ .tox/ .nox/ .coverage .coverage.* .cache nosetests.xml coverage.xml *.cover *.py,cover .hypothesis/ .pytest_cache/ # Translations *.mo *.pot # Django stuff: *.log local_settings.py db.sqlite3 db.sqlite3-journal # Flask stuff: instance/ .webassets-cache # Scrapy stuff: .scrapy # Sphinx documentation docs/_build/ # PyBuilder target/ # Jupyter Notebook .ipynb_checkpoints # IPython profile_default/ ipython_config.py # pyenv .python-version # pipenv # According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control. # However, in case of collaboration, if having platform-specific dependencies or dependencies # having no cross-platform support, pipenv may install dependencies that don't work, or not # install all needed dependencies. #Pipfile.lock # PEP 582; used by e.g. github.com/David-OConnor/pyflow __pypackages__/ # Celery stuff celerybeat-schedule celerybeat.pid # SageMath parsed files *.sage.py # Environments .env .venv env/ venv/ ENV/ env.bak/ venv.bak/ # Spyder project settings .spyderproject .spyproject # Rope project settings .ropeproject # mkdocs documentation /site # mypy .mypy_cache/ .dmypy.json dmypy.json # Pyre type checker .pyre/ .*.swp looseversion-1.3.0/CHANGES.md000066400000000000000000000024711445131232500156400ustar00rootroot00000000000000# Changelog ## Releases ### 1.3.0 (5 Jul 2023) - 2023.07.05 - Restore Python 3 semantics for `LooseVersion`, creating `LooseVersion2` to restore Python 2 semantics. ### 1.2.0 (25 May 2023) - 2023.05.25 - Test on Python 3.12 - Enable installation on Python 2+ - Ensure consistent semantics between Python 2 and 3 ### 1.1.2 (22 Feb 2023) - 2023.02.22 - Revert unintended change in internal version representation ### 1.1.1 (19 Feb 2023) - 2023.02.19 - Restructure package so stubs get installed and detected ### 1.1.0 (19 Feb 2023) - 2023.02.19 - Add type annotations and stubs. ### 1.0.3 (5 Jan 2023) Re-release to ensure tests are bundled in sdist. - 2022.12.11 - Convert to flit package ### 1.0.2 (14 Oct 2022) - 2022.10.14 - Fix package metadata to correctly identify module - 2022.07.24 - Test on Python 3.11 - 2022.05.24 - Add `__main__` section to tests to enable `python tests.py` ### 1.0.1 (16 May 2022) - 2022.05.16 - Add tests.py in sdist - 2022.05.11 - Set up GitHub actions for build/test/upload ### 1.0.0 (11 May 2022) - 2022.05.11 - Import from CPython (last modified 662db125cddbca1db68116c547c290eb3943d98e) - Remove Version base class and StrictVersion - Style with black - Add non-importing check for distutils.version.LooseVersion to maintain compatibility looseversion-1.3.0/LICENSE000066400000000000000000000046721445131232500152600ustar00rootroot00000000000000PYTHON SOFTWARE FOUNDATION LICENSE VERSION 2 -------------------------------------------- 1. This LICENSE AGREEMENT is between the Python Software Foundation ("PSF"), and the Individual or Organization ("Licensee") accessing and otherwise using this software ("Python") in source or binary form and its associated documentation. 2. Subject to the terms and conditions of this License Agreement, PSF hereby grants Licensee a nonexclusive, royalty-free, world-wide license to reproduce, analyze, test, perform and/or display publicly, prepare derivative works, distribute, and otherwise use Python alone or in any derivative version, provided, however, that PSF's License Agreement and PSF's notice of copyright, i.e., "Copyright (c) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012, 2013, 2014, 2015, 2016, 2017, 2018, 2019, 2020, 2021, 2022 Python Software Foundation; All Rights Reserved" are retained in Python alone or in any derivative version prepared by Licensee. 3. In the event Licensee prepares a derivative work that is based on or incorporates Python or any part thereof, and wants to make the derivative work available to others as provided herein, then Licensee hereby agrees to include in any such work a brief summary of the changes made to Python. 4. PSF is making Python available to Licensee on an "AS IS" basis. PSF MAKES NO REPRESENTATIONS OR WARRANTIES, EXPRESS OR IMPLIED. BY WAY OF EXAMPLE, BUT NOT LIMITATION, PSF MAKES NO AND DISCLAIMS ANY REPRESENTATION OR WARRANTY OF MERCHANTABILITY OR FITNESS FOR ANY PARTICULAR PURPOSE OR THAT THE USE OF PYTHON WILL NOT INFRINGE ANY THIRD PARTY RIGHTS. 5. PSF SHALL NOT BE LIABLE TO LICENSEE OR ANY OTHER USERS OF PYTHON FOR ANY INCIDENTAL, SPECIAL, OR CONSEQUENTIAL DAMAGES OR LOSS AS A RESULT OF MODIFYING, DISTRIBUTING, OR OTHERWISE USING PYTHON, OR ANY DERIVATIVE THEREOF, EVEN IF ADVISED OF THE POSSIBILITY THEREOF. 6. This License Agreement will automatically terminate upon a material breach of its terms and conditions. 7. Nothing in this License Agreement shall be deemed to create any relationship of agency, partnership, or joint venture between PSF and Licensee. This License Agreement does not grant permission to use PSF trademarks or trade name in a trademark sense to endorse or promote products or services of Licensee, or any third party. 8. By copying, installing or otherwise using Python, Licensee agrees to be bound by the terms and conditions of this License Agreement. looseversion-1.3.0/README.md000066400000000000000000000023531445131232500155240ustar00rootroot00000000000000# looseversion - Version numbering for anarchists and software realists A backwards/forwards-compatible fork of `distutils.version.LooseVersion`, for times when PEP-440 isn't what you need. The goal of this package is to be a drop-in replacement for the original `LooseVersion`. It implements an identical interface and comparison logic to `LooseVersion`. The only major change is that a `looseversion.LooseVersion` is comparable to a `distutils.version.LooseVersion`, which means tools should not need to worry whether all dependencies that use LooseVersion have migrated. If you are simply comparing versions of Python packages, consider moving to [packaging.version.Version](https://packaging.pypa.io/en/latest/version.html#packaging.version.Version), which follows [PEP-440](https://peps.python.org/pep-0440). `LooseVersion` is better suited to interacting with heterogeneous version schemes that do not follow PEP-440. ## Installation ### From PyPI ``` pip install looseversion ``` ### From source ``` git clone https://github.com/effigies/looseversion.git pip install looseversion/ ``` ## Usage ```Python >>> from looseversion import LooseVersion >>> LooseVersion("1.0.0") < LooseVersion("2.0.0") True >>> LooseVersion("1.0.0") < "2" True ``` looseversion-1.3.0/pyproject.toml000066400000000000000000000012251445131232500171560ustar00rootroot00000000000000[build-system] requires = ["hatchling"] build-backend = "hatchling.build" [project] name = "looseversion" maintainers = [{name = "Chris Markiewicz", email = "effigies@gmail.com"}] version = "1.3.0" description = "Version numbering for anarchists and software realists" readme = "README.md" license = {file = "LICENSE"} classifiers = [ "Programming Language :: Python :: 3", "Development Status :: 6 - Mature", "License :: OSI Approved :: Python Software Foundation License", ] urls = {Homepage = "https://github.com/effigies/looseversion"} [tool.hatch.build] exclude = [".github"] [tool.hatch.build.targets.wheel] packages = ["src/looseversion"] looseversion-1.3.0/src/000077500000000000000000000000001445131232500150315ustar00rootroot00000000000000looseversion-1.3.0/src/looseversion/000077500000000000000000000000001445131232500175605ustar00rootroot00000000000000looseversion-1.3.0/src/looseversion/__init__.py000066400000000000000000000221601445131232500216720ustar00rootroot00000000000000"""Provides classes to represent module version numbers (one class for each style of version numbering). There are currently two such classes implemented: StrictVersion and LooseVersion. Every version number class implements the following interface: * the 'parse' method takes a string and parses it to some internal representation; if the string is an invalid version number, 'parse' raises a ValueError exception * the class constructor takes an optional string argument which, if supplied, is passed to 'parse' * __str__ reconstructs the string that was passed to 'parse' (or an equivalent string -- ie. one that will generate an equivalent version number instance) * __repr__ generates Python code to recreate the version number instance * _cmp compares the current instance with either another instance of the same class or a string (which will be parsed to an instance of the same class, thus must follow the same rules) """ import re import sys # The rules according to Greg Stein: # 1) a version number has 1 or more numbers separated by a period or by # sequences of letters. If only periods, then these are compared # left-to-right to determine an ordering. # 2) sequences of letters are part of the tuple for comparison and are # compared lexicographically # 3) recognize the numeric components may have leading zeroes # # The LooseVersion class below implements these rules: a version number # string is split up into a tuple of integer and string components, and # comparison is a simple tuple comparison. This means that version # numbers behave in a predictable and obvious way, but a way that might # not necessarily be how people *want* version numbers to behave. There # wouldn't be a problem if people could stick to purely numeric version # numbers: just split on period and compare the numbers as tuples. # However, people insist on putting letters into their version numbers; # the most common purpose seems to be: # - indicating a "pre-release" version # ('alpha', 'beta', 'a', 'b', 'pre', 'p') # - indicating a post-release patch ('p', 'pl', 'patch') # but of course this can't cover all version number schemes, and there's # no way to know what a programmer means without asking him. # # The problem is what to do with letters (and other non-numeric # characters) in a version number. The current implementation does the # obvious and predictable thing: keep them as strings and compare # lexically within a tuple comparison. This has the desired effect if # an appended letter sequence implies something "post-release": # eg. "0.99" < "0.99pl14" < "1.0", and "5.001" < "5.001m" < "5.002". # # However, if letters in a version number imply a pre-release version, # the "obvious" thing isn't correct. Eg. you would expect that # "1.5.1" < "1.5.2a2" < "1.5.2", but under the tuple/lexical comparison # implemented here, this just isn't so. # # Two possible solutions come to mind. The first is to tie the # comparison algorithm to a particular set of semantic rules, as has # been done in the StrictVersion class above. This works great as long # as everyone can go along with bondage and discipline. Hopefully a # (large) subset of Python module programmers will agree that the # particular flavour of bondage and discipline provided by StrictVersion # provides enough benefit to be worth using, and will submit their # version numbering scheme to its domination. The free-thinking # anarchists in the lot will never give in, though, and something needs # to be done to accommodate them. # # Perhaps a "moderately strict" version class could be implemented that # lets almost anything slide (syntactically), and makes some heuristic # assumptions about non-digits in version number strings. This could # sink into special-case-hell, though; if I was as talented and # idiosyncratic as Larry Wall, I'd go ahead and implement a class that # somehow knows that "1.2.1" < "1.2.2a2" < "1.2.2" < "1.2.2pl3", and is # just as happy dealing with things like "2g6" and "1.13++". I don't # think I'm smart enough to do it right though. # # In any case, I've coded the test suite for this module (see # ../test/test_version.py) specifically to fail on things like comparing # "1.2a2" and "1.2". That's not because the *code* is doing anything # wrong, it's because the simple, obvious design doesn't match my # complicated, hairy expectations for real-world version numbers. It # would be a snap to fix the test suite to say, "Yep, LooseVersion does # the Right Thing" (ie. the code matches the conception). But I'd rather # have a conception that matches common notions about version numbers. if sys.version_info >= (3,): class _Py2Int(int): """Integer object that compares < any string""" def __gt__(self, other): if isinstance(other, str): return False return super().__gt__(other) def __lt__(self, other): if isinstance(other, str): return True return super().__lt__(other) else: _Py2Int = int class LooseVersion(object): """Version numbering for anarchists and software realists. Implements the standard interface for version number classes as described above. A version number consists of a series of numbers, separated by either periods or strings of letters. When comparing version numbers, the numeric components will be compared numerically, and the alphabetic components lexically. The following are all valid version numbers, in no particular order: 1.5.1 1.5.2b2 161 3.10a 8.02 3.4j 1996.07.12 3.2.pl0 3.1.1.6 2g6 11g 0.960923 2.2beta29 1.13++ 5.5.kw 2.0b1pl0 In fact, there is no such thing as an invalid version number under this scheme; the rules for comparison are simple and predictable, but may not always give the results you want (for some definition of "want"). """ component_re = re.compile(r"(\d+ | [a-z]+ | \.)", re.VERBOSE) def __init__(self, vstring=None): if vstring: self.parse(vstring) def __eq__(self, other): c = self._cmp(other) if c is NotImplemented: return NotImplemented return c == 0 def __lt__(self, other): c = self._cmp(other) if c is NotImplemented: return NotImplemented return c < 0 def __le__(self, other): c = self._cmp(other) if c is NotImplemented: return NotImplemented return c <= 0 def __gt__(self, other): c = self._cmp(other) if c is NotImplemented: return NotImplemented return c > 0 def __ge__(self, other): c = self._cmp(other) if c is NotImplemented: return NotImplemented return c >= 0 def parse(self, vstring): # I've given up on thinking I can reconstruct the version string # from the parsed tuple -- so I just store the string here for # use by __str__ self.vstring = vstring components = [x for x in self.component_re.split(vstring) if x and x != "."] for i, obj in enumerate(components): try: components[i] = int(obj) except ValueError: pass self.version = components def __str__(self): return self.vstring def __repr__(self): return "LooseVersion ('%s')" % str(self) def _cmp(self, other): other = self._coerce(other) if other is NotImplemented: return NotImplemented if self.version == other.version: return 0 if self.version < other.version: return -1 if self.version > other.version: return 1 return NotImplemented @classmethod def _coerce(cls, other): if isinstance(other, cls): return other elif isinstance(other, str): return cls(other) elif "distutils" in sys.modules: # Using this check to avoid importing distutils and suppressing the warning try: from distutils.version import LooseVersion as deprecated except ImportError: return NotImplemented if isinstance(other, deprecated): return cls(str(other)) return NotImplemented class LooseVersion2(LooseVersion): """LooseVersion variant that restores Python 2 semantics In Python 2, comparing LooseVersions where paired components could be string and int always resulted in the string being "greater". In Python 3, this produced a TypeError. """ def parse(self, vstring): # I've given up on thinking I can reconstruct the version string # from the parsed tuple -- so I just store the string here for # use by __str__ self.vstring = vstring components = [x for x in self.component_re.split(vstring) if x and x != "."] for i, obj in enumerate(components): try: components[i] = _Py2Int(obj) except ValueError: pass self.version = components looseversion-1.3.0/src/looseversion/__init__.pyi000066400000000000000000000010571445131232500220450ustar00rootroot00000000000000from re import Pattern from typing import List, Union class LooseVersion: component_re: Pattern[str] vstring: str version: List[Union[str, int]] def __init__(self, vstring: Union[str, None] = ...) -> None: ... def __eq__(self, other: object) -> bool: ... def __lt__(self, other: object) -> bool: ... def __le__(self, other: object) -> bool: ... def __gt__(self, other: object) -> bool: ... def __ge__(self, other: object) -> bool: ... def parse(self, vstring: str) -> None: ... class LooseVersion2(LooseVersion): ... looseversion-1.3.0/src/looseversion/py.typed000066400000000000000000000000001445131232500212450ustar00rootroot00000000000000looseversion-1.3.0/tests.py000066400000000000000000000063601445131232500157630ustar00rootroot00000000000000import sys import warnings import pytest import looseversion as lv have_distutils = True with warnings.catch_warnings(): warnings.simplefilter("ignore") try: from distutils import version as dv except ImportError: have_distutils = False @pytest.mark.skipif(not have_distutils, reason="Needs distutils") @pytest.mark.parametrize("v1, v2", [("0.0.0", "0.0.0"), ("0.0.0", "1.0.0")]) @pytest.mark.parametrize("lvtype", [lv.LooseVersion, lv.LooseVersion2]) def test_LooseVersion_compat(v1, v2, lvtype): vend1, vend2 = lvtype(v1), lvtype(v2) with warnings.catch_warnings(): warnings.simplefilter("ignore") orig1, orig2 = dv.LooseVersion(v1), dv.LooseVersion(v2) assert vend1 == orig1 assert orig1 == vend1 assert vend2 == orig2 assert orig2 == vend2 assert (vend1 == orig2) == (v1 == v2) assert (vend1 < orig2) == (v1 < v2) assert (vend1 > orig2) == (v1 > v2) assert (vend1 <= orig2) == (v1 <= v2) assert (vend1 >= orig2) == (v1 >= v2) assert (orig1 == vend2) == (v1 == v2) assert (orig1 < vend2) == (v1 < v2) assert (orig1 > vend2) == (v1 > v2) assert (orig1 <= vend2) == (v1 <= v2) assert (orig1 >= vend2) == (v1 >= v2) # Adapted from Cpython:Lib/distutils/tests/test_version.py @pytest.mark.parametrize( "v1,v2,result", [ ("1.5.1", "1.5.2b2", -1), ("161", "3.10a", 1), ("8.02", "8.02", 0), ("3.4j", "1996.07.12", -1), ("3.2.pl0", "3.1.1.6", 1), ("2g6", "11g", -1), ("0.960923", "2.2beta29", -1), ("1.13++", "5.5.kw", -1), ], ) @pytest.mark.parametrize("lvtype", [lv.LooseVersion, lv.LooseVersion2]) def test_cmp(v1, v2, result, lvtype): loosev1 = lvtype(v1) loosev2 = lvtype(v2) assert loosev1._cmp(loosev2) == result assert loosev1._cmp(v2) == result assert loosev2._cmp(loosev1) == -result assert loosev2._cmp(v1) == -result assert loosev1._cmp(object()) == NotImplemented assert loosev2._cmp(object()) == NotImplemented @pytest.mark.parametrize( "vstring,version", [ ("1.5.1", [1, 5, 1]), ("1.5.2b2", [1, 5, 2, "b", 2]), ("161", [161]), ("3.10a", [3, 10, "a"]), ("1.13++", [1, 13, "++"]), ], ) @pytest.mark.parametrize("lvtype", [lv.LooseVersion, lv.LooseVersion2]) def test_split(vstring, version, lvtype): # Regression test to ensure we don't accidentally break parsing (again) # This can be changed if the version representation changes v = lvtype(vstring) assert v.vstring == vstring assert v.version == version @pytest.mark.parametrize( "v1,v2,result", [ ("0.3@v0.3", "0.3.1@v0.3.1", 1), ("0.3.1@v0.3.1", "0.3@v0.3", -1), ("13.0-beta3", "13.0.1", 1), ("13.0.1", "13.0-beta3", -1), ], ) def test_py2_rules(v1, v2, result): """Python 2 did allow strings and numbers to be compared. Verify consistent, generally unintuitive behavior. """ loosev1 = lv.LooseVersion2(v1) loosev2 = lv.LooseVersion2(v2) assert loosev1._cmp(loosev2) == result assert loosev1._cmp(v2) == result assert loosev2._cmp(loosev1) == -result assert loosev2._cmp(v1) == -result if __name__ == "__main__": sys.exit(pytest.main([__file__] + sys.argv[1:])) looseversion-1.3.0/tox.ini000066400000000000000000000007661445131232500155660ustar00rootroot00000000000000[tox] isolated_build = true envlist = py{36,37,38,39,310,311,312,py3}, type skip_missing_interpreters = True [testenv] description = Run the tests under {basepython} deps = pytest commands = pytest tests.py {posargs} [testenv:type] description = Check typing of looseversion deps = mypy pytest commands = mypy src tests.py {posargs} stubtest looseversion [gh-actions] python = 3.6: py36 3.7: py37 3.8: py38 3.9: py39 3.10: py310 3.11: py311, type 3.12: py312 pypy-3.7: pypy3