pax_global_header00006660000000000000000000000064145605042610014515gustar00rootroot0000000000000052 comment=59e70d1d5d18145f5cfa078b69996102bbd8c3c6 awesomeversion-24.2.0/000077500000000000000000000000001456050426100146505ustar00rootroot00000000000000awesomeversion-24.2.0/.codecov.yml000066400000000000000000000004171456050426100170750ustar00rootroot00000000000000comment: false codecov: branch: main coverage: precision: 2 status: patch: off project: default: target: 100% parsers: gcov: branch_detection: conditional: yes loop: yes method: no macro: no ignore: - "tests"awesomeversion-24.2.0/.devcontainer.json000066400000000000000000000020561456050426100203050ustar00rootroot00000000000000{ "name": "AwesomeVersion", "image": "mcr.microsoft.com/vscode/devcontainers/python:0-3.11", "postCreateCommand": "make requirements", "customizations": { "vscode": { "settings": { "python.defaultInterpreterPath": "/usr/local/bin/python", "python.linting.enabled": true, "python.linting.pylintEnabled": true, "python.formatting.autopep8Path": "/usr/local/py-utils/bin/autopep8", "python.formatting.blackPath": "/usr/local/py-utils/bin/black", "python.formatting.yapfPath": "/usr/local/py-utils/bin/yapf", "python.linting.banditPath": "/usr/local/py-utils/bin/bandit", "python.linting.flake8Path": "/usr/local/py-utils/bin/flake8", "python.linting.mypyPath": "/usr/local/py-utils/bin/mypy", "python.linting.pycodestylePath": "/usr/local/py-utils/bin/pycodestyle", "python.linting.pydocstylePath": "/usr/local/py-utils/bin/pydocstyle", "python.linting.pylintPath": "/usr/local/py-utils/bin/pylint" }, "extensions": [ "ms-python.python", "ms-python.vscode-pylance", "GitHub.copilot" ] } } } awesomeversion-24.2.0/.gitattributes000066400000000000000000000000221456050426100175350ustar00rootroot00000000000000* text=auto eol=lfawesomeversion-24.2.0/.github/000077500000000000000000000000001456050426100162105ustar00rootroot00000000000000awesomeversion-24.2.0/.github/ISSUE_TEMPLATE/000077500000000000000000000000001456050426100203735ustar00rootroot00000000000000awesomeversion-24.2.0/.github/ISSUE_TEMPLATE/bug.yml000066400000000000000000000021061456050426100216720ustar00rootroot00000000000000name: "Report a bug with AwesomeVersion" description: Report an issue with AwesomeVersion labels: "bug" body: - type: textarea attributes: label: The problem placeholder: >- Describe the issue you are experiencing here to communicate to the maintainers. Tell us what you were trying to do and what happened. validations: required: true - type: markdown attributes: value: | ## Environment - type: input attributes: label: Operating system validations: required: true - type: dropdown validations: required: true attributes: label: Python version options: - 3.8 - 3.9 - "3.10" - "3.11" - type: textarea validations: required: true attributes: label: Problem-relevant code description: >- A minimal example to reproduce the bug render: python - type: textarea attributes: label: Traceback/Error logs description: >- If you come across any trace or error logs, please provide them. render: txt - type: textarea attributes: label: Additional informationawesomeversion-24.2.0/.github/ISSUE_TEMPLATE/config.yml000066400000000000000000000000331456050426100223570ustar00rootroot00000000000000blank_issues_enabled: falseawesomeversion-24.2.0/.github/ISSUE_TEMPLATE/feature_request.yml000066400000000000000000000012241456050426100243200ustar00rootroot00000000000000name: "Feature request for AwesomeVersion" description: Suggest a feature/change to be added to AwesomeVersion labels: "enhancement" body: - type: textarea validations: required: true attributes: label: The idea description: > A good description of what you are suggesting. - type: textarea validations: required: true attributes: label: Implementation description: > How do you see this being implemented? - type: textarea attributes: label: Alternatives description: > Are there any alternative solutions or features you've considered? - type: textarea attributes: label: Additional contextawesomeversion-24.2.0/.github/PULL_REQUEST_TEMPLATE.md000066400000000000000000000033531456050426100220150ustar00rootroot00000000000000 ## Proposed change ## Type of change - [ ] Dependency upgrade - [ ] Bugfix (non-breaking change which fixes an issue) - [ ] New feature (which adds functionalit) - [ ] Breaking change (fix/feature causing existing functionality to break) - [ ] Code quality improvements to existing code or addition of tests ## Additional information - This PR fixes or closes issue: fixes # - This PR is related to issue: - Link to documentation pull request: ## Checklist - [ ] The code change is tested and works locally. - [ ] Local tests pass. - [ ] There is no commented out code in this PR. - [ ] The code has been formatted using Black (`make lint`) - [ ] Tests have been added to verify that the new code works. awesomeversion-24.2.0/.github/dependabot.yml000066400000000000000000000004261456050426100210420ustar00rootroot00000000000000version: 2 updates: - package-ecosystem: pip directory: "/" schedule: interval: daily time: "06:00" open-pull-requests-limit: 10 - package-ecosystem: "github-actions" directory: "/" schedule: interval: daily time: "06:00" open-pull-requests-limit: 10awesomeversion-24.2.0/.github/release.yml000066400000000000000000000000661456050426100203550ustar00rootroot00000000000000changelog: exclude: labels: - dependenciesawesomeversion-24.2.0/.github/workflows/000077500000000000000000000000001456050426100202455ustar00rootroot00000000000000awesomeversion-24.2.0/.github/workflows/actions.yml000066400000000000000000000040731456050426100224340ustar00rootroot00000000000000name: Actions on: pull_request: branches: - main push: branches: - main jobs: lint: name: Lint runs-on: ubuntu-latest steps: - name: πŸ“₯ Checkout the repository uses: actions/checkout@v4.1.1 - name: πŸ›  Set up Python 3 uses: actions/setup-python@v5 id: python with: python-version: 3.x - name: πŸ“¦ Install dependencies run: make requirements - name: πŸ–€ Lint with Black run: make black-check - name: 🐍 Lint with mypy run: make mypy - name: ✨ Lint with pylint run: make pylint - name: πŸ”€ Lint with isort run: make isort-check test: name: Test with Python ${{ matrix.entry.version }} needs: lint runs-on: ubuntu-latest strategy: fail-fast: false matrix: entry: - version: "3.8" - version: "3.9" - version: "3.10" - version: "3.11" - version: "3.12" prereleases: true steps: - name: πŸ“₯ Checkout the repository uses: actions/checkout@v4.1.1 - name: πŸ› οΈ Set up Python ${{ matrix.entry.version }} uses: actions/setup-python@v5 with: python-version: ${{ matrix.entry.version }} allow-prereleases: ${{ matrix.entry.prereleases || false }} - name: πŸ“¦ Install dependencies run: make requirements - name: πŸƒ Run tests run: make test - name: πŸ›  Build run: make build coverage: name: Upload coverage to Codecov needs: test runs-on: ubuntu-latest steps: - name: πŸ“₯ Checkout the repository uses: actions/checkout@v4.1.1 with: depth: 0 - name: πŸ› οΈ Set up Python uses: actions/setup-python@v5 with: python-version: 3.x - name: πŸ“¦ Install dependencies run: make requirements - name: πŸ“€ Upload coverage to Codecov run: | make coverage curl -sfSL https://codecov.io/bash | bash -awesomeversion-24.2.0/.github/workflows/codeql-analysis.yml000066400000000000000000000011651456050426100240630ustar00rootroot00000000000000name: "CodeQL" on: push: branches: - main pull_request: branches: - main schedule: - cron: '19 14 * * 0' jobs: analyze: name: Analyze runs-on: ubuntu-latest permissions: actions: read contents: read security-events: write steps: - name: Checkout repository uses: actions/checkout@v4.1.1 - name: Initialize CodeQL uses: github/codeql-action/init@v3 with: languages: 'python' - name: Autobuild uses: github/codeql-action/autobuild@v3 - name: Perform CodeQL Analysis uses: github/codeql-action/analyze@v3 awesomeversion-24.2.0/.github/workflows/demo.yml000066400000000000000000000012401456050426100217110ustar00rootroot00000000000000name: Deploy demo on: push: branches: - "main" permissions: contents: read pages: write id-token: write concurrency: group: "pages" cancel-in-progress: true jobs: deploy: environment: name: github-pages url: ${{ steps.deployment.outputs.page_url }} runs-on: ubuntu-latest steps: - name: Checkout uses: actions/checkout@v4.1.1 - name: Setup Pages uses: actions/configure-pages@v4 - name: Upload artifact uses: actions/upload-pages-artifact@v3 with: path: 'demo' - name: Deploy to GitHub Pages id: deployment uses: actions/deploy-pages@v4 awesomeversion-24.2.0/.github/workflows/release.yml000066400000000000000000000016141456050426100224120ustar00rootroot00000000000000name: Release on: release: types: - published permissions: {} jobs: deploy: runs-on: ubuntu-latest name: Build package environment: name: release url: https://pypi.org/project/awesomeversion permissions: # Used to authenticate to PyPI via OIDC. id-token: write steps: - name: πŸ“₯ Checkout the repository uses: actions/checkout@v4.1.1 - name: πŸ›  Set up Python uses: actions/setup-python@v5 id: python with: python-version: 3.x - name: πŸ“¦ Install poetry run: make install-poetry - name: πŸ”’ Set version number run: | export version=${{ github.ref }} poetry version "${version##*/}" - name: πŸ›  Build run: poetry build --no-interaction - name: πŸš€ Publish to PyPi uses: pypa/gh-action-pypi-publish@v1.8.11 awesomeversion-24.2.0/.gitignore000066400000000000000000000001351456050426100166370ustar00rootroot00000000000000__pycache__ __target__ .mypy_cache .pytest_cache .coverage coverage.xml dist build *.egg-infoawesomeversion-24.2.0/LICENCE.md000066400000000000000000000020641456050426100162360ustar00rootroot00000000000000MIT License Copyright (c) 2020-2022 Joakim SΓΈrensen Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.awesomeversion-24.2.0/Makefile000066400000000000000000000025071456050426100163140ustar00rootroot00000000000000.DEFAULT_GOAL := help help: ## Shows this help message @printf "\033[1m%s\033[36m %s\033[32m %s\033[0m \n\n" "Development environment for" "ludeeus/awesomeversion" ""; @awk 'BEGIN {FS = ":.*##";} /^[a-zA-Z_-]+:.*?##/ { printf " \033[36m make %-25s\033[0m %s\n", $$1, $$2 } /^##@/ { printf "\n\033[1m%s\033[0m\n", substr($$0, 5) } ' $(MAKEFILE_LIST); @echo requirements: install-poetry ## Install requirements @poetry install @poetry check install: ## Install awesomeversion @poetry install install-poetry: @curl -sSL https://install.python-poetry.org | python3 - test: ## Run all tests @poetry run pytest tests -rxf -x -vv -l -s --cov=./ --cov-report=xml build: ## Build the package @poetry build lint: isort black mypy pylint ## Lint all files snapshot-update: ## Update test snapshot files @poetry run pytest tests --snapshot-update coverage: ## Check the coverage of the package @poetry run pytest tests -rxf -x -v -l --cov=./ --cov-report=xml > /dev/null @poetry run coverage report isort: @poetry run isort awesomeversion tests isort-check: @poetry run isort awesomeversion tests --check-only black: @poetry run black --fast awesomeversion tests black-check: @poetry run black --check --fast awesomeversion tests mypy: @poetry run mypy --strict awesomeversion tests pylint: @poetry run pylint awesomeversion testsawesomeversion-24.2.0/README.md000066400000000000000000000173301456050426100161330ustar00rootroot00000000000000# AwesomeVersion [![codecov](https://codecov.io/gh/ludeeus/awesomeversion/branch/main/graph/badge.svg)](https://codecov.io/gh/ludeeus/awesomeversion) ![python version](https://img.shields.io/badge/Python-3.8=><=3.12-blue.svg) ![dependencies](https://img.shields.io/badge/Dependencies-0-blue.svg) [![PyPI](https://img.shields.io/pypi/v/awesomeversion)](https://pypi.org/project/awesomeversion) ![Actions](https://github.com/ludeeus/awesomeversion/workflows/Actions/badge.svg?branch=main) _One version package to rule them all, One version package to find them, One version package to bring them all, and in the darkness bind them._ Make anything a version object, and compare against a vast section of other version formats. ## Installation ```bash python3 -m pip install awesomeversion ``` ## AwesomeVersion class The AwesomeVersion class takes a version as the first argument, you can also pass in additional kwargs to customize the version object. Argument | Description --- | --- `version` | The version string to parse. `ensure_strategy` | Match the `AwesomeVersion` object against spesific strategies when creating if. If it does not match `AwesomeVersionStrategyException` will be raised `find_first_match` | If True, the version given will be scanned for the first match of the given `ensure_strategy`. Raises `AwesomeVersionStrategyException` If it is not found for any of the given strategies. ## AwesomeVersion methods
AwesomeVersion.in_range This is a helper method to check if the version is in a range. This method takes two arguments, `lowest` and `highest`, both are required, and returns a boolean. > **Note** This method is the same as doing `lowest <= AwesomeVersion <= highest` Example: ```python from awesomeversion import AwesomeVersion print(AwesomeVersion("1.2.2").in_range("1.2.1", "1.3")) > True print(AwesomeVersion("1.2.0").in_range("1.2.1", "1.3")) > False ```
AwesomeVersion.diff This is a helper method to get the difference between two versions. This method takes one argument which is the version to compare against, and returns a `AwesomeVersionDiff` object. > **Note** This method is the same as doing `AwesomeVersion - version` Example: ```python from awesomeversion import AwesomeVersion > print(AwesomeVersion("1.0").diff("2.1")) AwesomeVersionDiff(major=True, minor=True, patch=False, modifier=False, strategy=False) ```
AwesomeVersion.section This is a helper method to get a section of the version. This method takes one argument which is the section to get, and returns an integer representing it (or 0 if it does not exist). Example: ```python from awesomeversion import AwesomeVersion > print(AwesomeVersion("1.0").section(0)) 1 ```
## AwesomeVersion properties Argument | Description --- | --- `alpha` | This is a boolean representing if the version is an alpha version. `beta` | This is a boolean representing if the version is a beta version. `dev` | This is a boolean representing if the version is a dev version. `major` | This is an `AwesomeVersion` object representing the major version or `None` if not present. `micro` | This is an `AwesomeVersion` object representing the micro version or `None` if not present. `minor` | This is an `AwesomeVersion` object representing the minor version or `None` if not present. `modifier_type` | This is a string representing the modifier type of the version or `None` if not present. `modifier` | This is a string representing the modifier of the version or `None` if not present. `patch` | This is an `AwesomeVersion` object representing the patch version or `None` if not present. `prefix` | This is the prefix of the version or `None` if not present. `release_candidate` | This is a boolean representing if the version is a release candidate version. `simple` | This is a boolean representing if the version is a simple version. `strategy_description` | This is a `AwesomeVersionStrategyDescription` object representing the strategy description of the version. `strategy` | This is a `AwesomeVersionStrategy` object representing the strategy of the version. `string` | This is the string representation of the version (without the v prefix if present). `valid` | This is a boolean representing if the version is valid (not unknown strategy). `year` | This is alias to `major`, and is an `AwesomeVersion` object representing the year. ## Example usage Here are some examples of how you can use this package, more examples can be found in the `tests` directory.
Basic compare ```python from awesomeversion import AwesomeVersion current = AwesomeVersion("1.2.2") upstream = AwesomeVersion("1.2.3") print(upstream > current) > True ```
Compare beta version ```python from awesomeversion import AwesomeVersion current = AwesomeVersion("2021.1.0") upstream = AwesomeVersion("2021.1.0b2") print(current > upstream) > True ```
Check if version is a beta version ```python from awesomeversion import AwesomeVersion print(AwesomeVersion("1.2.3b0").beta) > True print(AwesomeVersion("1.2.3").beta) > False ```
Use AwesomeVersion with with ... ```python from awesomeversion import AwesomeVersion with AwesomeVersion("20.12.0") as current: with AwesomeVersion("20.12.1") as upstream: print(upstream > current) > True ```
Compare AwesomeVersion with other non-AwesomeVersion formats ```python from awesomeversion import AwesomeVersion base = AwesomeVersion("20.12.0") print(base > "20.12.1") > False print(base > "19") > True print(base > 5) > True ```
## General behavior You can test your versions on the [demo page][awesomeversion_demo]. ### Modifiers When comparing versions with modifiers, if the base version is the same the modifier will be used to determine the order. If one of the versions do not have a modifier, the one without will be considered newer. The order of the modifiers are: - No modifier - RC - Beta - Alpha - Dev
Examples ```python from awesomeversion import AwesomeVersion print(AwesomeVersion("1.0.0") > AwesomeVersion("1.0.0b6")) > True print(AwesomeVersion("1.0.0") > AwesomeVersion("1.0.0.dev6")) > True print(AwesomeVersion("1.0.0.dev19") > AwesomeVersion("1.0.0b4")) > False ```
### Special versions (container) There are some special versions for container that are handled differently than typical version formats. The special versions are in the following order: - `dev` (newest) - `latest` - `beta` - `stable` (oldest) If only the first version is this special version, it will be considered newer. If only the second version is this special version, it will be considered older.
Examples ```python from awesomeversion import AwesomeVersion print(AwesomeVersion("latest") > AwesomeVersion("1.0.0b6")) > True print(AwesomeVersion("1.0.0") > AwesomeVersion("latest")) > False print(AwesomeVersion("stable") > AwesomeVersion("latest")) > False print(AwesomeVersion("beta") > AwesomeVersion("dev")) > False ```
## Contribute **All** contributions are welcome! 1. Fork the repository 2. Clone the repository locally and open the devcontainer or use GitHub codespaces 3. Do your changes 4. Lint the files with `make lint` 5. Ensure all tests passes with `make test` 6. Ensure 100% coverage with `make coverage` 7. Commit your work, and push it to GitHub 8. Create a PR against the `main` branch [awesomeversion_demo]: https://ludeeus.github.io/awesomeversion/awesomeversion-24.2.0/awesomeversion/000077500000000000000000000000001456050426100177165ustar00rootroot00000000000000awesomeversion-24.2.0/awesomeversion/__init__.py000066400000000000000000000010311456050426100220220ustar00rootroot00000000000000"""Initialize the AwesomeVersion package.""" from .awesomeversion import AwesomeVersion, AwesomeVersionDiff from .exceptions import ( AwesomeVersionCompareException, AwesomeVersionException, AwesomeVersionStrategyException, ) from .strategy import COMPARABLE_STRATEGIES, AwesomeVersionStrategy __all__ = [ "AwesomeVersion", "AwesomeVersionCompareException", "AwesomeVersionDiff", "AwesomeVersionException", "AwesomeVersionStrategy", "AwesomeVersionStrategyException", "COMPARABLE_STRATEGIES", ] awesomeversion-24.2.0/awesomeversion/awesomeversion.py000066400000000000000000000432351456050426100233450ustar00rootroot00000000000000"""AwesomeVersion.""" from __future__ import annotations from typing import TYPE_CHECKING, Any, Dict from warnings import warn from .comparehandlers.container import compare_handler_container from .comparehandlers.modifier import compare_handler_semver_modifier from .comparehandlers.sections import compare_handler_sections from .comparehandlers.simple import compare_handler_simple from .exceptions import AwesomeVersionCompareException, AwesomeVersionStrategyException from .strategy import ( VERSION_STRATEGIES, VERSION_STRATEGIES_DICT, AwesomeVersionStrategy, AwesomeVersionStrategyDescription, ) from .utils.regex import ( RE_DIGIT, RE_MODIFIER, RE_SIMPLE, compile_regex, generate_full_string_regex, ) if TYPE_CHECKING: from .typing import EnsureStrategyIterableType, EnsureStrategyType, VersionType class AwesomeVersion(str): """ AwesomeVersion class. """ _version: str = "" _modifier: str | None = None _modifier_type: str | None = None _sections: int | None = None _simple: bool | None = None _ensure_strategy: EnsureStrategyIterableType = [] def __init__( self, # pylint: disable=unused-argument version: VersionType, *args: Any, ensure_strategy: EnsureStrategyType = None, find_first_match: bool = False, **kwargs: Any, ) -> None: """ Initialize AwesomeVersion. **args**: version: The version to create a AwesomeVersion object from **kwargs**: ensure_strategy: Match the AwesomeVersion object against spesific strategies when creating if. If it does not match AwesomeVersionStrategyException will be raised find_first_match: If True, the version given will be scanned for the first match of the given ensure_strategy. Raises AwesomeVersionStrategyException If it is not found for any of the given strategies. """ if args: warn( "Positional argument for ensure_strategy is deprecated. " "This will be removed in 2023, use keyword argument instead", category=DeprecationWarning, stacklevel=2, ) ensure_strategy = args[0] if len(args) == 2: warn( "Positional argument for find_first_match is deprecated. " "This will be removed in 2023, use keyword argument instead", category=DeprecationWarning, stacklevel=2, ) find_first_match = args[1] self._version = ( version._version if isinstance(version, AwesomeVersion) else str(version) ) if isinstance(self._version, str): self._version = self._version.strip() if find_first_match and not ensure_strategy: warn( "Can not use find_first_match without ensure_strategy", stacklevel=2, ) if ensure_strategy is not None: self._ensure_strategy = ensure_strategy = ( ensure_strategy if isinstance(ensure_strategy, (list, tuple)) else [ensure_strategy] ) if AwesomeVersionStrategy.UNKNOWN in ensure_strategy: raise AwesomeVersionStrategyException( f"Can't use {AwesomeVersionStrategy.UNKNOWN.value} as ensure_strategy" ) if find_first_match: for strategy in self._ensure_strategy or []: description = VERSION_STRATEGIES_DICT[strategy] match = compile_regex(description.regex_string).search( self._version ) if match is not None: self._version = match.group(0) if self.strategy not in ensure_strategy: raise AwesomeVersionStrategyException( f"Strategy {self.strategy.value} does not match " f"{[strategy.value for strategy in ensure_strategy]} for {version}" ) if self._version and self._version[-1] == ".": self._version = self._version[:-1] str.__init__(self._version) def __new__( cls, version: str, *_: Any, **__: Any, ) -> AwesomeVersion: """Create a new AwesomeVersion object.""" return super().__new__(cls, version) def __enter__(self) -> AwesomeVersion: return self def __exit__(self, *_: Any, **__: Any) -> None: pass def __repr__(self) -> str: return f"" def __str__(self) -> str: return str(self._version) def __eq__(self, compareto: VersionType) -> bool: """Check if equals to.""" if isinstance(compareto, (str, float, int)): compareto = AwesomeVersion(compareto) if not isinstance(compareto, AwesomeVersion): raise AwesomeVersionCompareException("Not a valid AwesomeVersion object") return self.string == compareto.string def __lt__(self, compareto: VersionType) -> bool: """Check if less than.""" if isinstance(compareto, (str, float, int)): compareto = AwesomeVersion(compareto) if not isinstance(compareto, AwesomeVersion): raise AwesomeVersionCompareException("Not a valid AwesomeVersion object") if self.string == compareto.string: return False if AwesomeVersionStrategy.UNKNOWN in (self.strategy, compareto.strategy): raise AwesomeVersionCompareException( f"Can't compare <{self.strategy.value} {self._version}> and " f"<{compareto.strategy.value} {compareto._version}>" ) return self._compare_versions(compareto, self) def __gt__(self, compareto: VersionType) -> bool: """Check if greater than.""" if isinstance(compareto, (str, float, int)): compareto = AwesomeVersion(compareto) if not isinstance(compareto, AwesomeVersion): raise AwesomeVersionCompareException("Not a valid AwesomeVersion object") if self.string == compareto.string: return False if AwesomeVersionStrategy.UNKNOWN in (self.strategy, compareto.strategy): raise AwesomeVersionCompareException( f"Can't compare <{self.strategy.value} {self._version}> and " f"<{compareto.strategy.value} {compareto._version}>" ) return self._compare_versions(self, compareto) def __ne__(self, compareto: object) -> bool: return not self.__eq__(compareto) def __le__(self, compareto: object) -> bool: return self.__eq__(compareto) or self.__lt__(compareto) def __ge__(self, compareto: object) -> bool: return self.__eq__(compareto) or self.__gt__(compareto) def __sub__(self, compareto: object) -> AwesomeVersionDiff: return self.diff(compareto) def __hash__(self) -> int: return str.__hash__(self.string) def diff(self, compareto: VersionType) -> AwesomeVersionDiff: """Return a dictionary with differences between 2 AwesomeVersion objects.""" if isinstance(compareto, (str, float, int)): compareto = AwesomeVersion(compareto) if not isinstance(compareto, AwesomeVersion): raise AwesomeVersionCompareException("Not a valid AwesomeVersion object") return AwesomeVersionDiff( { "major": str(self.major) != str(compareto.major), "minor": str(self.minor) != str(compareto.minor), "patch": str(self.patch) != str(compareto.patch), "modifier": self.modifier != compareto.modifier, "strategy": self.strategy != compareto.strategy, } ) def in_range(self, lowest: VersionType, highest: VersionType) -> bool: """Check if version is in range.""" if isinstance(lowest, (str, float, int)): lowest = AwesomeVersion(lowest) if isinstance(highest, (str, float, int)): highest = AwesomeVersion(highest) if not isinstance(lowest, AwesomeVersion): raise AwesomeVersionCompareException("Lowest version is not valid") if not isinstance(highest, AwesomeVersion): raise AwesomeVersionCompareException("Highest version is not valid") return lowest <= self <= highest def section(self, idx: int) -> int: """Return the value of the specified section of the version.""" if self.strategy == AwesomeVersionStrategy.HEXVER: return int(self.string, 16) if idx == 0 else 0 if self.sections >= (idx + 1): match = RE_DIGIT.match(self.string.split(".")[idx] or "") if match and match.groups(): return int(match.group(1) or 0) return 0 @staticmethod def _compare_versions(version_a: AwesomeVersion, version_b: AwesomeVersion) -> bool: """Compare versions.""" for handler in ( compare_handler_container, compare_handler_simple, compare_handler_sections, compare_handler_semver_modifier, ): result = handler(version_a, version_b) if result is not None: return result return False @property def string(self) -> str: """Return a string representation of the version.""" if not self._version: return self._version prefix = self.prefix if prefix is None: return self._version return self._version[len(prefix) :] @property def prefix(self) -> str | None: """Return the version prefix if any""" version = self._version for prefix in ("v", "V", "v.", "V."): if version.startswith(prefix): return prefix return None @property def alpha(self) -> bool: """Return a bool to indicate alpha version.""" return "a" in self.modifier if self.modifier else False @property def beta(self) -> bool: """Return a bool to indicate beta version.""" return "b" in self.modifier if self.modifier else "beta" in self.string @property def dev(self) -> bool: """Return a bool to indicate dev version.""" return "d" in self.modifier if self.modifier else "dev" in self.string @property def release_candidate(self) -> bool: """Return a bool to indicate release candidate version.""" return "rc" in self.modifier if self.modifier else "rc" in self.string @property def sections(self) -> int: """Return a int representation of the number of sections in the version.""" if self._sections is not None: return self._sections if self.strategy == AwesomeVersionStrategy.SEMVER: self._sections = 3 else: modifier = self.modifier self._sections = len( [ section.split(self.modifier_type)[-1] for section in self.string.split(".") if section and (modifier is None or section != modifier) ] ) return self._sections @property def major(self) -> AwesomeVersion | None: """ Return a AwesomeVersion representation of the major version. Will return None if the versions is not semver/buildver/calver/simplever/pep440. """ if self.strategy not in ( AwesomeVersionStrategy.SEMVER, AwesomeVersionStrategy.BUILDVER, AwesomeVersionStrategy.CALVER, AwesomeVersionStrategy.SIMPLEVER, AwesomeVersionStrategy.PEP440, ): return None return AwesomeVersion(self.section(0)) @property def minor(self) -> AwesomeVersion | None: """ Return a AwesomeVersion representation of the minor version. Will return None if the versions is not semver/simplever/calver/pep440 Will return None if the version does not have at least 2 sections. """ if ( self.strategy not in ( AwesomeVersionStrategy.SEMVER, AwesomeVersionStrategy.CALVER, AwesomeVersionStrategy.SIMPLEVER, AwesomeVersionStrategy.PEP440, ) or self.sections < 2 ): return None return AwesomeVersion(self.section(1)) @property def patch(self) -> AwesomeVersion | None: """ Return a AwesomeVersion representation of the patch version. Will return None if the versions is not semver/simplever/calver/pep440 Will return None if the version does not have at least 3 sections. """ if ( self.strategy not in ( AwesomeVersionStrategy.SEMVER, AwesomeVersionStrategy.CALVER, AwesomeVersionStrategy.SIMPLEVER, AwesomeVersionStrategy.PEP440, ) or self.sections < 3 ): return None return AwesomeVersion(self.section(2)) @property def micro(self) -> AwesomeVersion | None: """Alias to self.patch""" return self.patch @property def year(self) -> AwesomeVersion | None: """Alias to self.major, here to provide a better name for use in CalVer.""" return self.major @property def valid(self) -> bool: """Return True if the version is not UNKNOWN.""" return self.strategy != AwesomeVersionStrategy.UNKNOWN @property def modifier(self) -> str | None: """Return the modifier of the version if any.""" if self._modifier is not None: return self._modifier if self.strategy in ( AwesomeVersionStrategy.SPECIALCONTAINER, AwesomeVersionStrategy.HEXVER, ): return None modifier_string = None if ( self.strategy_description is not None and self.strategy_description.strategy == AwesomeVersionStrategy.SEMVER ): match = self.strategy_description.pattern.match(self.string) if match and len(match.groups()) >= 4: self._modifier = modifier_string = match.group(4) else: modifier_string = self.string.split(".")[-1] if not modifier_string: return None match = RE_MODIFIER.match(modifier_string) if match and len(match.groups()) >= 2: self._modifier = match.group(2) return self._modifier @property def modifier_type(self) -> str | None: """Return the modifier type of the version if any.""" if self._modifier_type is not None: return self._modifier_type if self.strategy == AwesomeVersionStrategy.HEXVER: return None match = RE_MODIFIER.match(self.modifier or "") if match and len(match.groups()) >= 3: self._modifier_type = match.group(3) return self._modifier_type @property def strategy_description(self) -> AwesomeVersionStrategyDescription | None: """Return a string representation of the strategy.""" if self.strategy == AwesomeVersionStrategy.UNKNOWN: return None return VERSION_STRATEGIES_DICT[self.strategy] @property def strategy(self) -> AwesomeVersionStrategy: """Return the version strategy.""" version_strategies: dict[ AwesomeVersionStrategy, AwesomeVersionStrategyDescription ] = {} for strategy in self._ensure_strategy or []: version_strategies[strategy] = VERSION_STRATEGIES_DICT[strategy] for description in VERSION_STRATEGIES: if description.strategy not in version_strategies: version_strategies[description.strategy] = description for description in version_strategies.values(): if description.pattern.match(self.string) is not None and ( description.validate is None or description.validate(self.string) ): return description.strategy return AwesomeVersionStrategy.UNKNOWN @property def simple(self) -> bool: """Return True if the version string is simple.""" if self._simple is None: self._simple = ( generate_full_string_regex(RE_SIMPLE).match(self.string) is not None ) return self._simple class AwesomeVersionDiff: """Structured output of AwesomeVersion.diff""" def __init__(self, changes: Dict[str, bool]) -> None: """Initialize the AwesomeVersionDiff.""" self._changes = changes def __repr__(self) -> str: return ( f"AwesomeVersionDiff(major={self.major}, minor={self.minor}, " f"patch={self.patch}, modifier={self.modifier}, strategy={self.strategy})" ) @property def major(self) -> bool: """Return True if the major version has changed.""" return self._changes["major"] @property def minor(self) -> bool: """Return True if the minor version has changed.""" return self._changes["minor"] @property def patch(self) -> bool: """Return True if the patch version has changed.""" return self._changes["patch"] @property def modifier(self) -> bool: """Return True if the modifier version has changed.""" return self._changes["modifier"] @property def strategy(self) -> bool: """Return True if the strategy has changed.""" return self._changes["strategy"] awesomeversion-24.2.0/awesomeversion/comparehandlers/000077500000000000000000000000001456050426100230655ustar00rootroot00000000000000awesomeversion-24.2.0/awesomeversion/comparehandlers/__init__.py000066400000000000000000000000711456050426100251740ustar00rootroot00000000000000"""Initialize the comparehandlers for AwesomeVersion.""" awesomeversion-24.2.0/awesomeversion/comparehandlers/container.py000066400000000000000000000015221456050426100254210ustar00rootroot00000000000000"""Special handler for container.""" from __future__ import annotations from typing import TYPE_CHECKING from ..strategy import AwesomeVersionStrategy CONTAINER_VERSION_MAP = {"stable": 1, "beta": 2, "latest": 3, "dev": 4} if TYPE_CHECKING: from awesomeversion import AwesomeVersion def compare_handler_container( version_a: AwesomeVersion, version_b: AwesomeVersion, ) -> bool | None: """Compare handler container.""" if version_a.strategy == AwesomeVersionStrategy.SPECIALCONTAINER: if version_b.strategy != AwesomeVersionStrategy.SPECIALCONTAINER: return True return ( CONTAINER_VERSION_MAP[version_a.string] > CONTAINER_VERSION_MAP[version_b.string] ) if version_b.strategy == AwesomeVersionStrategy.SPECIALCONTAINER: return False return None awesomeversion-24.2.0/awesomeversion/comparehandlers/modifier.py000066400000000000000000000034541456050426100252430ustar00rootroot00000000000000"""Special handler for modifier.""" from __future__ import annotations from typing import TYPE_CHECKING from ..strategy import VERSION_STRATEGIES_DICT, AwesomeVersionStrategy from ..utils.regex import RE_MODIFIER SEMVER_MODIFIER_MAP = {"dev": 0, "alpha": 1, "beta": 2, "rc": 3} if TYPE_CHECKING: from awesomeversion import AwesomeVersion def compare_handler_semver_modifier( version_a: AwesomeVersion, version_b: AwesomeVersion, ) -> bool | None: """Compare handler sections.""" if AwesomeVersionStrategy.SEMVER not in ( version_a.strategy, version_b.strategy, ) or (version_a.modifier_type is None or version_b.modifier_type is None): return None if version_a.modifier_type != version_b.modifier_type: mod_a = SEMVER_MODIFIER_MAP.get(version_a.modifier_type) mod_b = SEMVER_MODIFIER_MAP.get(version_b.modifier_type) if mod_a is not None and mod_b is not None: return mod_a > mod_b ver_a_modifier, ver_b_modifier = None, None semver_pattern = VERSION_STRATEGIES_DICT[AwesomeVersionStrategy.SEMVER].pattern semver_match = semver_pattern.match(version_a.string) if semver_match and len(semver_match.groups()) >= 4: modifier_match = RE_MODIFIER.match(semver_match.group(4)) if modifier_match and len(modifier_match.groups()) >= 4: ver_a_modifier = modifier_match.group(4) semver_match = semver_pattern.match(version_b.string) if semver_match and len(semver_match.groups()) >= 4: modifier_match = RE_MODIFIER.match(semver_match.group(4)) if modifier_match and len(modifier_match.groups()) >= 4: ver_b_modifier = modifier_match.group(4) if not ver_a_modifier or not ver_b_modifier: return True return int(ver_a_modifier) > int(ver_b_modifier) awesomeversion-24.2.0/awesomeversion/comparehandlers/sections.py000066400000000000000000000047761456050426100253040ustar00rootroot00000000000000"""Special handler for sections.""" from __future__ import annotations from typing import TYPE_CHECKING from ..utils.regex import RE_IS_SINGLE_DIGIT, RE_MODIFIER if TYPE_CHECKING: from ..awesomeversion import AwesomeVersion MODIFIERS = {"rc": 3, "beta": 2, "b": 2, "alpha": 1, "a": 1, "dev": 0, "d": 0} def compare_handler_sections( version_a: AwesomeVersion, version_b: AwesomeVersion, ) -> bool | None: """Compare handler sections.""" base = compare_base_sections(version_a, version_b) if base is not None: return base return compare_modifier_section(version_a, version_b) def compare_base_sections( version_a: AwesomeVersion, version_b: AwesomeVersion, ) -> bool | None: """Compare base sections between two AwesomeVersion objects.""" biggest = ( version_a.sections if version_a.sections >= version_b.sections else version_b.sections ) for section in range(0, biggest): ver_a_section = version_a.section(section) ver_b_section = version_b.section(section) if ver_a_section == ver_b_section: continue if ver_a_section > ver_b_section: return True if ver_a_section < ver_b_section: return False return None def compare_modifier_section( version_a: AwesomeVersion, version_b: AwesomeVersion, ) -> bool | None: """Compare modifiers between two AwesomeVersion objects.""" if version_a.modifier is None and version_b.modifier is not None: return True if version_a.modifier is not None and version_b.modifier is not None: version_a_modifier = RE_MODIFIER.match(version_a.string.split(".")[-1]) version_b_modifier = RE_MODIFIER.match(version_b.string.split(".")[-1]) if version_a_modifier and version_b_modifier: if version_a_modifier.group(3) == version_b_modifier.group(3): return int(version_a_modifier.group(4) or 0) > int( version_b_modifier.group(4) or 0 ) mod_a = MODIFIERS.get(version_a_modifier.group(3)) mod_b = MODIFIERS.get(version_b_modifier.group(3)) if mod_a is not None and mod_b is not None: return mod_a > mod_b return version_a_modifier.group(3) > version_a_modifier.group(3) if RE_IS_SINGLE_DIGIT.match(version_a.modifier) and RE_IS_SINGLE_DIGIT.match( version_b.modifier ): return int(version_a.modifier) > int(version_b.modifier) return None awesomeversion-24.2.0/awesomeversion/comparehandlers/simple.py000066400000000000000000000007371456050426100247370ustar00rootroot00000000000000"""Special handler for simple.""" from __future__ import annotations from typing import TYPE_CHECKING from .sections import compare_base_sections if TYPE_CHECKING: from awesomeversion import AwesomeVersion def compare_handler_simple( version_a: AwesomeVersion, version_b: AwesomeVersion, ) -> bool | None: """Compare handler simple.""" if version_a.simple and version_b.simple: return compare_base_sections(version_a, version_b) return None awesomeversion-24.2.0/awesomeversion/exceptions.py000066400000000000000000000005501456050426100224510ustar00rootroot00000000000000"""Exceptions for AwesomeVersion.""" class AwesomeVersionException(Exception): """Base AwesomeVersion exception.""" class AwesomeVersionCompareException(AwesomeVersionException): """Thrown when compare is not possible.""" class AwesomeVersionStrategyException(AwesomeVersionException): """Thrown when the expected strategy does not match.""" awesomeversion-24.2.0/awesomeversion/py.typed000066400000000000000000000000001456050426100214030ustar00rootroot00000000000000awesomeversion-24.2.0/awesomeversion/strategy.py000066400000000000000000000052231456050426100221340ustar00rootroot00000000000000"""Strategies for AwesomeVersion.""" from __future__ import annotations from collections.abc import Callable from dataclasses import dataclass from enum import Enum from typing import Pattern, Tuple from .utils.regex import ( RE_BUILDVER, RE_CALVER, RE_HEXVER, RE_PEP440, RE_SEMVER, RE_SIMPLE, RE_SPECIAL_CONTAINER, generate_full_string_regex, ) from .utils.validate import value_is_base16 class AwesomeVersionStrategy(str, Enum): """Strategy enum.""" BUILDVER = "BuildVer" CALVER = "CalVer" HEXVER = "HexVer" SEMVER = "SemVer" SIMPLEVER = "SimpleVer" PEP440 = "PEP 440" UNKNOWN = "unknown" SPECIALCONTAINER = "SpecialContainer" @dataclass class AwesomeVersionStrategyDescription: """Description of a strategy.""" strategy: AwesomeVersionStrategy regex_string: str pattern: Pattern[str] validate: Callable[[str], bool] | None = None COMPARABLE_STRATEGIES = [ strategy for strategy in AwesomeVersionStrategy if strategy not in (AwesomeVersionStrategy.UNKNOWN, AwesomeVersionStrategy.SPECIALCONTAINER) ] VERSION_STRATEGIES: Tuple[AwesomeVersionStrategyDescription, ...] = ( AwesomeVersionStrategyDescription( strategy=AwesomeVersionStrategy.BUILDVER, regex_string=RE_BUILDVER, pattern=generate_full_string_regex(RE_BUILDVER), ), AwesomeVersionStrategyDescription( strategy=AwesomeVersionStrategy.CALVER, regex_string=RE_CALVER, pattern=generate_full_string_regex(RE_CALVER), ), AwesomeVersionStrategyDescription( strategy=AwesomeVersionStrategy.HEXVER, regex_string=RE_HEXVER, pattern=generate_full_string_regex(RE_HEXVER), validate=value_is_base16, ), AwesomeVersionStrategyDescription( strategy=AwesomeVersionStrategy.SEMVER, regex_string=RE_SEMVER, pattern=generate_full_string_regex(RE_SEMVER), ), AwesomeVersionStrategyDescription( strategy=AwesomeVersionStrategy.SPECIALCONTAINER, regex_string=RE_SPECIAL_CONTAINER, pattern=generate_full_string_regex(RE_SPECIAL_CONTAINER), ), AwesomeVersionStrategyDescription( strategy=AwesomeVersionStrategy.SIMPLEVER, regex_string=RE_SIMPLE, pattern=generate_full_string_regex(RE_SIMPLE), ), AwesomeVersionStrategyDescription( strategy=AwesomeVersionStrategy.PEP440, regex_string=RE_PEP440, pattern=generate_full_string_regex(RE_PEP440), ), ) VERSION_STRATEGIES_DICT: dict[ AwesomeVersionStrategy, AwesomeVersionStrategyDescription ] = {description.strategy: description for description in VERSION_STRATEGIES} awesomeversion-24.2.0/awesomeversion/typing.py000066400000000000000000000007641456050426100216110ustar00rootroot00000000000000""""Custom types for AwesomeVersion.""" from __future__ import annotations from typing import TYPE_CHECKING, List, Tuple, Union from .strategy import AwesomeVersionStrategy if TYPE_CHECKING: from .awesomeversion import AwesomeVersion VersionType = Union[str, float, int, object, "AwesomeVersion"] EnsureStrategyIterableType = Union[ List[AwesomeVersionStrategy], Tuple[AwesomeVersionStrategy, ...] ] EnsureStrategyType = Union[AwesomeVersionStrategy, EnsureStrategyIterableType, None] awesomeversion-24.2.0/awesomeversion/utils/000077500000000000000000000000001456050426100210565ustar00rootroot00000000000000awesomeversion-24.2.0/awesomeversion/utils/__init__.py000066400000000000000000000000001456050426100231550ustar00rootroot00000000000000awesomeversion-24.2.0/awesomeversion/utils/regex.py000066400000000000000000000022061456050426100225420ustar00rootroot00000000000000"""Regex utils for AwesomeVersion.""" import re from typing import Pattern # General purpose patterns RE_IS_SINGLE_DIGIT = re.compile(r"^\d{1}$") RE_DIGIT = re.compile(r"[a-z]*(\d+)[a-z]*") RE_MODIFIER = re.compile(r"^((?:\d+\-|\d|))(([a-z]+)\.?(\d*))$") # Version patterns RE_CALVER = r"(\d{2}|\d{4})\.\d{1,2}?(\.?\d{1,2}?\.?)?(\.\d)?(\d*(\w+\d+)?)" RE_SEMVER = ( r"(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)(?:-((?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*)" r"(?:\.(?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*))*))?(?:\+([0-9a-zA-Z-]+(?:\.[0-9a-zA-Z-]+)*))?" ) RE_PEP440 = ( r"([1-9][0-9]*!)?(0|[1-9][0-9]*)(\.(0|[1-9][0-9]*))*((a|b|rc)" r"(0|[1-9][0-9]*))?(\.post(0|[1-9][0-9]*))?(\.dev(0|[1-9][0-9]*))?(\.rc(0|[1-9][0-9]*))?" ) RE_BUILDVER = r"\d+" RE_HEXVER = r"0x[A-Fa-f0-9]+" RE_SPECIAL_CONTAINER = r"(latest|dev|stable|beta)" RE_SIMPLE = r"[v|V]?((\d+)(\.\d+)+)" def compile_regex(pattern: str) -> Pattern[str]: """Compile a regex.""" return re.compile(pattern) def generate_full_string_regex(string: str) -> Pattern[str]: """Generate a regex that matches the full string.""" return compile_regex(r"^" + string + r"$") awesomeversion-24.2.0/awesomeversion/utils/validate.py000066400000000000000000000003061456050426100232200ustar00rootroot00000000000000"""Utils to validate.""" def value_is_base16(value: str) -> bool: """Check if a value is base16.""" try: int(value, 16) except ValueError: return False return True awesomeversion-24.2.0/demo/000077500000000000000000000000001456050426100155745ustar00rootroot00000000000000awesomeversion-24.2.0/demo/index.html000066400000000000000000000126761456050426100176050ustar00rootroot00000000000000 AwesomeVersion Demo { "packages": ["awesomeversion"] } from awesomeversion import AwesomeVersion import json import inspect def safe_compare(a, b): try: return a > b except Exception: return None def version_json(version): return json.dumps( { "string": version.string, "alpha": version.alpha, "beta": version.beta, "dev": version.dev, "major": version.major, "micro": version.micro, "minor": version.minor, "modifier_type": version.modifier_type, "modifier": version.modifier, "patch": version.patch, "prefix": version.prefix, "release_candidate": version.release_candidate, "sections": version.sections, "simple": version.simple, "strategy": version.strategy, "valid": version.valid, "year": version.year, }, indent=2 ) def extract_awesomeversion_properties(*args, **kwargs): versions = { "a": AwesomeVersion(Element("version-input-a").element.value.strip() or None), "b": AwesomeVersion(Element("version-input-b").element.value.strip() or None) } for key,version in versions.items(): if version.string == "None": Element(f"properties-output-{key}").element.innerText = "" Element("properties-output-diff").element.innerText = "" continue Element(f"properties-output-{key}").element.innerText = f"Version {key.upper()} properties:\n{version_json(version)}" if versions["a"].string != "None" and versions["b"].string != "None": Element("properties-output-diff").element.innerText =f"""Compare: {json.dumps({ f"{versions['a'].string}>{versions['b'].string}": safe_compare(versions["a"],versions["b"]), f"{versions['b'].string}>{versions['a'].string}": safe_compare(versions["b"],versions["a"]), "diff": { "major": versions["a"].major != versions["b"].major, "minor": versions["a"].minor != versions["b"].minor, "patch": versions["a"].patch != versions["b"].patch, "modifier": versions["a"].modifier != versions["b"].modifier, "strategy": versions["a"].strategy != versions["b"].strategy, } },indent=2)}"""
Version A
Version B

    

    

  


  
  

    

      
AwesomeVersion demo powered by PyScript

    

  

  
  
awesomeversion-24.2.0/poetry.lock000066400000000000000000000655441456050426100170620ustar00rootroot00000000000000# This file is automatically @generated by Poetry 1.7.1 and should not be changed by hand.

[[package]]
name = "astroid"
version = "3.0.1"
description = "An abstract syntax tree for Python with inference support."
optional = false
python-versions = ">=3.8.0"
files = [
    {file = "astroid-3.0.1-py3-none-any.whl", hash = "sha256:7d5895c9825e18079c5aeac0572bc2e4c83205c95d416e0b4fee8bc361d2d9ca"},
    {file = "astroid-3.0.1.tar.gz", hash = "sha256:86b0bb7d7da0be1a7c4aedb7974e391b32d4ed89e33de6ed6902b4b15c97577e"},
]

[package.dependencies]
typing-extensions = {version = ">=4.0.0", markers = "python_version < \"3.11\""}

[[package]]
name = "black"
version = "24.1.1"
description = "The uncompromising code formatter."
optional = false
python-versions = ">=3.8"
files = [
    {file = "black-24.1.1-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:2588021038bd5ada078de606f2a804cadd0a3cc6a79cb3e9bb3a8bf581325a4c"},
    {file = "black-24.1.1-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:1a95915c98d6e32ca43809d46d932e2abc5f1f7d582ffbe65a5b4d1588af7445"},
    {file = "black-24.1.1-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:2fa6a0e965779c8f2afb286f9ef798df770ba2b6cee063c650b96adec22c056a"},
    {file = "black-24.1.1-cp310-cp310-win_amd64.whl", hash = "sha256:5242ecd9e990aeb995b6d03dc3b2d112d4a78f2083e5a8e86d566340ae80fec4"},
    {file = "black-24.1.1-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:fc1ec9aa6f4d98d022101e015261c056ddebe3da6a8ccfc2c792cbe0349d48b7"},
    {file = "black-24.1.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:0269dfdea12442022e88043d2910429bed717b2d04523867a85dacce535916b8"},
    {file = "black-24.1.1-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:b3d64db762eae4a5ce04b6e3dd745dcca0fb9560eb931a5be97472e38652a161"},
    {file = "black-24.1.1-cp311-cp311-win_amd64.whl", hash = "sha256:5d7b06ea8816cbd4becfe5f70accae953c53c0e53aa98730ceccb0395520ee5d"},
    {file = "black-24.1.1-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:e2c8dfa14677f90d976f68e0c923947ae68fa3961d61ee30976c388adc0b02c8"},
    {file = "black-24.1.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:a21725862d0e855ae05da1dd25e3825ed712eaaccef6b03017fe0853a01aa45e"},
    {file = "black-24.1.1-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:07204d078e25327aad9ed2c64790d681238686bce254c910de640c7cc4fc3aa6"},
    {file = "black-24.1.1-cp312-cp312-win_amd64.whl", hash = "sha256:a83fe522d9698d8f9a101b860b1ee154c1d25f8a82ceb807d319f085b2627c5b"},
    {file = "black-24.1.1-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:08b34e85170d368c37ca7bf81cf67ac863c9d1963b2c1780c39102187ec8dd62"},
    {file = "black-24.1.1-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:7258c27115c1e3b5de9ac6c4f9957e3ee2c02c0b39222a24dc7aa03ba0e986f5"},
    {file = "black-24.1.1-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:40657e1b78212d582a0edecafef133cf1dd02e6677f539b669db4746150d38f6"},
    {file = "black-24.1.1-cp38-cp38-win_amd64.whl", hash = "sha256:e298d588744efda02379521a19639ebcd314fba7a49be22136204d7ed1782717"},
    {file = "black-24.1.1-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:34afe9da5056aa123b8bfda1664bfe6fb4e9c6f311d8e4a6eb089da9a9173bf9"},
    {file = "black-24.1.1-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:854c06fb86fd854140f37fb24dbf10621f5dab9e3b0c29a690ba595e3d543024"},
    {file = "black-24.1.1-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:3897ae5a21ca132efa219c029cce5e6bfc9c3d34ed7e892113d199c0b1b444a2"},
    {file = "black-24.1.1-cp39-cp39-win_amd64.whl", hash = "sha256:ecba2a15dfb2d97105be74bbfe5128bc5e9fa8477d8c46766505c1dda5883aac"},
    {file = "black-24.1.1-py3-none-any.whl", hash = "sha256:5cdc2e2195212208fbcae579b931407c1fa9997584f0a415421748aeafff1168"},
    {file = "black-24.1.1.tar.gz", hash = "sha256:48b5760dcbfe5cf97fd4fba23946681f3a81514c6ab8a45b50da67ac8fbc6c7b"},
]

[package.dependencies]
click = ">=8.0.0"
mypy-extensions = ">=0.4.3"
packaging = ">=22.0"
pathspec = ">=0.9.0"
platformdirs = ">=2"
tomli = {version = ">=1.1.0", markers = "python_version < \"3.11\""}
typing-extensions = {version = ">=4.0.1", markers = "python_version < \"3.11\""}

[package.extras]
colorama = ["colorama (>=0.4.3)"]
d = ["aiohttp (>=3.7.4)", "aiohttp (>=3.7.4,!=3.9.0)"]
jupyter = ["ipython (>=7.8.0)", "tokenize-rt (>=3.2.0)"]
uvloop = ["uvloop (>=0.15.2)"]

[[package]]
name = "click"
version = "8.1.7"
description = "Composable command line interface toolkit"
optional = false
python-versions = ">=3.7"
files = [
    {file = "click-8.1.7-py3-none-any.whl", hash = "sha256:ae74fb96c20a0277a1d615f1e4d73c8414f5a98db8b799a7931d1582f3390c28"},
    {file = "click-8.1.7.tar.gz", hash = "sha256:ca9853ad459e787e2192211578cc907e7594e294c7ccc834310722b41b9ca6de"},
]

[package.dependencies]
colorama = {version = "*", markers = "platform_system == \"Windows\""}

[[package]]
name = "colorama"
version = "0.4.6"
description = "Cross-platform colored terminal text."
optional = false
python-versions = "!=3.0.*,!=3.1.*,!=3.2.*,!=3.3.*,!=3.4.*,!=3.5.*,!=3.6.*,>=2.7"
files = [
    {file = "colorama-0.4.6-py2.py3-none-any.whl", hash = "sha256:4f1d9991f5acc0ca119f9d443620b77f9d6b33703e51011c16baf57afb285fc6"},
    {file = "colorama-0.4.6.tar.gz", hash = "sha256:08695f5cb7ed6e0531a20572697297273c47b8cae5a63ffc6d6ed5c201be6e44"},
]

[[package]]
name = "coverage"
version = "7.3.2"
description = "Code coverage measurement for Python"
optional = false
python-versions = ">=3.8"
files = [
    {file = "coverage-7.3.2-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:d872145f3a3231a5f20fd48500274d7df222e291d90baa2026cc5152b7ce86bf"},
    {file = "coverage-7.3.2-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:310b3bb9c91ea66d59c53fa4989f57d2436e08f18fb2f421a1b0b6b8cc7fffda"},
    {file = "coverage-7.3.2-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:f47d39359e2c3779c5331fc740cf4bce6d9d680a7b4b4ead97056a0ae07cb49a"},
    {file = "coverage-7.3.2-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:aa72dbaf2c2068404b9870d93436e6d23addd8bbe9295f49cbca83f6e278179c"},
    {file = "coverage-7.3.2-cp310-cp310-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:beaa5c1b4777f03fc63dfd2a6bd820f73f036bfb10e925fce067b00a340d0f3f"},
    {file = "coverage-7.3.2-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:dbc1b46b92186cc8074fee9d9fbb97a9dd06c6cbbef391c2f59d80eabdf0faa6"},
    {file = "coverage-7.3.2-cp310-cp310-musllinux_1_1_i686.whl", hash = "sha256:315a989e861031334d7bee1f9113c8770472db2ac484e5b8c3173428360a9148"},
    {file = "coverage-7.3.2-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:d1bc430677773397f64a5c88cb522ea43175ff16f8bfcc89d467d974cb2274f9"},
    {file = "coverage-7.3.2-cp310-cp310-win32.whl", hash = "sha256:a889ae02f43aa45032afe364c8ae84ad3c54828c2faa44f3bfcafecb5c96b02f"},
    {file = "coverage-7.3.2-cp310-cp310-win_amd64.whl", hash = "sha256:c0ba320de3fb8c6ec16e0be17ee1d3d69adcda99406c43c0409cb5c41788a611"},
    {file = "coverage-7.3.2-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:ac8c802fa29843a72d32ec56d0ca792ad15a302b28ca6203389afe21f8fa062c"},
    {file = "coverage-7.3.2-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:89a937174104339e3a3ffcf9f446c00e3a806c28b1841c63edb2b369310fd074"},
    {file = "coverage-7.3.2-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:e267e9e2b574a176ddb983399dec325a80dbe161f1a32715c780b5d14b5f583a"},
    {file = "coverage-7.3.2-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:2443cbda35df0d35dcfb9bf8f3c02c57c1d6111169e3c85fc1fcc05e0c9f39a3"},
    {file = "coverage-7.3.2-cp311-cp311-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:4175e10cc8dda0265653e8714b3174430b07c1dca8957f4966cbd6c2b1b8065a"},
    {file = "coverage-7.3.2-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:0cbf38419fb1a347aaf63481c00f0bdc86889d9fbf3f25109cf96c26b403fda1"},
    {file = "coverage-7.3.2-cp311-cp311-musllinux_1_1_i686.whl", hash = "sha256:5c913b556a116b8d5f6ef834038ba983834d887d82187c8f73dec21049abd65c"},
    {file = "coverage-7.3.2-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:1981f785239e4e39e6444c63a98da3a1db8e971cb9ceb50a945ba6296b43f312"},
    {file = "coverage-7.3.2-cp311-cp311-win32.whl", hash = "sha256:43668cabd5ca8258f5954f27a3aaf78757e6acf13c17604d89648ecc0cc66640"},
    {file = "coverage-7.3.2-cp311-cp311-win_amd64.whl", hash = "sha256:e10c39c0452bf6e694511c901426d6b5ac005acc0f78ff265dbe36bf81f808a2"},
    {file = "coverage-7.3.2-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:4cbae1051ab791debecc4a5dcc4a1ff45fc27b91b9aee165c8a27514dd160836"},
    {file = "coverage-7.3.2-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:12d15ab5833a997716d76f2ac1e4b4d536814fc213c85ca72756c19e5a6b3d63"},
    {file = "coverage-7.3.2-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:3c7bba973ebee5e56fe9251300c00f1579652587a9f4a5ed8404b15a0471f216"},
    {file = "coverage-7.3.2-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:fe494faa90ce6381770746077243231e0b83ff3f17069d748f645617cefe19d4"},
    {file = "coverage-7.3.2-cp312-cp312-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f6e9589bd04d0461a417562649522575d8752904d35c12907d8c9dfeba588faf"},
    {file = "coverage-7.3.2-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:d51ac2a26f71da1b57f2dc81d0e108b6ab177e7d30e774db90675467c847bbdf"},
    {file = "coverage-7.3.2-cp312-cp312-musllinux_1_1_i686.whl", hash = "sha256:99b89d9f76070237975b315b3d5f4d6956ae354a4c92ac2388a5695516e47c84"},
    {file = "coverage-7.3.2-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:fa28e909776dc69efb6ed975a63691bc8172b64ff357e663a1bb06ff3c9b589a"},
    {file = "coverage-7.3.2-cp312-cp312-win32.whl", hash = "sha256:289fe43bf45a575e3ab10b26d7b6f2ddb9ee2dba447499f5401cfb5ecb8196bb"},
    {file = "coverage-7.3.2-cp312-cp312-win_amd64.whl", hash = "sha256:7dbc3ed60e8659bc59b6b304b43ff9c3ed858da2839c78b804973f613d3e92ed"},
    {file = "coverage-7.3.2-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:f94b734214ea6a36fe16e96a70d941af80ff3bfd716c141300d95ebc85339738"},
    {file = "coverage-7.3.2-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:af3d828d2c1cbae52d34bdbb22fcd94d1ce715d95f1a012354a75e5913f1bda2"},
    {file = "coverage-7.3.2-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:630b13e3036e13c7adc480ca42fa7afc2a5d938081d28e20903cf7fd687872e2"},
    {file = "coverage-7.3.2-cp38-cp38-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:c9eacf273e885b02a0273bb3a2170f30e2d53a6d53b72dbe02d6701b5296101c"},
    {file = "coverage-7.3.2-cp38-cp38-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:d8f17966e861ff97305e0801134e69db33b143bbfb36436efb9cfff6ec7b2fd9"},
    {file = "coverage-7.3.2-cp38-cp38-musllinux_1_1_aarch64.whl", hash = "sha256:b4275802d16882cf9c8b3d057a0839acb07ee9379fa2749eca54efbce1535b82"},
    {file = "coverage-7.3.2-cp38-cp38-musllinux_1_1_i686.whl", hash = "sha256:72c0cfa5250f483181e677ebc97133ea1ab3eb68645e494775deb6a7f6f83901"},
    {file = "coverage-7.3.2-cp38-cp38-musllinux_1_1_x86_64.whl", hash = "sha256:cb536f0dcd14149425996821a168f6e269d7dcd2c273a8bff8201e79f5104e76"},
    {file = "coverage-7.3.2-cp38-cp38-win32.whl", hash = "sha256:307adb8bd3abe389a471e649038a71b4eb13bfd6b7dd9a129fa856f5c695cf92"},
    {file = "coverage-7.3.2-cp38-cp38-win_amd64.whl", hash = "sha256:88ed2c30a49ea81ea3b7f172e0269c182a44c236eb394718f976239892c0a27a"},
    {file = "coverage-7.3.2-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:b631c92dfe601adf8f5ebc7fc13ced6bb6e9609b19d9a8cd59fa47c4186ad1ce"},
    {file = "coverage-7.3.2-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:d3d9df4051c4a7d13036524b66ecf7a7537d14c18a384043f30a303b146164e9"},
    {file = "coverage-7.3.2-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:5f7363d3b6a1119ef05015959ca24a9afc0ea8a02c687fe7e2d557705375c01f"},
    {file = "coverage-7.3.2-cp39-cp39-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:2f11cc3c967a09d3695d2a6f03fb3e6236622b93be7a4b5dc09166a861be6d25"},
    {file = "coverage-7.3.2-cp39-cp39-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:149de1d2401ae4655c436a3dced6dd153f4c3309f599c3d4bd97ab172eaf02d9"},
    {file = "coverage-7.3.2-cp39-cp39-musllinux_1_1_aarch64.whl", hash = "sha256:3a4006916aa6fee7cd38db3bfc95aa9c54ebb4ffbfc47c677c8bba949ceba0a6"},
    {file = "coverage-7.3.2-cp39-cp39-musllinux_1_1_i686.whl", hash = "sha256:9028a3871280110d6e1aa2df1afd5ef003bab5fb1ef421d6dc748ae1c8ef2ebc"},
    {file = "coverage-7.3.2-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:9f805d62aec8eb92bab5b61c0f07329275b6f41c97d80e847b03eb894f38d083"},
    {file = "coverage-7.3.2-cp39-cp39-win32.whl", hash = "sha256:d1c88ec1a7ff4ebca0219f5b1ef863451d828cccf889c173e1253aa84b1e07ce"},
    {file = "coverage-7.3.2-cp39-cp39-win_amd64.whl", hash = "sha256:b4767da59464bb593c07afceaddea61b154136300881844768037fd5e859353f"},
    {file = "coverage-7.3.2-pp38.pp39.pp310-none-any.whl", hash = "sha256:ae97af89f0fbf373400970c0a21eef5aa941ffeed90aee43650b81f7d7f47637"},
    {file = "coverage-7.3.2.tar.gz", hash = "sha256:be32ad29341b0170e795ca590e1c07e81fc061cb5b10c74ce7203491484404ef"},
]

[package.dependencies]
tomli = {version = "*", optional = true, markers = "python_full_version <= \"3.11.0a6\" and extra == \"toml\""}

[package.extras]
toml = ["tomli"]

[[package]]
name = "dill"
version = "0.3.7"
description = "serialize all of Python"
optional = false
python-versions = ">=3.7"
files = [
    {file = "dill-0.3.7-py3-none-any.whl", hash = "sha256:76b122c08ef4ce2eedcd4d1abd8e641114bfc6c2867f49f3c41facf65bf19f5e"},
    {file = "dill-0.3.7.tar.gz", hash = "sha256:cc1c8b182eb3013e24bd475ff2e9295af86c1a38eb1aff128dac8962a9ce3c03"},
]

[package.extras]
graph = ["objgraph (>=1.7.2)"]

[[package]]
name = "exceptiongroup"
version = "1.1.3"
description = "Backport of PEP 654 (exception groups)"
optional = false
python-versions = ">=3.7"
files = [
    {file = "exceptiongroup-1.1.3-py3-none-any.whl", hash = "sha256:343280667a4585d195ca1cf9cef84a4e178c4b6cf2274caef9859782b567d5e3"},
    {file = "exceptiongroup-1.1.3.tar.gz", hash = "sha256:097acd85d473d75af5bb98e41b61ff7fe35efe6675e4f9370ec6ec5126d160e9"},
]

[package.extras]
test = ["pytest (>=6)"]

[[package]]
name = "iniconfig"
version = "2.0.0"
description = "brain-dead simple config-ini parsing"
optional = false
python-versions = ">=3.7"
files = [
    {file = "iniconfig-2.0.0-py3-none-any.whl", hash = "sha256:b6a85871a79d2e3b22d2d1b94ac2824226a63c6b741c88f7ae975f18b6778374"},
    {file = "iniconfig-2.0.0.tar.gz", hash = "sha256:2d91e135bf72d31a410b17c16da610a82cb55f6b0477d1a902134b24a455b8b3"},
]

[[package]]
name = "isort"
version = "5.13.2"
description = "A Python utility / library to sort Python imports."
optional = false
python-versions = ">=3.8.0"
files = [
    {file = "isort-5.13.2-py3-none-any.whl", hash = "sha256:8ca5e72a8d85860d5a3fa69b8745237f2939afe12dbf656afbcb47fe72d947a6"},
    {file = "isort-5.13.2.tar.gz", hash = "sha256:48fdfcb9face5d58a4f6dde2e72a1fb8dcaf8ab26f95ab49fab84c2ddefb0109"},
]

[package.extras]
colors = ["colorama (>=0.4.6)"]

[[package]]
name = "mccabe"
version = "0.7.0"
description = "McCabe checker, plugin for flake8"
optional = false
python-versions = ">=3.6"
files = [
    {file = "mccabe-0.7.0-py2.py3-none-any.whl", hash = "sha256:6c2d30ab6be0e4a46919781807b4f0d834ebdd6c6e3dca0bda5a15f863427b6e"},
    {file = "mccabe-0.7.0.tar.gz", hash = "sha256:348e0240c33b60bbdf4e523192ef919f28cb2c3d7d5c7794f74009290f236325"},
]

[[package]]
name = "mypy"
version = "1.8.0"
description = "Optional static typing for Python"
optional = false
python-versions = ">=3.8"
files = [
    {file = "mypy-1.8.0-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:485a8942f671120f76afffff70f259e1cd0f0cfe08f81c05d8816d958d4577d3"},
    {file = "mypy-1.8.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:df9824ac11deaf007443e7ed2a4a26bebff98d2bc43c6da21b2b64185da011c4"},
    {file = "mypy-1.8.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:2afecd6354bbfb6e0160f4e4ad9ba6e4e003b767dd80d85516e71f2e955ab50d"},
    {file = "mypy-1.8.0-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:8963b83d53ee733a6e4196954502b33567ad07dfd74851f32be18eb932fb1cb9"},
    {file = "mypy-1.8.0-cp310-cp310-win_amd64.whl", hash = "sha256:e46f44b54ebddbeedbd3d5b289a893219065ef805d95094d16a0af6630f5d410"},
    {file = "mypy-1.8.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:855fe27b80375e5c5878492f0729540db47b186509c98dae341254c8f45f42ae"},
    {file = "mypy-1.8.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:4c886c6cce2d070bd7df4ec4a05a13ee20c0aa60cb587e8d1265b6c03cf91da3"},
    {file = "mypy-1.8.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:d19c413b3c07cbecf1f991e2221746b0d2a9410b59cb3f4fb9557f0365a1a817"},
    {file = "mypy-1.8.0-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:9261ed810972061388918c83c3f5cd46079d875026ba97380f3e3978a72f503d"},
    {file = "mypy-1.8.0-cp311-cp311-win_amd64.whl", hash = "sha256:51720c776d148bad2372ca21ca29256ed483aa9a4cdefefcef49006dff2a6835"},
    {file = "mypy-1.8.0-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:52825b01f5c4c1c4eb0db253ec09c7aa17e1a7304d247c48b6f3599ef40db8bd"},
    {file = "mypy-1.8.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:f5ac9a4eeb1ec0f1ccdc6f326bcdb464de5f80eb07fb38b5ddd7b0de6bc61e55"},
    {file = "mypy-1.8.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:afe3fe972c645b4632c563d3f3eff1cdca2fa058f730df2b93a35e3b0c538218"},
    {file = "mypy-1.8.0-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:42c6680d256ab35637ef88891c6bd02514ccb7e1122133ac96055ff458f93fc3"},
    {file = "mypy-1.8.0-cp312-cp312-win_amd64.whl", hash = "sha256:720a5ca70e136b675af3af63db533c1c8c9181314d207568bbe79051f122669e"},
    {file = "mypy-1.8.0-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:028cf9f2cae89e202d7b6593cd98db6759379f17a319b5faf4f9978d7084cdc6"},
    {file = "mypy-1.8.0-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:4e6d97288757e1ddba10dd9549ac27982e3e74a49d8d0179fc14d4365c7add66"},
    {file = "mypy-1.8.0-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:7f1478736fcebb90f97e40aff11a5f253af890c845ee0c850fe80aa060a267c6"},
    {file = "mypy-1.8.0-cp38-cp38-musllinux_1_1_x86_64.whl", hash = "sha256:42419861b43e6962a649068a61f4a4839205a3ef525b858377a960b9e2de6e0d"},
    {file = "mypy-1.8.0-cp38-cp38-win_amd64.whl", hash = "sha256:2b5b6c721bd4aabaadead3a5e6fa85c11c6c795e0c81a7215776ef8afc66de02"},
    {file = "mypy-1.8.0-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:5c1538c38584029352878a0466f03a8ee7547d7bd9f641f57a0f3017a7c905b8"},
    {file = "mypy-1.8.0-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:4ef4be7baf08a203170f29e89d79064463b7fc7a0908b9d0d5114e8009c3a259"},
    {file = "mypy-1.8.0-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:7178def594014aa6c35a8ff411cf37d682f428b3b5617ca79029d8ae72f5402b"},
    {file = "mypy-1.8.0-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:ab3c84fa13c04aeeeabb2a7f67a25ef5d77ac9d6486ff33ded762ef353aa5592"},
    {file = "mypy-1.8.0-cp39-cp39-win_amd64.whl", hash = "sha256:99b00bc72855812a60d253420d8a2eae839b0afa4938f09f4d2aa9bb4654263a"},
    {file = "mypy-1.8.0-py3-none-any.whl", hash = "sha256:538fd81bb5e430cc1381a443971c0475582ff9f434c16cd46d2c66763ce85d9d"},
    {file = "mypy-1.8.0.tar.gz", hash = "sha256:6ff8b244d7085a0b425b56d327b480c3b29cafbd2eff27316a004f9a7391ae07"},
]

[package.dependencies]
mypy-extensions = ">=1.0.0"
tomli = {version = ">=1.1.0", markers = "python_version < \"3.11\""}
typing-extensions = ">=4.1.0"

[package.extras]
dmypy = ["psutil (>=4.0)"]
install-types = ["pip"]
mypyc = ["setuptools (>=50)"]
reports = ["lxml"]

[[package]]
name = "mypy-extensions"
version = "1.0.0"
description = "Type system extensions for programs checked with the mypy type checker."
optional = false
python-versions = ">=3.5"
files = [
    {file = "mypy_extensions-1.0.0-py3-none-any.whl", hash = "sha256:4392f6c0eb8a5668a69e23d168ffa70f0be9ccfd32b5cc2d26a34ae5b844552d"},
    {file = "mypy_extensions-1.0.0.tar.gz", hash = "sha256:75dbf8955dc00442a438fc4d0666508a9a97b6bd41aa2f0ffe9d2f2725af0782"},
]

[[package]]
name = "packaging"
version = "23.2"
description = "Core utilities for Python packages"
optional = false
python-versions = ">=3.7"
files = [
    {file = "packaging-23.2-py3-none-any.whl", hash = "sha256:8c491190033a9af7e1d931d0b5dacc2ef47509b34dd0de67ed209b5203fc88c7"},
    {file = "packaging-23.2.tar.gz", hash = "sha256:048fb0e9405036518eaaf48a55953c750c11e1a1b68e0dd1a9d62ed0c092cfc5"},
]

[[package]]
name = "pathspec"
version = "0.11.2"
description = "Utility library for gitignore style pattern matching of file paths."
optional = false
python-versions = ">=3.7"
files = [
    {file = "pathspec-0.11.2-py3-none-any.whl", hash = "sha256:1d6ed233af05e679efb96b1851550ea95bbb64b7c490b0f5aa52996c11e92a20"},
    {file = "pathspec-0.11.2.tar.gz", hash = "sha256:e0d8d0ac2f12da61956eb2306b69f9469b42f4deb0f3cb6ed47b9cce9996ced3"},
]

[[package]]
name = "platformdirs"
version = "3.11.0"
description = "A small Python package for determining appropriate platform-specific dirs, e.g. a \"user data dir\"."
optional = false
python-versions = ">=3.7"
files = [
    {file = "platformdirs-3.11.0-py3-none-any.whl", hash = "sha256:e9d171d00af68be50e9202731309c4e658fd8bc76f55c11c7dd760d023bda68e"},
    {file = "platformdirs-3.11.0.tar.gz", hash = "sha256:cf8ee52a3afdb965072dcc652433e0c7e3e40cf5ea1477cd4b3b1d2eb75495b3"},
]

[package.extras]
docs = ["furo (>=2023.7.26)", "proselint (>=0.13)", "sphinx (>=7.1.1)", "sphinx-autodoc-typehints (>=1.24)"]
test = ["appdirs (==1.4.4)", "covdefaults (>=2.3)", "pytest (>=7.4)", "pytest-cov (>=4.1)", "pytest-mock (>=3.11.1)"]

[[package]]
name = "pluggy"
version = "1.3.0"
description = "plugin and hook calling mechanisms for python"
optional = false
python-versions = ">=3.8"
files = [
    {file = "pluggy-1.3.0-py3-none-any.whl", hash = "sha256:d89c696a773f8bd377d18e5ecda92b7a3793cbe66c87060a6fb58c7b6e1061f7"},
    {file = "pluggy-1.3.0.tar.gz", hash = "sha256:cf61ae8f126ac6f7c451172cf30e3e43d3ca77615509771b3a984a0730651e12"},
]

[package.extras]
dev = ["pre-commit", "tox"]
testing = ["pytest", "pytest-benchmark"]

[[package]]
name = "pylint"
version = "3.0.3"
description = "python code static checker"
optional = false
python-versions = ">=3.8.0"
files = [
    {file = "pylint-3.0.3-py3-none-any.whl", hash = "sha256:7a1585285aefc5165db81083c3e06363a27448f6b467b3b0f30dbd0ac1f73810"},
    {file = "pylint-3.0.3.tar.gz", hash = "sha256:58c2398b0301e049609a8429789ec6edf3aabe9b6c5fec916acd18639c16de8b"},
]

[package.dependencies]
astroid = ">=3.0.1,<=3.1.0-dev0"
colorama = {version = ">=0.4.5", markers = "sys_platform == \"win32\""}
dill = [
    {version = ">=0.2", markers = "python_version < \"3.11\""},
    {version = ">=0.3.7", markers = "python_version >= \"3.12\""},
    {version = ">=0.3.6", markers = "python_version >= \"3.11\" and python_version < \"3.12\""},
]
isort = ">=4.2.5,<5.13.0 || >5.13.0,<6"
mccabe = ">=0.6,<0.8"
platformdirs = ">=2.2.0"
tomli = {version = ">=1.1.0", markers = "python_version < \"3.11\""}
tomlkit = ">=0.10.1"
typing-extensions = {version = ">=3.10.0", markers = "python_version < \"3.10\""}

[package.extras]
spelling = ["pyenchant (>=3.2,<4.0)"]
testutils = ["gitpython (>3)"]

[[package]]
name = "pytest"
version = "8.0.0"
description = "pytest: simple powerful testing with Python"
optional = false
python-versions = ">=3.8"
files = [
    {file = "pytest-8.0.0-py3-none-any.whl", hash = "sha256:50fb9cbe836c3f20f0dfa99c565201fb75dc54c8d76373cd1bde06b06657bdb6"},
    {file = "pytest-8.0.0.tar.gz", hash = "sha256:249b1b0864530ba251b7438274c4d251c58d868edaaec8762893ad4a0d71c36c"},
]

[package.dependencies]
colorama = {version = "*", markers = "sys_platform == \"win32\""}
exceptiongroup = {version = ">=1.0.0rc8", markers = "python_version < \"3.11\""}
iniconfig = "*"
packaging = "*"
pluggy = ">=1.3.0,<2.0"
tomli = {version = ">=1.0.0", markers = "python_version < \"3.11\""}

[package.extras]
testing = ["argcomplete", "attrs (>=19.2.0)", "hypothesis (>=3.56)", "mock", "nose", "pygments (>=2.7.2)", "requests", "setuptools", "xmlschema"]

[[package]]
name = "pytest-cov"
version = "4.1.0"
description = "Pytest plugin for measuring coverage."
optional = false
python-versions = ">=3.7"
files = [
    {file = "pytest-cov-4.1.0.tar.gz", hash = "sha256:3904b13dfbfec47f003b8e77fd5b589cd11904a21ddf1ab38a64f204d6a10ef6"},
    {file = "pytest_cov-4.1.0-py3-none-any.whl", hash = "sha256:6ba70b9e97e69fcc3fb45bfeab2d0a138fb65c4d0d6a41ef33983ad114be8c3a"},
]

[package.dependencies]
coverage = {version = ">=5.2.1", extras = ["toml"]}
pytest = ">=4.6"

[package.extras]
testing = ["fields", "hunter", "process-tests", "pytest-xdist", "six", "virtualenv"]

[[package]]
name = "pytest-snapshot"
version = "0.9.0"
description = "A plugin for snapshot testing with pytest."
optional = false
python-versions = ">=3.5"
files = [
    {file = "pytest-snapshot-0.9.0.tar.gz", hash = "sha256:c7013c3abc3e860f9feff899f8b4debe3708650d8d8242a61bf2625ff64db7f3"},
    {file = "pytest_snapshot-0.9.0-py3-none-any.whl", hash = "sha256:4b9fe1c21c868fe53a545e4e3184d36bc1c88946e3f5c1d9dd676962a9b3d4ab"},
]

[package.dependencies]
pytest = ">=3.0.0"

[[package]]
name = "tomli"
version = "2.0.1"
description = "A lil' TOML parser"
optional = false
python-versions = ">=3.7"
files = [
    {file = "tomli-2.0.1-py3-none-any.whl", hash = "sha256:939de3e7a6161af0c887ef91b7d41a53e7c5a1ca976325f429cb46ea9bc30ecc"},
    {file = "tomli-2.0.1.tar.gz", hash = "sha256:de526c12914f0c550d15924c62d72abc48d6fe7364aa87328337a31007fe8a4f"},
]

[[package]]
name = "tomlkit"
version = "0.12.2"
description = "Style preserving TOML library"
optional = false
python-versions = ">=3.7"
files = [
    {file = "tomlkit-0.12.2-py3-none-any.whl", hash = "sha256:eeea7ac7563faeab0a1ed8fe12c2e5a51c61f933f2502f7e9db0241a65163ad0"},
    {file = "tomlkit-0.12.2.tar.gz", hash = "sha256:df32fab589a81f0d7dc525a4267b6d7a64ee99619cbd1eeb0fae32c1dd426977"},
]

[[package]]
name = "typing-extensions"
version = "4.8.0"
description = "Backported and Experimental Type Hints for Python 3.8+"
optional = false
python-versions = ">=3.8"
files = [
    {file = "typing_extensions-4.8.0-py3-none-any.whl", hash = "sha256:8f92fc8806f9a6b641eaa5318da32b44d401efaac0f6678c9bc448ba3605faa0"},
    {file = "typing_extensions-4.8.0.tar.gz", hash = "sha256:df8e4339e9cb77357558cbdbceca33c303714cf861d1eef15e1070055ae8b7ef"},
]

[metadata]
lock-version = "2.0"
python-versions = "^3.8"
content-hash = "31c44cf33bf83d17a3b2db0a6d392cb4b572ab4f7e803867bcb1268ede7389db"
awesomeversion-24.2.0/pyproject.toml000066400000000000000000000025161456050426100175700ustar00rootroot00000000000000[build-system]
build-backend = "poetry.core.masonry.api"
requires = ["poetry-core>=1.0.0"]

[tool.poetry]
authors = ["Ludeeus "]
classifiers = [
  "Intended Audience :: Developers",
  "Natural Language :: English",
  "Topic :: Software Development :: Libraries :: Python Modules",
]
description = "One version package to rule them all, One version package to find them, One version package to bring them all, and in the darkness bind them."
exclude = ['**/__pycache__']
include = ["awesomeversion", "awesomeversion.*", "LICENCE.md"]
keywords = ["calver", "semver", "0ver", "version", "pep440", "buildver"]
license = "MIT"
maintainers = ["Ludeeus "]
name = "awesomeversion"
readme = "README.md"
repository = "https://github.com/ludeeus/awesomeversion"
version = "0"

[tool.poetry.dependencies]
python = "^3.8"

[tool.poetry.dev-dependencies]
black = "^24.1"
isort = "^5.13.2"
mypy = "^1.8"
pylint = "^3.0.3"
pytest = "^8.0.0"
pytest-cov = "^4.1.0"
pytest-snapshot = "^0.9.0"

[tool.isort]
combine_as_imports = true
force_sort_within_sections = true
profile = "black"

[tool.pylint.'MESSAGES CONTROL']
disable = "unsubscriptable-object,duplicate-code,too-many-public-methods"


[tool.coverage.run]
source = ["awesomeversion"]
omit = ["setup.py", "tests/*"]

[tool.coverage.report]
exclude_lines = ["if TYPE_CHECKING:"]awesomeversion-24.2.0/tests/000077500000000000000000000000001456050426100160125ustar00rootroot00000000000000awesomeversion-24.2.0/tests/__init__.py000066400000000000000000000000301456050426100201140ustar00rootroot00000000000000"""Initialize tests."""
awesomeversion-24.2.0/tests/issues/000077500000000000000000000000001456050426100173255ustar00rootroot00000000000000awesomeversion-24.2.0/tests/issues/test_issue14.py000066400000000000000000000005641456050426100222400ustar00rootroot00000000000000"""Test for issue #14."""

# https://github.com/ludeeus/awesomeversion/issues/14
from awesomeversion import AwesomeVersion
from awesomeversion.strategy import AwesomeVersionStrategy


def test() -> None:
    """Test for issue #14."""
    version = AwesomeVersion("2021.1.0.dev20201230")
    assert version.dev
    assert version.strategy != AwesomeVersionStrategy.UNKNOWN
awesomeversion-24.2.0/tests/issues/test_issue153.py000066400000000000000000000012041456050426100223140ustar00rootroot00000000000000"""Test for issue #153."""

# https://github.com/ludeeus/awesomeversion/issues/153
from awesomeversion import AwesomeVersion


def test() -> None:
    """Test for issue #153."""
    current = AwesomeVersion("v1.10.0")

    dev1 = AwesomeVersion("v1.11.0-dev.1")
    dev2 = AwesomeVersion("v2.0.0-dev.1")
    dev3 = AwesomeVersion("v2.0.0-dev.2")

    assert current < dev1
    assert current < dev2
    assert current < dev3

    assert dev1 > current
    assert dev1 < dev2
    assert dev1 < dev3

    assert dev2 > current
    assert dev2 > dev1
    assert dev2 < dev3

    assert dev3 > current
    assert dev3 > dev1
    assert dev3 > dev2
awesomeversion-24.2.0/tests/issues/test_issue26.py000066400000000000000000000004301456050426100222330ustar00rootroot00000000000000"""Test for issue #26."""

# https://github.com/ludeeus/awesomeversion/issues/26
from awesomeversion import AwesomeVersion


def test() -> None:
    """Test for issue #26."""
    current = AwesomeVersion(" 123")
    upstream = AwesomeVersion("123")
    assert current == upstream
awesomeversion-24.2.0/tests/issues/test_issue96.py000066400000000000000000000030701456050426100222450ustar00rootroot00000000000000"""Test for issue #96."""

# https://github.com/ludeeus/awesomeversion/issues/96
import re

import pytest

from awesomeversion import (
    AwesomeVersion,
    AwesomeVersionStrategy,
    AwesomeVersionStrategyException,
)


def test() -> None:
    """Test for issue #96."""
    version = AwesomeVersion("10.3.0", AwesomeVersionStrategy.SEMVER)
    assert version.strategy == AwesomeVersionStrategy.SEMVER

    version = AwesomeVersion(
        "10.3.0",
        [
            AwesomeVersionStrategy.CALVER,
            AwesomeVersionStrategy.SEMVER,
            AwesomeVersionStrategy.SIMPLEVER,
            AwesomeVersionStrategy.BUILDVER,
            AwesomeVersionStrategy.PEP440,
        ],
    )
    assert version.strategy == AwesomeVersionStrategy.CALVER

    version = AwesomeVersion(
        "10.3.0",
        [
            AwesomeVersionStrategy.SEMVER,
            AwesomeVersionStrategy.CALVER,
        ],
    )
    assert version.strategy == AwesomeVersionStrategy.SEMVER

    with pytest.raises(
        AwesomeVersionStrategyException,
        match=re.escape(
            "Strategy unknown does not match ['SemVer', 'CalVer'] for whatever"
        ),
    ):
        AwesomeVersion(
            "whatever",
            [
                AwesomeVersionStrategy.SEMVER,
                AwesomeVersionStrategy.CALVER,
            ],
        )

    with pytest.raises(
        AwesomeVersionStrategyException,
        match=re.escape("Strategy CalVer does not match ['SemVer'] for 2021.12"),
    ):
        AwesomeVersion("2021.12", ensure_strategy=AwesomeVersionStrategy.SEMVER)
awesomeversion-24.2.0/tests/snapshots/000077500000000000000000000000001456050426100200345ustar00rootroot00000000000000awesomeversion-24.2.0/tests/snapshots/BuildVer/000077500000000000000000000000001456050426100215505ustar00rootroot00000000000000awesomeversion-24.2.0/tests/snapshots/BuildVer/0.json000066400000000000000000000005461456050426100226070ustar00rootroot00000000000000{
    "alpha": false,
    "beta": false,
    "dev": false,
    "major": "0",
    "micro": null,
    "minor": null,
    "modifier_type": null,
    "modifier": null,
    "patch": null,
    "prefix": null,
    "release_candidate": false,
    "sections": 1,
    "simple": false,
    "strategy": "BuildVer",
    "string": "0",
    "valid": true,
    "year": "0"
}awesomeversion-24.2.0/tests/snapshots/BuildVer/01234567.json000066400000000000000000000005711456050426100233610ustar00rootroot00000000000000{
    "alpha": false,
    "beta": false,
    "dev": false,
    "major": "1234567",
    "micro": null,
    "minor": null,
    "modifier_type": null,
    "modifier": null,
    "patch": null,
    "prefix": null,
    "release_candidate": false,
    "sections": 1,
    "simple": false,
    "strategy": "BuildVer",
    "string": "01234567",
    "valid": true,
    "year": "1234567"
}awesomeversion-24.2.0/tests/snapshots/BuildVer/1.json000066400000000000000000000005461456050426100226100ustar00rootroot00000000000000{
    "alpha": false,
    "beta": false,
    "dev": false,
    "major": "1",
    "micro": null,
    "minor": null,
    "modifier_type": null,
    "modifier": null,
    "patch": null,
    "prefix": null,
    "release_candidate": false,
    "sections": 1,
    "simple": false,
    "strategy": "BuildVer",
    "string": "1",
    "valid": true,
    "year": "1"
}awesomeversion-24.2.0/tests/snapshots/BuildVer/123.json000066400000000000000000000005541456050426100227540ustar00rootroot00000000000000{
    "alpha": false,
    "beta": false,
    "dev": false,
    "major": "123",
    "micro": null,
    "minor": null,
    "modifier_type": null,
    "modifier": null,
    "patch": null,
    "prefix": null,
    "release_candidate": false,
    "sections": 1,
    "simple": false,
    "strategy": "BuildVer",
    "string": "123",
    "valid": true,
    "year": "123"
}awesomeversion-24.2.0/tests/snapshots/BuildVer/16785665.json000066400000000000000000000005731456050426100234030ustar00rootroot00000000000000{
    "alpha": false,
    "beta": false,
    "dev": false,
    "major": "16785665",
    "micro": null,
    "minor": null,
    "modifier_type": null,
    "modifier": null,
    "patch": null,
    "prefix": null,
    "release_candidate": false,
    "sections": 1,
    "simple": false,
    "strategy": "BuildVer",
    "string": "16785665",
    "valid": true,
    "year": "16785665"
}awesomeversion-24.2.0/tests/snapshots/BuildVer/2.json000066400000000000000000000005461456050426100226110ustar00rootroot00000000000000{
    "alpha": false,
    "beta": false,
    "dev": false,
    "major": "2",
    "micro": null,
    "minor": null,
    "modifier_type": null,
    "modifier": null,
    "patch": null,
    "prefix": null,
    "release_candidate": false,
    "sections": 1,
    "simple": false,
    "strategy": "BuildVer",
    "string": "2",
    "valid": true,
    "year": "2"
}awesomeversion-24.2.0/tests/snapshots/BuildVer/2019.json000066400000000000000000000005571456050426100230450ustar00rootroot00000000000000{
    "alpha": false,
    "beta": false,
    "dev": false,
    "major": "2019",
    "micro": null,
    "minor": null,
    "modifier_type": null,
    "modifier": null,
    "patch": null,
    "prefix": null,
    "release_candidate": false,
    "sections": 1,
    "simple": false,
    "strategy": "BuildVer",
    "string": "2019",
    "valid": true,
    "year": "2019"
}awesomeversion-24.2.0/tests/snapshots/BuildVer/2020.json000066400000000000000000000005571456050426100230350ustar00rootroot00000000000000{
    "alpha": false,
    "beta": false,
    "dev": false,
    "major": "2020",
    "micro": null,
    "minor": null,
    "modifier_type": null,
    "modifier": null,
    "patch": null,
    "prefix": null,
    "release_candidate": false,
    "sections": 1,
    "simple": false,
    "strategy": "BuildVer",
    "string": "2020",
    "valid": true,
    "year": "2020"
}awesomeversion-24.2.0/tests/snapshots/CalVer/000077500000000000000000000000001456050426100212105ustar00rootroot00000000000000awesomeversion-24.2.0/tests/snapshots/CalVer/20.1.0.json000066400000000000000000000005471456050426100226270ustar00rootroot00000000000000{
    "alpha": false,
    "beta": false,
    "dev": false,
    "major": "20",
    "micro": "0",
    "minor": "1",
    "modifier_type": null,
    "modifier": null,
    "patch": "0",
    "prefix": null,
    "release_candidate": false,
    "sections": 3,
    "simple": true,
    "strategy": "CalVer",
    "string": "20.1.0",
    "valid": true,
    "year": "20"
}awesomeversion-24.2.0/tests/snapshots/CalVer/20.1.json000066400000000000000000000005471456050426100224710ustar00rootroot00000000000000{
    "alpha": false,
    "beta": false,
    "dev": false,
    "major": "20",
    "micro": null,
    "minor": "1",
    "modifier_type": null,
    "modifier": null,
    "patch": null,
    "prefix": null,
    "release_candidate": false,
    "sections": 2,
    "simple": true,
    "strategy": "CalVer",
    "string": "20.1",
    "valid": true,
    "year": "20"
}awesomeversion-24.2.0/tests/snapshots/CalVer/2020.1.1..json000066400000000000000000000005551456050426100230470ustar00rootroot00000000000000{
    "alpha": false,
    "beta": false,
    "dev": false,
    "major": "2020",
    "micro": "1",
    "minor": "1",
    "modifier_type": null,
    "modifier": null,
    "patch": "1",
    "prefix": null,
    "release_candidate": false,
    "sections": 3,
    "simple": true,
    "strategy": "CalVer",
    "string": "2020.1.1",
    "valid": true,
    "year": "2020"
}awesomeversion-24.2.0/tests/snapshots/CalVer/2020.1.json000066400000000000000000000005551456050426100226320ustar00rootroot00000000000000{
    "alpha": false,
    "beta": false,
    "dev": false,
    "major": "2020",
    "micro": null,
    "minor": "1",
    "modifier_type": null,
    "modifier": null,
    "patch": null,
    "prefix": null,
    "release_candidate": false,
    "sections": 2,
    "simple": true,
    "strategy": "CalVer",
    "string": "2020.1",
    "valid": true,
    "year": "2020"
}awesomeversion-24.2.0/tests/snapshots/CalVer/2020.12.0.json000066400000000000000000000005571456050426100230540ustar00rootroot00000000000000{
    "alpha": false,
    "beta": false,
    "dev": false,
    "major": "2020",
    "micro": "0",
    "minor": "12",
    "modifier_type": null,
    "modifier": null,
    "patch": "0",
    "prefix": null,
    "release_candidate": false,
    "sections": 3,
    "simple": true,
    "strategy": "CalVer",
    "string": "2020.12.0",
    "valid": true,
    "year": "2020"
}awesomeversion-24.2.0/tests/snapshots/CalVer/2020.12.1.json000066400000000000000000000005571456050426100230550ustar00rootroot00000000000000{
    "alpha": false,
    "beta": false,
    "dev": false,
    "major": "2020",
    "micro": "1",
    "minor": "12",
    "modifier_type": null,
    "modifier": null,
    "patch": "1",
    "prefix": null,
    "release_candidate": false,
    "sections": 3,
    "simple": true,
    "strategy": "CalVer",
    "string": "2020.12.1",
    "valid": true,
    "year": "2020"
}awesomeversion-24.2.0/tests/snapshots/CalVer/2020.12.dev1602.json000066400000000000000000000005751456050426100240040ustar00rootroot00000000000000{
    "alpha": false,
    "beta": false,
    "dev": true,
    "major": "2020",
    "micro": null,
    "minor": "12",
    "modifier_type": "dev",
    "modifier": "dev1602",
    "patch": null,
    "prefix": null,
    "release_candidate": false,
    "sections": 2,
    "simple": false,
    "strategy": "CalVer",
    "string": "2020.12.dev1602",
    "valid": true,
    "year": "2020"
}awesomeversion-24.2.0/tests/snapshots/CalVer/2020.12.dev1603.json000066400000000000000000000005751456050426100240050ustar00rootroot00000000000000{
    "alpha": false,
    "beta": false,
    "dev": true,
    "major": "2020",
    "micro": null,
    "minor": "12",
    "modifier_type": "dev",
    "modifier": "dev1603",
    "patch": null,
    "prefix": null,
    "release_candidate": false,
    "sections": 2,
    "simple": false,
    "strategy": "CalVer",
    "string": "2020.12.dev1603",
    "valid": true,
    "year": "2020"
}awesomeversion-24.2.0/tests/snapshots/CalVer/2020.2.0.json000066400000000000000000000005551456050426100227710ustar00rootroot00000000000000{
    "alpha": false,
    "beta": false,
    "dev": false,
    "major": "2020",
    "micro": "0",
    "minor": "2",
    "modifier_type": null,
    "modifier": null,
    "patch": "0",
    "prefix": null,
    "release_candidate": false,
    "sections": 3,
    "simple": true,
    "strategy": "CalVer",
    "string": "2020.2.0",
    "valid": true,
    "year": "2020"
}awesomeversion-24.2.0/tests/snapshots/CalVer/2020.21.1.json000066400000000000000000000005571456050426100230550ustar00rootroot00000000000000{
    "alpha": false,
    "beta": false,
    "dev": false,
    "major": "2020",
    "micro": "1",
    "minor": "21",
    "modifier_type": null,
    "modifier": null,
    "patch": "1",
    "prefix": null,
    "release_candidate": false,
    "sections": 3,
    "simple": true,
    "strategy": "CalVer",
    "string": "2020.21.1",
    "valid": true,
    "year": "2020"
}awesomeversion-24.2.0/tests/snapshots/CalVer/2021.1.0.0.json000066400000000000000000000005571456050426100231310ustar00rootroot00000000000000{
    "alpha": false,
    "beta": false,
    "dev": false,
    "major": "2021",
    "micro": "0",
    "minor": "1",
    "modifier_type": null,
    "modifier": null,
    "patch": "0",
    "prefix": null,
    "release_candidate": false,
    "sections": 4,
    "simple": true,
    "strategy": "CalVer",
    "string": "2021.1.0.0",
    "valid": true,
    "year": "2021"
}awesomeversion-24.2.0/tests/snapshots/CalVer/2021.1.0.dev0.json000066400000000000000000000005651456050426100236270ustar00rootroot00000000000000{
    "alpha": false,
    "beta": false,
    "dev": true,
    "major": "2021",
    "micro": "0",
    "minor": "1",
    "modifier_type": "dev",
    "modifier": "dev0",
    "patch": "0",
    "prefix": null,
    "release_candidate": false,
    "sections": 3,
    "simple": false,
    "strategy": "CalVer",
    "string": "2021.1.0.dev0",
    "valid": true,
    "year": "2021"
}awesomeversion-24.2.0/tests/snapshots/CalVer/2021.1.0.json000066400000000000000000000005551456050426100227710ustar00rootroot00000000000000{
    "alpha": false,
    "beta": false,
    "dev": false,
    "major": "2021",
    "micro": "0",
    "minor": "1",
    "modifier_type": null,
    "modifier": null,
    "patch": "0",
    "prefix": null,
    "release_candidate": false,
    "sections": 3,
    "simple": true,
    "strategy": "CalVer",
    "string": "2021.1.0",
    "valid": true,
    "year": "2021"
}awesomeversion-24.2.0/tests/snapshots/CalVer/2021.1.0a0.json000066400000000000000000000005561456050426100232130ustar00rootroot00000000000000{
    "alpha": true,
    "beta": false,
    "dev": false,
    "major": "2021",
    "micro": "0",
    "minor": "1",
    "modifier_type": "a",
    "modifier": "a0",
    "patch": "0",
    "prefix": null,
    "release_candidate": false,
    "sections": 3,
    "simple": false,
    "strategy": "CalVer",
    "string": "2021.1.0a0",
    "valid": true,
    "year": "2021"
}awesomeversion-24.2.0/tests/snapshots/CalVer/2021.1.0b0.json000066400000000000000000000005561456050426100232140ustar00rootroot00000000000000{
    "alpha": false,
    "beta": true,
    "dev": false,
    "major": "2021",
    "micro": "0",
    "minor": "1",
    "modifier_type": "b",
    "modifier": "b0",
    "patch": "0",
    "prefix": null,
    "release_candidate": false,
    "sections": 3,
    "simple": false,
    "strategy": "CalVer",
    "string": "2021.1.0b0",
    "valid": true,
    "year": "2021"
}awesomeversion-24.2.0/tests/snapshots/CalVer/2021.1.0b1.json000066400000000000000000000005561456050426100232150ustar00rootroot00000000000000{
    "alpha": false,
    "beta": true,
    "dev": false,
    "major": "2021",
    "micro": "0",
    "minor": "1",
    "modifier_type": "b",
    "modifier": "b1",
    "patch": "0",
    "prefix": null,
    "release_candidate": false,
    "sections": 3,
    "simple": false,
    "strategy": "CalVer",
    "string": "2021.1.0b1",
    "valid": true,
    "year": "2021"
}awesomeversion-24.2.0/tests/snapshots/CalVer/2021.1.0b2.json000066400000000000000000000005561456050426100232160ustar00rootroot00000000000000{
    "alpha": false,
    "beta": true,
    "dev": false,
    "major": "2021",
    "micro": "0",
    "minor": "1",
    "modifier_type": "b",
    "modifier": "b2",
    "patch": "0",
    "prefix": null,
    "release_candidate": false,
    "sections": 3,
    "simple": false,
    "strategy": "CalVer",
    "string": "2021.1.0b2",
    "valid": true,
    "year": "2021"
}awesomeversion-24.2.0/tests/snapshots/CalVer/2021.1.0dev0.json000066400000000000000000000005641456050426100235500ustar00rootroot00000000000000{
    "alpha": false,
    "beta": false,
    "dev": true,
    "major": "2021",
    "micro": "0",
    "minor": "1",
    "modifier_type": "dev",
    "modifier": "dev0",
    "patch": "0",
    "prefix": null,
    "release_candidate": false,
    "sections": 3,
    "simple": false,
    "strategy": "CalVer",
    "string": "2021.1.0dev0",
    "valid": true,
    "year": "2021"
}awesomeversion-24.2.0/tests/snapshots/CalVer/2021.1.0dev20210101.json000066400000000000000000000006021456050426100242700ustar00rootroot00000000000000{
    "alpha": false,
    "beta": false,
    "dev": true,
    "major": "2021",
    "micro": "0",
    "minor": "1",
    "modifier_type": "dev",
    "modifier": "dev20210101",
    "patch": "0",
    "prefix": null,
    "release_candidate": false,
    "sections": 3,
    "simple": false,
    "strategy": "CalVer",
    "string": "2021.1.0dev20210101",
    "valid": true,
    "year": "2021"
}awesomeversion-24.2.0/tests/snapshots/CalVer/2021.2.0.dev20210118.json000066400000000000000000000006031456050426100243600ustar00rootroot00000000000000{
    "alpha": false,
    "beta": false,
    "dev": true,
    "major": "2021",
    "micro": "0",
    "minor": "2",
    "modifier_type": "dev",
    "modifier": "dev20210118",
    "patch": "0",
    "prefix": null,
    "release_candidate": false,
    "sections": 3,
    "simple": false,
    "strategy": "CalVer",
    "string": "2021.2.0.dev20210118",
    "valid": true,
    "year": "2021"
}awesomeversion-24.2.0/tests/snapshots/CalVer/2021.2.0.json000066400000000000000000000005551456050426100227720ustar00rootroot00000000000000{
    "alpha": false,
    "beta": false,
    "dev": false,
    "major": "2021",
    "micro": "0",
    "minor": "2",
    "modifier_type": null,
    "modifier": null,
    "patch": "0",
    "prefix": null,
    "release_candidate": false,
    "sections": 3,
    "simple": true,
    "strategy": "CalVer",
    "string": "2021.2.0",
    "valid": true,
    "year": "2021"
}awesomeversion-24.2.0/tests/snapshots/CalVer/2021.2.0b0.json000066400000000000000000000005561456050426100232150ustar00rootroot00000000000000{
    "alpha": false,
    "beta": true,
    "dev": false,
    "major": "2021",
    "micro": "0",
    "minor": "2",
    "modifier_type": "b",
    "modifier": "b0",
    "patch": "0",
    "prefix": null,
    "release_candidate": false,
    "sections": 3,
    "simple": false,
    "strategy": "CalVer",
    "string": "2021.2.0b0",
    "valid": true,
    "year": "2021"
}awesomeversion-24.2.0/tests/snapshots/CalVer/2021.2.0b10.json000066400000000000000000000005601456050426100232710ustar00rootroot00000000000000{
    "alpha": false,
    "beta": true,
    "dev": false,
    "major": "2021",
    "micro": "0",
    "minor": "2",
    "modifier_type": "b",
    "modifier": "b10",
    "patch": "0",
    "prefix": null,
    "release_candidate": false,
    "sections": 3,
    "simple": false,
    "strategy": "CalVer",
    "string": "2021.2.0b10",
    "valid": true,
    "year": "2021"
}awesomeversion-24.2.0/tests/snapshots/CalVer/2022.01.01.json000066400000000000000000000005571456050426100231350ustar00rootroot00000000000000{
    "alpha": false,
    "beta": false,
    "dev": false,
    "major": "2022",
    "micro": "1",
    "minor": "1",
    "modifier_type": null,
    "modifier": null,
    "patch": "1",
    "prefix": null,
    "release_candidate": false,
    "sections": 3,
    "simple": true,
    "strategy": "CalVer",
    "string": "2022.01.01",
    "valid": true,
    "year": "2022"
}awesomeversion-24.2.0/tests/snapshots/CalVer/2022.01.02.json000066400000000000000000000005571456050426100231360ustar00rootroot00000000000000{
    "alpha": false,
    "beta": false,
    "dev": false,
    "major": "2022",
    "micro": "2",
    "minor": "1",
    "modifier_type": null,
    "modifier": null,
    "patch": "2",
    "prefix": null,
    "release_candidate": false,
    "sections": 3,
    "simple": true,
    "strategy": "CalVer",
    "string": "2022.01.02",
    "valid": true,
    "year": "2022"
}awesomeversion-24.2.0/tests/snapshots/CalVer/2022.02.01.json000066400000000000000000000005571456050426100231360ustar00rootroot00000000000000{
    "alpha": false,
    "beta": false,
    "dev": false,
    "major": "2022",
    "micro": "1",
    "minor": "2",
    "modifier_type": null,
    "modifier": null,
    "patch": "1",
    "prefix": null,
    "release_candidate": false,
    "sections": 3,
    "simple": true,
    "strategy": "CalVer",
    "string": "2022.02.01",
    "valid": true,
    "year": "2022"
}awesomeversion-24.2.0/tests/snapshots/CalVer/2022.02.02.json000066400000000000000000000005571456050426100231370ustar00rootroot00000000000000{
    "alpha": false,
    "beta": false,
    "dev": false,
    "major": "2022",
    "micro": "2",
    "minor": "2",
    "modifier_type": null,
    "modifier": null,
    "patch": "2",
    "prefix": null,
    "release_candidate": false,
    "sections": 3,
    "simple": true,
    "strategy": "CalVer",
    "string": "2022.02.02",
    "valid": true,
    "year": "2022"
}awesomeversion-24.2.0/tests/snapshots/CalVer/2022.03.01.json000066400000000000000000000005571456050426100231370ustar00rootroot00000000000000{
    "alpha": false,
    "beta": false,
    "dev": false,
    "major": "2022",
    "micro": "1",
    "minor": "3",
    "modifier_type": null,
    "modifier": null,
    "patch": "1",
    "prefix": null,
    "release_candidate": false,
    "sections": 3,
    "simple": true,
    "strategy": "CalVer",
    "string": "2022.03.01",
    "valid": true,
    "year": "2022"
}awesomeversion-24.2.0/tests/snapshots/CalVer/2022.03.02.json000066400000000000000000000005571456050426100231400ustar00rootroot00000000000000{
    "alpha": false,
    "beta": false,
    "dev": false,
    "major": "2022",
    "micro": "2",
    "minor": "3",
    "modifier_type": null,
    "modifier": null,
    "patch": "2",
    "prefix": null,
    "release_candidate": false,
    "sections": 3,
    "simple": true,
    "strategy": "CalVer",
    "string": "2022.03.02",
    "valid": true,
    "year": "2022"
}awesomeversion-24.2.0/tests/snapshots/CalVer/2023.01.01.json000066400000000000000000000005571456050426100231360ustar00rootroot00000000000000{
    "alpha": false,
    "beta": false,
    "dev": false,
    "major": "2023",
    "micro": "1",
    "minor": "1",
    "modifier_type": null,
    "modifier": null,
    "patch": "1",
    "prefix": null,
    "release_candidate": false,
    "sections": 3,
    "simple": true,
    "strategy": "CalVer",
    "string": "2023.01.01",
    "valid": true,
    "year": "2023"
}awesomeversion-24.2.0/tests/snapshots/CalVer/2023.01.02.json000066400000000000000000000005571456050426100231370ustar00rootroot00000000000000{
    "alpha": false,
    "beta": false,
    "dev": false,
    "major": "2023",
    "micro": "2",
    "minor": "1",
    "modifier_type": null,
    "modifier": null,
    "patch": "2",
    "prefix": null,
    "release_candidate": false,
    "sections": 3,
    "simple": true,
    "strategy": "CalVer",
    "string": "2023.01.02",
    "valid": true,
    "year": "2023"
}awesomeversion-24.2.0/tests/snapshots/CalVer/2023.02.01.json000066400000000000000000000005571456050426100231370ustar00rootroot00000000000000{
    "alpha": false,
    "beta": false,
    "dev": false,
    "major": "2023",
    "micro": "1",
    "minor": "2",
    "modifier_type": null,
    "modifier": null,
    "patch": "1",
    "prefix": null,
    "release_candidate": false,
    "sections": 3,
    "simple": true,
    "strategy": "CalVer",
    "string": "2023.02.01",
    "valid": true,
    "year": "2023"
}awesomeversion-24.2.0/tests/snapshots/CalVer/2023.02.02.json000066400000000000000000000005571456050426100231400ustar00rootroot00000000000000{
    "alpha": false,
    "beta": false,
    "dev": false,
    "major": "2023",
    "micro": "2",
    "minor": "2",
    "modifier_type": null,
    "modifier": null,
    "patch": "2",
    "prefix": null,
    "release_candidate": false,
    "sections": 3,
    "simple": true,
    "strategy": "CalVer",
    "string": "2023.02.02",
    "valid": true,
    "year": "2023"
}awesomeversion-24.2.0/tests/snapshots/CalVer/2023.03.01.json000066400000000000000000000005571456050426100231400ustar00rootroot00000000000000{
    "alpha": false,
    "beta": false,
    "dev": false,
    "major": "2023",
    "micro": "1",
    "minor": "3",
    "modifier_type": null,
    "modifier": null,
    "patch": "1",
    "prefix": null,
    "release_candidate": false,
    "sections": 3,
    "simple": true,
    "strategy": "CalVer",
    "string": "2023.03.01",
    "valid": true,
    "year": "2023"
}awesomeversion-24.2.0/tests/snapshots/CalVer/2023.03.02.json000066400000000000000000000005571456050426100231410ustar00rootroot00000000000000{
    "alpha": false,
    "beta": false,
    "dev": false,
    "major": "2023",
    "micro": "2",
    "minor": "3",
    "modifier_type": null,
    "modifier": null,
    "patch": "2",
    "prefix": null,
    "release_candidate": false,
    "sections": 3,
    "simple": true,
    "strategy": "CalVer",
    "string": "2023.03.02",
    "valid": true,
    "year": "2023"
}awesomeversion-24.2.0/tests/snapshots/HexVer/000077500000000000000000000000001456050426100212355ustar00rootroot00000000000000awesomeversion-24.2.0/tests/snapshots/HexVer/0x0.json000066400000000000000000000005501456050426100225370ustar00rootroot00000000000000{
    "alpha": false,
    "beta": false,
    "dev": false,
    "major": null,
    "micro": null,
    "minor": null,
    "modifier_type": null,
    "modifier": null,
    "patch": null,
    "prefix": null,
    "release_candidate": false,
    "sections": 1,
    "simple": false,
    "strategy": "HexVer",
    "string": "0x0",
    "valid": true,
    "year": null
}awesomeversion-24.2.0/tests/snapshots/HexVer/0x00AABB00.json000066400000000000000000000005571456050426100233740ustar00rootroot00000000000000{
    "alpha": false,
    "beta": false,
    "dev": false,
    "major": null,
    "micro": null,
    "minor": null,
    "modifier_type": null,
    "modifier": null,
    "patch": null,
    "prefix": null,
    "release_candidate": false,
    "sections": 1,
    "simple": false,
    "strategy": "HexVer",
    "string": "0x00AABB00",
    "valid": true,
    "year": null
}awesomeversion-24.2.0/tests/snapshots/HexVer/0x01002100.json000066400000000000000000000005571456050426100232720ustar00rootroot00000000000000{
    "alpha": false,
    "beta": false,
    "dev": false,
    "major": null,
    "micro": null,
    "minor": null,
    "modifier_type": null,
    "modifier": null,
    "patch": null,
    "prefix": null,
    "release_candidate": false,
    "sections": 1,
    "simple": false,
    "strategy": "HexVer",
    "string": "0x01002100",
    "valid": true,
    "year": null
}awesomeversion-24.2.0/tests/snapshots/HexVer/0x23089631.json000066400000000000000000000005571456050426100233260ustar00rootroot00000000000000{
    "alpha": false,
    "beta": false,
    "dev": false,
    "major": null,
    "micro": null,
    "minor": null,
    "modifier_type": null,
    "modifier": null,
    "patch": null,
    "prefix": null,
    "release_candidate": false,
    "sections": 1,
    "simple": false,
    "strategy": "HexVer",
    "string": "0x23089631",
    "valid": true,
    "year": null
}awesomeversion-24.2.0/tests/snapshots/HexVer/0x2df35.json000066400000000000000000000005541456050426100232270ustar00rootroot00000000000000{
    "alpha": false,
    "beta": false,
    "dev": false,
    "major": null,
    "micro": null,
    "minor": null,
    "modifier_type": null,
    "modifier": null,
    "patch": null,
    "prefix": null,
    "release_candidate": false,
    "sections": 1,
    "simple": false,
    "strategy": "HexVer",
    "string": "0x2df35",
    "valid": true,
    "year": null
}awesomeversion-24.2.0/tests/snapshots/PEP 440/000077500000000000000000000000001456050426100207505ustar00rootroot00000000000000awesomeversion-24.2.0/tests/snapshots/PEP 440/1.0.0b0.json000066400000000000000000000005461456050426100225260ustar00rootroot00000000000000{
    "alpha": false,
    "beta": true,
    "dev": false,
    "major": "1",
    "micro": "0",
    "minor": "0",
    "modifier_type": "b",
    "modifier": "b0",
    "patch": "0",
    "prefix": null,
    "release_candidate": false,
    "sections": 3,
    "simple": false,
    "strategy": "PEP 440",
    "string": "1.0.0b0",
    "valid": true,
    "year": "1"
}awesomeversion-24.2.0/tests/snapshots/PEP 440/1.0.0b1.json000066400000000000000000000005461456050426100225270ustar00rootroot00000000000000{
    "alpha": false,
    "beta": true,
    "dev": false,
    "major": "1",
    "micro": "0",
    "minor": "0",
    "modifier_type": "b",
    "modifier": "b1",
    "patch": "0",
    "prefix": null,
    "release_candidate": false,
    "sections": 3,
    "simple": false,
    "strategy": "PEP 440",
    "string": "1.0.0b1",
    "valid": true,
    "year": "1"
}awesomeversion-24.2.0/tests/snapshots/PEP 440/1.0.0b10.json000066400000000000000000000005501456050426100226020ustar00rootroot00000000000000{
    "alpha": false,
    "beta": true,
    "dev": false,
    "major": "1",
    "micro": "0",
    "minor": "0",
    "modifier_type": "b",
    "modifier": "b10",
    "patch": "0",
    "prefix": null,
    "release_candidate": false,
    "sections": 3,
    "simple": false,
    "strategy": "PEP 440",
    "string": "1.0.0b10",
    "valid": true,
    "year": "1"
}awesomeversion-24.2.0/tests/snapshots/PEP 440/1.0.0b9.json000066400000000000000000000005461456050426100225370ustar00rootroot00000000000000{
    "alpha": false,
    "beta": true,
    "dev": false,
    "major": "1",
    "micro": "0",
    "minor": "0",
    "modifier_type": "b",
    "modifier": "b9",
    "patch": "0",
    "prefix": null,
    "release_candidate": false,
    "sections": 3,
    "simple": false,
    "strategy": "PEP 440",
    "string": "1.0.0b9",
    "valid": true,
    "year": "1"
}awesomeversion-24.2.0/tests/snapshots/PEP 440/1.0.0rc0.json000066400000000000000000000005511456050426100227050ustar00rootroot00000000000000{
    "alpha": false,
    "beta": false,
    "dev": false,
    "major": "1",
    "micro": "0",
    "minor": "0",
    "modifier_type": "rc",
    "modifier": "rc0",
    "patch": "0",
    "prefix": null,
    "release_candidate": true,
    "sections": 3,
    "simple": false,
    "strategy": "PEP 440",
    "string": "1.0.0rc0",
    "valid": true,
    "year": "1"
}awesomeversion-24.2.0/tests/snapshots/PEP 440/1.0.dev0.json000066400000000000000000000005551456050426100230030ustar00rootroot00000000000000{
    "alpha": false,
    "beta": false,
    "dev": true,
    "major": "1",
    "micro": null,
    "minor": "0",
    "modifier_type": "dev",
    "modifier": "dev0",
    "patch": null,
    "prefix": null,
    "release_candidate": false,
    "sections": 2,
    "simple": false,
    "strategy": "PEP 440",
    "string": "1.0.dev0",
    "valid": true,
    "year": "1"
}awesomeversion-24.2.0/tests/snapshots/PEP 440/1.0.dev1.json000066400000000000000000000005551456050426100230040ustar00rootroot00000000000000{
    "alpha": false,
    "beta": false,
    "dev": true,
    "major": "1",
    "micro": null,
    "minor": "0",
    "modifier_type": "dev",
    "modifier": "dev1",
    "patch": null,
    "prefix": null,
    "release_candidate": false,
    "sections": 2,
    "simple": false,
    "strategy": "PEP 440",
    "string": "1.0.dev1",
    "valid": true,
    "year": "1"
}awesomeversion-24.2.0/tests/snapshots/PEP 440/1.0.dev456.json000066400000000000000000000005611456050426100231570ustar00rootroot00000000000000{
    "alpha": false,
    "beta": false,
    "dev": true,
    "major": "1",
    "micro": null,
    "minor": "0",
    "modifier_type": "dev",
    "modifier": "dev456",
    "patch": null,
    "prefix": null,
    "release_candidate": false,
    "sections": 2,
    "simple": false,
    "strategy": "PEP 440",
    "string": "1.0.dev456",
    "valid": true,
    "year": "1"
}awesomeversion-24.2.0/tests/snapshots/PEP 440/1.0.post456.dev34.json000066400000000000000000000005711456050426100243130ustar00rootroot00000000000000{
    "alpha": false,
    "beta": false,
    "dev": true,
    "major": "1",
    "micro": "456",
    "minor": "0",
    "modifier_type": "dev",
    "modifier": "dev34",
    "patch": "456",
    "prefix": null,
    "release_candidate": false,
    "sections": 3,
    "simple": false,
    "strategy": "PEP 440",
    "string": "1.0.post456.dev34",
    "valid": true,
    "year": "1"
}awesomeversion-24.2.0/tests/snapshots/PEP 440/1.0.post456.json000066400000000000000000000005651456050426100233720ustar00rootroot00000000000000{
    "alpha": false,
    "beta": false,
    "dev": false,
    "major": "1",
    "micro": null,
    "minor": "0",
    "modifier_type": "post",
    "modifier": "post456",
    "patch": null,
    "prefix": null,
    "release_candidate": false,
    "sections": 2,
    "simple": false,
    "strategy": "PEP 440",
    "string": "1.0.post456",
    "valid": true,
    "year": "1"
}awesomeversion-24.2.0/tests/snapshots/PEP 440/1.0.rc2.json000066400000000000000000000005521456050426100226300ustar00rootroot00000000000000{
    "alpha": false,
    "beta": false,
    "dev": false,
    "major": "1",
    "micro": null,
    "minor": "0",
    "modifier_type": "rc",
    "modifier": "rc2",
    "patch": null,
    "prefix": null,
    "release_candidate": true,
    "sections": 2,
    "simple": false,
    "strategy": "PEP 440",
    "string": "1.0.rc2",
    "valid": true,
    "year": "1"
}awesomeversion-24.2.0/tests/snapshots/PEP 440/1.0a1.json000066400000000000000000000005461456050426100223700ustar00rootroot00000000000000{
    "alpha": true,
    "beta": false,
    "dev": false,
    "major": "1",
    "micro": null,
    "minor": "0",
    "modifier_type": "a",
    "modifier": "a1",
    "patch": null,
    "prefix": null,
    "release_candidate": false,
    "sections": 2,
    "simple": false,
    "strategy": "PEP 440",
    "string": "1.0a1",
    "valid": true,
    "year": "1"
}awesomeversion-24.2.0/tests/snapshots/PEP 440/1.0a12.dev456.json000066400000000000000000000005641456050426100234660ustar00rootroot00000000000000{
    "alpha": false,
    "beta": false,
    "dev": true,
    "major": "1",
    "micro": null,
    "minor": "0",
    "modifier_type": "dev",
    "modifier": "dev456",
    "patch": null,
    "prefix": null,
    "release_candidate": false,
    "sections": 2,
    "simple": false,
    "strategy": "PEP 440",
    "string": "1.0a12.dev456",
    "valid": true,
    "year": "1"
}awesomeversion-24.2.0/tests/snapshots/PEP 440/1.0a12.json000066400000000000000000000005501456050426100224450ustar00rootroot00000000000000{
    "alpha": true,
    "beta": false,
    "dev": false,
    "major": "1",
    "micro": null,
    "minor": "0",
    "modifier_type": "a",
    "modifier": "a12",
    "patch": null,
    "prefix": null,
    "release_candidate": false,
    "sections": 2,
    "simple": false,
    "strategy": "PEP 440",
    "string": "1.0a12",
    "valid": true,
    "year": "1"
}awesomeversion-24.2.0/tests/snapshots/PEP 440/1.0a2.dev456.json000066400000000000000000000005631456050426100234040ustar00rootroot00000000000000{
    "alpha": false,
    "beta": false,
    "dev": true,
    "major": "1",
    "micro": null,
    "minor": "0",
    "modifier_type": "dev",
    "modifier": "dev456",
    "patch": null,
    "prefix": null,
    "release_candidate": false,
    "sections": 2,
    "simple": false,
    "strategy": "PEP 440",
    "string": "1.0a2.dev456",
    "valid": true,
    "year": "1"
}awesomeversion-24.2.0/tests/snapshots/PEP 440/1.0b0.json000066400000000000000000000005461456050426100223700ustar00rootroot00000000000000{
    "alpha": false,
    "beta": true,
    "dev": false,
    "major": "1",
    "micro": null,
    "minor": "0",
    "modifier_type": "b",
    "modifier": "b0",
    "patch": null,
    "prefix": null,
    "release_candidate": false,
    "sections": 2,
    "simple": false,
    "strategy": "PEP 440",
    "string": "1.0b0",
    "valid": true,
    "year": "1"
}awesomeversion-24.2.0/tests/snapshots/PEP 440/1.0b1.dev456.json000066400000000000000000000005631456050426100234040ustar00rootroot00000000000000{
    "alpha": false,
    "beta": false,
    "dev": true,
    "major": "1",
    "micro": null,
    "minor": "0",
    "modifier_type": "dev",
    "modifier": "dev456",
    "patch": null,
    "prefix": null,
    "release_candidate": false,
    "sections": 2,
    "simple": false,
    "strategy": "PEP 440",
    "string": "1.0b1.dev456",
    "valid": true,
    "year": "1"
}awesomeversion-24.2.0/tests/snapshots/PEP 440/1.0b1.json000066400000000000000000000005461456050426100223710ustar00rootroot00000000000000{
    "alpha": false,
    "beta": true,
    "dev": false,
    "major": "1",
    "micro": null,
    "minor": "0",
    "modifier_type": "b",
    "modifier": "b1",
    "patch": null,
    "prefix": null,
    "release_candidate": false,
    "sections": 2,
    "simple": false,
    "strategy": "PEP 440",
    "string": "1.0b1",
    "valid": true,
    "year": "1"
}awesomeversion-24.2.0/tests/snapshots/PEP 440/1.0b2.json000066400000000000000000000005461456050426100223720ustar00rootroot00000000000000{
    "alpha": false,
    "beta": true,
    "dev": false,
    "major": "1",
    "micro": null,
    "minor": "0",
    "modifier_type": "b",
    "modifier": "b2",
    "patch": null,
    "prefix": null,
    "release_candidate": false,
    "sections": 2,
    "simple": false,
    "strategy": "PEP 440",
    "string": "1.0b2",
    "valid": true,
    "year": "1"
}awesomeversion-24.2.0/tests/snapshots/PEP 440/1.0b2.post345.dev456.json000066400000000000000000000005751456050426100246300ustar00rootroot00000000000000{
    "alpha": false,
    "beta": false,
    "dev": true,
    "major": "1",
    "micro": "345",
    "minor": "0",
    "modifier_type": "dev",
    "modifier": "dev456",
    "patch": "345",
    "prefix": null,
    "release_candidate": false,
    "sections": 3,
    "simple": false,
    "strategy": "PEP 440",
    "string": "1.0b2.post345.dev456",
    "valid": true,
    "year": "1"
}awesomeversion-24.2.0/tests/snapshots/PEP 440/1.0b2.post345.json000066400000000000000000000005671456050426100236150ustar00rootroot00000000000000{
    "alpha": false,
    "beta": false,
    "dev": false,
    "major": "1",
    "micro": null,
    "minor": "0",
    "modifier_type": "post",
    "modifier": "post345",
    "patch": null,
    "prefix": null,
    "release_candidate": false,
    "sections": 2,
    "simple": false,
    "strategy": "PEP 440",
    "string": "1.0b2.post345",
    "valid": true,
    "year": "1"
}awesomeversion-24.2.0/tests/snapshots/PEP 440/1.0rc1.dev456.json000066400000000000000000000005641456050426100235700ustar00rootroot00000000000000{
    "alpha": false,
    "beta": false,
    "dev": true,
    "major": "1",
    "micro": null,
    "minor": "0",
    "modifier_type": "dev",
    "modifier": "dev456",
    "patch": null,
    "prefix": null,
    "release_candidate": false,
    "sections": 2,
    "simple": false,
    "strategy": "PEP 440",
    "string": "1.0rc1.dev456",
    "valid": true,
    "year": "1"
}awesomeversion-24.2.0/tests/snapshots/PEP 440/1.0rc1.json000066400000000000000000000005511456050426100225500ustar00rootroot00000000000000{
    "alpha": false,
    "beta": false,
    "dev": false,
    "major": "1",
    "micro": null,
    "minor": "0",
    "modifier_type": "rc",
    "modifier": "rc1",
    "patch": null,
    "prefix": null,
    "release_candidate": true,
    "sections": 2,
    "simple": false,
    "strategy": "PEP 440",
    "string": "1.0rc1",
    "valid": true,
    "year": "1"
}awesomeversion-24.2.0/tests/snapshots/PEP 440/1.1.dev1.json000066400000000000000000000005551456050426100230050ustar00rootroot00000000000000{
    "alpha": false,
    "beta": false,
    "dev": true,
    "major": "1",
    "micro": null,
    "minor": "1",
    "modifier_type": "dev",
    "modifier": "dev1",
    "patch": null,
    "prefix": null,
    "release_candidate": false,
    "sections": 2,
    "simple": false,
    "strategy": "PEP 440",
    "string": "1.1.dev1",
    "valid": true,
    "year": "1"
}awesomeversion-24.2.0/tests/snapshots/PEP 440/1.2.3.4.5b0.json000066400000000000000000000005521456050426100230350ustar00rootroot00000000000000{
    "alpha": false,
    "beta": true,
    "dev": false,
    "major": "1",
    "micro": "3",
    "minor": "2",
    "modifier_type": "b",
    "modifier": "b0",
    "patch": "3",
    "prefix": null,
    "release_candidate": false,
    "sections": 5,
    "simple": false,
    "strategy": "PEP 440",
    "string": "1.2.3.4.5b0",
    "valid": true,
    "year": "1"
}awesomeversion-24.2.0/tests/snapshots/PEP 440/1.2b0.json000066400000000000000000000005461456050426100223720ustar00rootroot00000000000000{
    "alpha": false,
    "beta": true,
    "dev": false,
    "major": "1",
    "micro": null,
    "minor": "2",
    "modifier_type": "b",
    "modifier": "b0",
    "patch": null,
    "prefix": null,
    "release_candidate": false,
    "sections": 2,
    "simple": false,
    "strategy": "PEP 440",
    "string": "1.2b0",
    "valid": true,
    "year": "1"
}awesomeversion-24.2.0/tests/snapshots/PEP 440/1.dev0.json000066400000000000000000000005541456050426100226440ustar00rootroot00000000000000{
    "alpha": false,
    "beta": false,
    "dev": true,
    "major": "1",
    "micro": null,
    "minor": null,
    "modifier_type": "dev",
    "modifier": "dev0",
    "patch": null,
    "prefix": null,
    "release_candidate": false,
    "sections": 1,
    "simple": false,
    "strategy": "PEP 440",
    "string": "1.dev0",
    "valid": true,
    "year": "1"
}awesomeversion-24.2.0/tests/snapshots/PEP 440/1.dev1.json000066400000000000000000000005541456050426100226450ustar00rootroot00000000000000{
    "alpha": false,
    "beta": false,
    "dev": true,
    "major": "1",
    "micro": null,
    "minor": null,
    "modifier_type": "dev",
    "modifier": "dev1",
    "patch": null,
    "prefix": null,
    "release_candidate": false,
    "sections": 1,
    "simple": false,
    "strategy": "PEP 440",
    "string": "1.dev1",
    "valid": true,
    "year": "1"
}awesomeversion-24.2.0/tests/snapshots/PEP 440/6.0.dev20210429.json000066400000000000000000000005731456050426100235540ustar00rootroot00000000000000{
    "alpha": false,
    "beta": false,
    "dev": true,
    "major": "6",
    "micro": null,
    "minor": "0",
    "modifier_type": "dev",
    "modifier": "dev20210429",
    "patch": null,
    "prefix": null,
    "release_candidate": false,
    "sections": 2,
    "simple": false,
    "strategy": "PEP 440",
    "string": "6.0.dev20210429",
    "valid": true,
    "year": "6"
}awesomeversion-24.2.0/tests/snapshots/PEP 440/6.0.rc1.json000066400000000000000000000005521456050426100226340ustar00rootroot00000000000000{
    "alpha": false,
    "beta": false,
    "dev": false,
    "major": "6",
    "micro": null,
    "minor": "0",
    "modifier_type": "rc",
    "modifier": "rc1",
    "patch": null,
    "prefix": null,
    "release_candidate": true,
    "sections": 2,
    "simple": false,
    "strategy": "PEP 440",
    "string": "6.0.rc1",
    "valid": true,
    "year": "6"
}awesomeversion-24.2.0/tests/snapshots/SemVer/000077500000000000000000000000001456050426100212355ustar00rootroot00000000000000awesomeversion-24.2.0/tests/snapshots/SemVer/0.118.0.json000066400000000000000000000005501456050426100227350ustar00rootroot00000000000000{
    "alpha": false,
    "beta": false,
    "dev": false,
    "major": "0",
    "micro": "0",
    "minor": "118",
    "modifier_type": null,
    "modifier": null,
    "patch": "0",
    "prefix": null,
    "release_candidate": false,
    "sections": 3,
    "simple": true,
    "strategy": "SemVer",
    "string": "0.118.0",
    "valid": true,
    "year": "0"
}awesomeversion-24.2.0/tests/snapshots/SemVer/1.0.0-alpha+1.2.json000066400000000000000000000005641456050426100241500ustar00rootroot00000000000000{
    "alpha": true,
    "beta": false,
    "dev": false,
    "major": "1",
    "micro": "0",
    "minor": "0",
    "modifier_type": "alpha",
    "modifier": "alpha",
    "patch": "0",
    "prefix": null,
    "release_candidate": false,
    "sections": 3,
    "simple": false,
    "strategy": "SemVer",
    "string": "1.0.0-alpha+1.2",
    "valid": true,
    "year": "1"
}awesomeversion-24.2.0/tests/snapshots/SemVer/1.0.0-alpha.1.json000066400000000000000000000005641456050426100240130ustar00rootroot00000000000000{
    "alpha": true,
    "beta": false,
    "dev": false,
    "major": "1",
    "micro": "0",
    "minor": "0",
    "modifier_type": "alpha",
    "modifier": "alpha.1",
    "patch": "0",
    "prefix": null,
    "release_candidate": false,
    "sections": 3,
    "simple": false,
    "strategy": "SemVer",
    "string": "1.0.0-alpha.1",
    "valid": true,
    "year": "1"
}awesomeversion-24.2.0/tests/snapshots/SemVer/1.0.0-alpha.2.json000066400000000000000000000005641456050426100240140ustar00rootroot00000000000000{
    "alpha": true,
    "beta": false,
    "dev": false,
    "major": "1",
    "micro": "0",
    "minor": "0",
    "modifier_type": "alpha",
    "modifier": "alpha.2",
    "patch": "0",
    "prefix": null,
    "release_candidate": false,
    "sections": 3,
    "simple": false,
    "strategy": "SemVer",
    "string": "1.0.0-alpha.2",
    "valid": true,
    "year": "1"
}awesomeversion-24.2.0/tests/snapshots/SemVer/1.0.0-alpha.json000066400000000000000000000005601456050426100236500ustar00rootroot00000000000000{
    "alpha": true,
    "beta": false,
    "dev": false,
    "major": "1",
    "micro": "0",
    "minor": "0",
    "modifier_type": "alpha",
    "modifier": "alpha",
    "patch": "0",
    "prefix": null,
    "release_candidate": false,
    "sections": 3,
    "simple": false,
    "strategy": "SemVer",
    "string": "1.0.0-alpha",
    "valid": true,
    "year": "1"
}awesomeversion-24.2.0/tests/snapshots/SemVer/1.0.0-alpha1.json000066400000000000000000000005621456050426100237330ustar00rootroot00000000000000{
    "alpha": true,
    "beta": false,
    "dev": false,
    "major": "1",
    "micro": "0",
    "minor": "0",
    "modifier_type": "alpha",
    "modifier": "alpha1",
    "patch": "0",
    "prefix": null,
    "release_candidate": false,
    "sections": 3,
    "simple": false,
    "strategy": "SemVer",
    "string": "1.0.0-alpha1",
    "valid": true,
    "year": "1"
}awesomeversion-24.2.0/tests/snapshots/SemVer/1.0.0-alpha10.json000066400000000000000000000005641456050426100240150ustar00rootroot00000000000000{
    "alpha": true,
    "beta": false,
    "dev": false,
    "major": "1",
    "micro": "0",
    "minor": "0",
    "modifier_type": "alpha",
    "modifier": "alpha10",
    "patch": "0",
    "prefix": null,
    "release_candidate": false,
    "sections": 3,
    "simple": false,
    "strategy": "SemVer",
    "string": "1.0.0-alpha10",
    "valid": true,
    "year": "1"
}awesomeversion-24.2.0/tests/snapshots/SemVer/1.0.0-alpha9.json000066400000000000000000000005621456050426100237430ustar00rootroot00000000000000{
    "alpha": true,
    "beta": false,
    "dev": false,
    "major": "1",
    "micro": "0",
    "minor": "0",
    "modifier_type": "alpha",
    "modifier": "alpha9",
    "patch": "0",
    "prefix": null,
    "release_candidate": false,
    "sections": 3,
    "simple": false,
    "strategy": "SemVer",
    "string": "1.0.0-alpha9",
    "valid": true,
    "year": "1"
}awesomeversion-24.2.0/tests/snapshots/SemVer/1.0.0-beta.1.json000066400000000000000000000005601456050426100236350ustar00rootroot00000000000000{
    "alpha": true,
    "beta": true,
    "dev": false,
    "major": "1",
    "micro": "0",
    "minor": "0",
    "modifier_type": "beta",
    "modifier": "beta.1",
    "patch": "0",
    "prefix": null,
    "release_candidate": false,
    "sections": 3,
    "simple": false,
    "strategy": "SemVer",
    "string": "1.0.0-beta.1",
    "valid": true,
    "year": "1"
}awesomeversion-24.2.0/tests/snapshots/SemVer/1.0.0-beta.10.json000066400000000000000000000005621456050426100237170ustar00rootroot00000000000000{
    "alpha": true,
    "beta": true,
    "dev": false,
    "major": "1",
    "micro": "0",
    "minor": "0",
    "modifier_type": "beta",
    "modifier": "beta.10",
    "patch": "0",
    "prefix": null,
    "release_candidate": false,
    "sections": 3,
    "simple": false,
    "strategy": "SemVer",
    "string": "1.0.0-beta.10",
    "valid": true,
    "year": "1"
}awesomeversion-24.2.0/tests/snapshots/SemVer/1.0.0-beta.2.json000066400000000000000000000005601456050426100236360ustar00rootroot00000000000000{
    "alpha": true,
    "beta": true,
    "dev": false,
    "major": "1",
    "micro": "0",
    "minor": "0",
    "modifier_type": "beta",
    "modifier": "beta.2",
    "patch": "0",
    "prefix": null,
    "release_candidate": false,
    "sections": 3,
    "simple": false,
    "strategy": "SemVer",
    "string": "1.0.0-beta.2",
    "valid": true,
    "year": "1"
}awesomeversion-24.2.0/tests/snapshots/SemVer/1.0.0-beta.9.json000066400000000000000000000005601456050426100236450ustar00rootroot00000000000000{
    "alpha": true,
    "beta": true,
    "dev": false,
    "major": "1",
    "micro": "0",
    "minor": "0",
    "modifier_type": "beta",
    "modifier": "beta.9",
    "patch": "0",
    "prefix": null,
    "release_candidate": false,
    "sections": 3,
    "simple": false,
    "strategy": "SemVer",
    "string": "1.0.0-beta.9",
    "valid": true,
    "year": "1"
}awesomeversion-24.2.0/tests/snapshots/SemVer/1.0.0-beta.json000066400000000000000000000005541456050426100235010ustar00rootroot00000000000000{
    "alpha": true,
    "beta": true,
    "dev": false,
    "major": "1",
    "micro": "0",
    "minor": "0",
    "modifier_type": "beta",
    "modifier": "beta",
    "patch": "0",
    "prefix": null,
    "release_candidate": false,
    "sections": 3,
    "simple": false,
    "strategy": "SemVer",
    "string": "1.0.0-beta",
    "valid": true,
    "year": "1"
}awesomeversion-24.2.0/tests/snapshots/SemVer/1.0.0-beta0.json000066400000000000000000000005561456050426100235630ustar00rootroot00000000000000{
    "alpha": true,
    "beta": true,
    "dev": false,
    "major": "1",
    "micro": "0",
    "minor": "0",
    "modifier_type": "beta",
    "modifier": "beta0",
    "patch": "0",
    "prefix": null,
    "release_candidate": false,
    "sections": 3,
    "simple": false,
    "strategy": "SemVer",
    "string": "1.0.0-beta0",
    "valid": true,
    "year": "1"
}awesomeversion-24.2.0/tests/snapshots/SemVer/1.0.0-beta1.json000066400000000000000000000005561456050426100235640ustar00rootroot00000000000000{
    "alpha": true,
    "beta": true,
    "dev": false,
    "major": "1",
    "micro": "0",
    "minor": "0",
    "modifier_type": "beta",
    "modifier": "beta1",
    "patch": "0",
    "prefix": null,
    "release_candidate": false,
    "sections": 3,
    "simple": false,
    "strategy": "SemVer",
    "string": "1.0.0-beta1",
    "valid": true,
    "year": "1"
}awesomeversion-24.2.0/tests/snapshots/SemVer/1.0.0-rc.1.json000066400000000000000000000005531456050426100233300ustar00rootroot00000000000000{
    "alpha": false,
    "beta": false,
    "dev": false,
    "major": "1",
    "micro": "0",
    "minor": "0",
    "modifier_type": "rc",
    "modifier": "rc.1",
    "patch": "0",
    "prefix": null,
    "release_candidate": true,
    "sections": 3,
    "simple": false,
    "strategy": "SemVer",
    "string": "1.0.0-rc.1",
    "valid": true,
    "year": "1"
}awesomeversion-24.2.0/tests/snapshots/SemVer/1.0.0-rc.2.json000066400000000000000000000005531456050426100233310ustar00rootroot00000000000000{
    "alpha": false,
    "beta": false,
    "dev": false,
    "major": "1",
    "micro": "0",
    "minor": "0",
    "modifier_type": "rc",
    "modifier": "rc.2",
    "patch": "0",
    "prefix": null,
    "release_candidate": true,
    "sections": 3,
    "simple": false,
    "strategy": "SemVer",
    "string": "1.0.0-rc.2",
    "valid": true,
    "year": "1"
}awesomeversion-24.2.0/tests/snapshots/SemVer/1.0.0-rc0.json000066400000000000000000000005511456050426100232470ustar00rootroot00000000000000{
    "alpha": false,
    "beta": false,
    "dev": false,
    "major": "1",
    "micro": "0",
    "minor": "0",
    "modifier_type": "rc",
    "modifier": "rc0",
    "patch": "0",
    "prefix": null,
    "release_candidate": true,
    "sections": 3,
    "simple": false,
    "strategy": "SemVer",
    "string": "1.0.0-rc0",
    "valid": true,
    "year": "1"
}awesomeversion-24.2.0/tests/snapshots/SemVer/1.0.0.json000066400000000000000000000005441456050426100225670ustar00rootroot00000000000000{
    "alpha": false,
    "beta": false,
    "dev": false,
    "major": "1",
    "micro": "0",
    "minor": "0",
    "modifier_type": null,
    "modifier": null,
    "patch": "0",
    "prefix": null,
    "release_candidate": false,
    "sections": 3,
    "simple": true,
    "strategy": "SemVer",
    "string": "1.0.0",
    "valid": true,
    "year": "1"
}awesomeversion-24.2.0/tests/snapshots/SemVer/1.0.1.json000066400000000000000000000005441456050426100225700ustar00rootroot00000000000000{
    "alpha": false,
    "beta": false,
    "dev": false,
    "major": "1",
    "micro": "1",
    "minor": "0",
    "modifier_type": null,
    "modifier": null,
    "patch": "1",
    "prefix": null,
    "release_candidate": false,
    "sections": 3,
    "simple": true,
    "strategy": "SemVer",
    "string": "1.0.1",
    "valid": true,
    "year": "1"
}awesomeversion-24.2.0/tests/snapshots/SemVer/1.2.3-1.json000066400000000000000000000005461456050426100227340ustar00rootroot00000000000000{
    "alpha": false,
    "beta": false,
    "dev": false,
    "major": "1",
    "micro": "3",
    "minor": "2",
    "modifier_type": null,
    "modifier": "1",
    "patch": "3",
    "prefix": null,
    "release_candidate": false,
    "sections": 3,
    "simple": false,
    "strategy": "SemVer",
    "string": "1.2.3-1",
    "valid": true,
    "year": "1"
}awesomeversion-24.2.0/tests/snapshots/SemVer/1.2.3-2.json000066400000000000000000000005461456050426100227350ustar00rootroot00000000000000{
    "alpha": false,
    "beta": false,
    "dev": false,
    "major": "1",
    "micro": "3",
    "minor": "2",
    "modifier_type": null,
    "modifier": "2",
    "patch": "3",
    "prefix": null,
    "release_candidate": false,
    "sections": 3,
    "simple": false,
    "strategy": "SemVer",
    "string": "1.2.3-2",
    "valid": true,
    "year": "1"
}awesomeversion-24.2.0/tests/snapshots/SemVer/1.2.3-alpha.1.json000066400000000000000000000005641456050426100240200ustar00rootroot00000000000000{
    "alpha": true,
    "beta": false,
    "dev": false,
    "major": "1",
    "micro": "3",
    "minor": "2",
    "modifier_type": "alpha",
    "modifier": "alpha.1",
    "patch": "3",
    "prefix": null,
    "release_candidate": false,
    "sections": 3,
    "simple": false,
    "strategy": "SemVer",
    "string": "1.2.3-alpha.1",
    "valid": true,
    "year": "1"
}awesomeversion-24.2.0/tests/snapshots/SemVer/1.2.3-dev.1.json000066400000000000000000000005561456050426100235120ustar00rootroot00000000000000{
    "alpha": false,
    "beta": false,
    "dev": true,
    "major": "1",
    "micro": "3",
    "minor": "2",
    "modifier_type": "dev",
    "modifier": "dev.1",
    "patch": "3",
    "prefix": null,
    "release_candidate": false,
    "sections": 3,
    "simple": false,
    "strategy": "SemVer",
    "string": "1.2.3-dev.1",
    "valid": true,
    "year": "1"
}awesomeversion-24.2.0/tests/snapshots/SemVer/1.2.3.json000066400000000000000000000005441456050426100225740ustar00rootroot00000000000000{
    "alpha": false,
    "beta": false,
    "dev": false,
    "major": "1",
    "micro": "3",
    "minor": "2",
    "modifier_type": null,
    "modifier": null,
    "patch": "3",
    "prefix": null,
    "release_candidate": false,
    "sections": 3,
    "simple": true,
    "strategy": "SemVer",
    "string": "1.2.3",
    "valid": true,
    "year": "1"
}awesomeversion-24.2.0/tests/snapshots/SemVer/1.8.2-beta.1.10+somebuild.json000066400000000000000000000005761456050426100260540ustar00rootroot00000000000000{
    "alpha": true,
    "beta": true,
    "dev": false,
    "major": "1",
    "micro": "2",
    "minor": "8",
    "modifier_type": null,
    "modifier": "beta.1.10",
    "patch": "2",
    "prefix": null,
    "release_candidate": false,
    "sections": 3,
    "simple": false,
    "strategy": "SemVer",
    "string": "1.8.2-beta.1.10+somebuild",
    "valid": true,
    "year": "1"
}awesomeversion-24.2.0/tests/snapshots/SemVer/1.8.2-beta.1.10.json000066400000000000000000000005641456050426100240720ustar00rootroot00000000000000{
    "alpha": true,
    "beta": true,
    "dev": false,
    "major": "1",
    "micro": "2",
    "minor": "8",
    "modifier_type": null,
    "modifier": "beta.1.10",
    "patch": "2",
    "prefix": null,
    "release_candidate": false,
    "sections": 3,
    "simple": false,
    "strategy": "SemVer",
    "string": "1.8.2-beta.1.10",
    "valid": true,
    "year": "1"
}awesomeversion-24.2.0/tests/snapshots/SemVer/1.8.2-beta.1.13.json000066400000000000000000000005641456050426100240750ustar00rootroot00000000000000{
    "alpha": true,
    "beta": true,
    "dev": false,
    "major": "1",
    "micro": "2",
    "minor": "8",
    "modifier_type": null,
    "modifier": "beta.1.13",
    "patch": "2",
    "prefix": null,
    "release_candidate": false,
    "sections": 3,
    "simple": false,
    "strategy": "SemVer",
    "string": "1.8.2-beta.1.13",
    "valid": true,
    "year": "1"
}awesomeversion-24.2.0/tests/snapshots/SemVer/2.0.0-alpha.1.json000066400000000000000000000005641456050426100240140ustar00rootroot00000000000000{
    "alpha": true,
    "beta": false,
    "dev": false,
    "major": "2",
    "micro": "0",
    "minor": "0",
    "modifier_type": "alpha",
    "modifier": "alpha.1",
    "patch": "0",
    "prefix": null,
    "release_candidate": false,
    "sections": 3,
    "simple": false,
    "strategy": "SemVer",
    "string": "2.0.0-alpha.1",
    "valid": true,
    "year": "2"
}awesomeversion-24.2.0/tests/snapshots/SemVer/2.0.0-alpha.2.json000066400000000000000000000005641456050426100240150ustar00rootroot00000000000000{
    "alpha": true,
    "beta": false,
    "dev": false,
    "major": "2",
    "micro": "0",
    "minor": "0",
    "modifier_type": "alpha",
    "modifier": "alpha.2",
    "patch": "0",
    "prefix": null,
    "release_candidate": false,
    "sections": 3,
    "simple": false,
    "strategy": "SemVer",
    "string": "2.0.0-alpha.2",
    "valid": true,
    "year": "2"
}awesomeversion-24.2.0/tests/snapshots/SemVer/2.0.0-beta.1.json000066400000000000000000000005601456050426100236360ustar00rootroot00000000000000{
    "alpha": true,
    "beta": true,
    "dev": false,
    "major": "2",
    "micro": "0",
    "minor": "0",
    "modifier_type": "beta",
    "modifier": "beta.1",
    "patch": "0",
    "prefix": null,
    "release_candidate": false,
    "sections": 3,
    "simple": false,
    "strategy": "SemVer",
    "string": "2.0.0-beta.1",
    "valid": true,
    "year": "2"
}awesomeversion-24.2.0/tests/snapshots/SemVer/2.0.0-beta.2.json000066400000000000000000000005601456050426100236370ustar00rootroot00000000000000{
    "alpha": true,
    "beta": true,
    "dev": false,
    "major": "2",
    "micro": "0",
    "minor": "0",
    "modifier_type": "beta",
    "modifier": "beta.2",
    "patch": "0",
    "prefix": null,
    "release_candidate": false,
    "sections": 3,
    "simple": false,
    "strategy": "SemVer",
    "string": "2.0.0-beta.2",
    "valid": true,
    "year": "2"
}awesomeversion-24.2.0/tests/snapshots/SemVer/2.0.0-rc.1.json000066400000000000000000000005531456050426100233310ustar00rootroot00000000000000{
    "alpha": false,
    "beta": false,
    "dev": false,
    "major": "2",
    "micro": "0",
    "minor": "0",
    "modifier_type": "rc",
    "modifier": "rc.1",
    "patch": "0",
    "prefix": null,
    "release_candidate": true,
    "sections": 3,
    "simple": false,
    "strategy": "SemVer",
    "string": "2.0.0-rc.1",
    "valid": true,
    "year": "2"
}awesomeversion-24.2.0/tests/snapshots/SemVer/2.0.0-rc.2.json000066400000000000000000000005531456050426100233320ustar00rootroot00000000000000{
    "alpha": false,
    "beta": false,
    "dev": false,
    "major": "2",
    "micro": "0",
    "minor": "0",
    "modifier_type": "rc",
    "modifier": "rc.2",
    "patch": "0",
    "prefix": null,
    "release_candidate": true,
    "sections": 3,
    "simple": false,
    "strategy": "SemVer",
    "string": "2.0.0-rc.2",
    "valid": true,
    "year": "2"
}awesomeversion-24.2.0/tests/snapshots/SemVer/2.0.0.json000066400000000000000000000005441456050426100225700ustar00rootroot00000000000000{
    "alpha": false,
    "beta": false,
    "dev": false,
    "major": "2",
    "micro": "0",
    "minor": "0",
    "modifier_type": null,
    "modifier": null,
    "patch": "0",
    "prefix": null,
    "release_candidate": false,
    "sections": 3,
    "simple": true,
    "strategy": "SemVer",
    "string": "2.0.0",
    "valid": true,
    "year": "2"
}awesomeversion-24.2.0/tests/snapshots/SemVer/2.1.0.json000066400000000000000000000005441456050426100225710ustar00rootroot00000000000000{
    "alpha": false,
    "beta": false,
    "dev": false,
    "major": "2",
    "micro": "0",
    "minor": "1",
    "modifier_type": null,
    "modifier": null,
    "patch": "0",
    "prefix": null,
    "release_candidate": false,
    "sections": 3,
    "simple": true,
    "strategy": "SemVer",
    "string": "2.1.0",
    "valid": true,
    "year": "2"
}awesomeversion-24.2.0/tests/snapshots/SemVer/2.1.1.json000066400000000000000000000005441456050426100225720ustar00rootroot00000000000000{
    "alpha": false,
    "beta": false,
    "dev": false,
    "major": "2",
    "micro": "1",
    "minor": "1",
    "modifier_type": null,
    "modifier": null,
    "patch": "1",
    "prefix": null,
    "release_candidate": false,
    "sections": 3,
    "simple": true,
    "strategy": "SemVer",
    "string": "2.1.1",
    "valid": true,
    "year": "2"
}awesomeversion-24.2.0/tests/snapshots/SemVer/2.1.3.json000066400000000000000000000005441456050426100225740ustar00rootroot00000000000000{
    "alpha": false,
    "beta": false,
    "dev": false,
    "major": "2",
    "micro": "3",
    "minor": "1",
    "modifier_type": null,
    "modifier": null,
    "patch": "3",
    "prefix": null,
    "release_candidate": false,
    "sections": 3,
    "simple": true,
    "strategy": "SemVer",
    "string": "2.1.3",
    "valid": true,
    "year": "2"
}awesomeversion-24.2.0/tests/snapshots/SemVer/2.4.6-8.json000066400000000000000000000005461456050426100227510ustar00rootroot00000000000000{
    "alpha": false,
    "beta": false,
    "dev": false,
    "major": "2",
    "micro": "6",
    "minor": "4",
    "modifier_type": null,
    "modifier": "8",
    "patch": "6",
    "prefix": null,
    "release_candidate": false,
    "sections": 3,
    "simple": false,
    "strategy": "SemVer",
    "string": "2.4.6-8",
    "valid": true,
    "year": "2"
}awesomeversion-24.2.0/tests/snapshots/SemVer/3.0.0-alpha.1.json000066400000000000000000000005641456050426100240150ustar00rootroot00000000000000{
    "alpha": true,
    "beta": false,
    "dev": false,
    "major": "3",
    "micro": "0",
    "minor": "0",
    "modifier_type": "alpha",
    "modifier": "alpha.1",
    "patch": "0",
    "prefix": null,
    "release_candidate": false,
    "sections": 3,
    "simple": false,
    "strategy": "SemVer",
    "string": "3.0.0-alpha.1",
    "valid": true,
    "year": "3"
}awesomeversion-24.2.0/tests/snapshots/SemVer/3.0.0-alpha.2.json000066400000000000000000000005641456050426100240160ustar00rootroot00000000000000{
    "alpha": true,
    "beta": false,
    "dev": false,
    "major": "3",
    "micro": "0",
    "minor": "0",
    "modifier_type": "alpha",
    "modifier": "alpha.2",
    "patch": "0",
    "prefix": null,
    "release_candidate": false,
    "sections": 3,
    "simple": false,
    "strategy": "SemVer",
    "string": "3.0.0-alpha.2",
    "valid": true,
    "year": "3"
}awesomeversion-24.2.0/tests/snapshots/SemVer/3.0.0-beta.1.json000066400000000000000000000005601456050426100236370ustar00rootroot00000000000000{
    "alpha": true,
    "beta": true,
    "dev": false,
    "major": "3",
    "micro": "0",
    "minor": "0",
    "modifier_type": "beta",
    "modifier": "beta.1",
    "patch": "0",
    "prefix": null,
    "release_candidate": false,
    "sections": 3,
    "simple": false,
    "strategy": "SemVer",
    "string": "3.0.0-beta.1",
    "valid": true,
    "year": "3"
}awesomeversion-24.2.0/tests/snapshots/SemVer/3.0.0-beta.2.json000066400000000000000000000005601456050426100236400ustar00rootroot00000000000000{
    "alpha": true,
    "beta": true,
    "dev": false,
    "major": "3",
    "micro": "0",
    "minor": "0",
    "modifier_type": "beta",
    "modifier": "beta.2",
    "patch": "0",
    "prefix": null,
    "release_candidate": false,
    "sections": 3,
    "simple": false,
    "strategy": "SemVer",
    "string": "3.0.0-beta.2",
    "valid": true,
    "year": "3"
}awesomeversion-24.2.0/tests/snapshots/SemVer/3.0.0-rc.1.json000066400000000000000000000005531456050426100233320ustar00rootroot00000000000000{
    "alpha": false,
    "beta": false,
    "dev": false,
    "major": "3",
    "micro": "0",
    "minor": "0",
    "modifier_type": "rc",
    "modifier": "rc.1",
    "patch": "0",
    "prefix": null,
    "release_candidate": true,
    "sections": 3,
    "simple": false,
    "strategy": "SemVer",
    "string": "3.0.0-rc.1",
    "valid": true,
    "year": "3"
}awesomeversion-24.2.0/tests/snapshots/SemVer/3.0.0-rc.2.json000066400000000000000000000005531456050426100233330ustar00rootroot00000000000000{
    "alpha": false,
    "beta": false,
    "dev": false,
    "major": "3",
    "micro": "0",
    "minor": "0",
    "modifier_type": "rc",
    "modifier": "rc.2",
    "patch": "0",
    "prefix": null,
    "release_candidate": true,
    "sections": 3,
    "simple": false,
    "strategy": "SemVer",
    "string": "3.0.0-rc.2",
    "valid": true,
    "year": "3"
}awesomeversion-24.2.0/tests/snapshots/SemVer/3.0.0.json000066400000000000000000000005441456050426100225710ustar00rootroot00000000000000{
    "alpha": false,
    "beta": false,
    "dev": false,
    "major": "3",
    "micro": "0",
    "minor": "0",
    "modifier_type": null,
    "modifier": null,
    "patch": "0",
    "prefix": null,
    "release_candidate": false,
    "sections": 3,
    "simple": true,
    "strategy": "SemVer",
    "string": "3.0.0",
    "valid": true,
    "year": "3"
}awesomeversion-24.2.0/tests/snapshots/SemVer/3.0.1.json000066400000000000000000000005441456050426100225720ustar00rootroot00000000000000{
    "alpha": false,
    "beta": false,
    "dev": false,
    "major": "3",
    "micro": "1",
    "minor": "0",
    "modifier_type": null,
    "modifier": null,
    "patch": "1",
    "prefix": null,
    "release_candidate": false,
    "sections": 3,
    "simple": true,
    "strategy": "SemVer",
    "string": "3.0.1",
    "valid": true,
    "year": "3"
}awesomeversion-24.2.0/tests/snapshots/SemVer/4.0.0.json000066400000000000000000000005441456050426100225720ustar00rootroot00000000000000{
    "alpha": false,
    "beta": false,
    "dev": false,
    "major": "4",
    "micro": "0",
    "minor": "0",
    "modifier_type": null,
    "modifier": null,
    "patch": "0",
    "prefix": null,
    "release_candidate": false,
    "sections": 3,
    "simple": true,
    "strategy": "SemVer",
    "string": "4.0.0",
    "valid": true,
    "year": "4"
}awesomeversion-24.2.0/tests/snapshots/SemVer/4.1.0.json000066400000000000000000000005441456050426100225730ustar00rootroot00000000000000{
    "alpha": false,
    "beta": false,
    "dev": false,
    "major": "4",
    "micro": "0",
    "minor": "1",
    "modifier_type": null,
    "modifier": null,
    "patch": "0",
    "prefix": null,
    "release_candidate": false,
    "sections": 3,
    "simple": true,
    "strategy": "SemVer",
    "string": "4.1.0",
    "valid": true,
    "year": "4"
}awesomeversion-24.2.0/tests/snapshots/SemVer/4.2.0.json000066400000000000000000000005441456050426100225740ustar00rootroot00000000000000{
    "alpha": false,
    "beta": false,
    "dev": false,
    "major": "4",
    "micro": "0",
    "minor": "2",
    "modifier_type": null,
    "modifier": null,
    "patch": "0",
    "prefix": null,
    "release_candidate": false,
    "sections": 3,
    "simple": true,
    "strategy": "SemVer",
    "string": "4.2.0",
    "valid": true,
    "year": "4"
}awesomeversion-24.2.0/tests/snapshots/SemVer/5.0.0.json000066400000000000000000000005441456050426100225730ustar00rootroot00000000000000{
    "alpha": false,
    "beta": false,
    "dev": false,
    "major": "5",
    "micro": "0",
    "minor": "0",
    "modifier_type": null,
    "modifier": null,
    "patch": "0",
    "prefix": null,
    "release_candidate": false,
    "sections": 3,
    "simple": true,
    "strategy": "SemVer",
    "string": "5.0.0",
    "valid": true,
    "year": "5"
}awesomeversion-24.2.0/tests/snapshots/SemVer/5.1.0.json000066400000000000000000000005441456050426100225740ustar00rootroot00000000000000{
    "alpha": false,
    "beta": false,
    "dev": false,
    "major": "5",
    "micro": "0",
    "minor": "1",
    "modifier_type": null,
    "modifier": null,
    "patch": "0",
    "prefix": null,
    "release_candidate": false,
    "sections": 3,
    "simple": true,
    "strategy": "SemVer",
    "string": "5.1.0",
    "valid": true,
    "year": "5"
}awesomeversion-24.2.0/tests/snapshots/SemVer/5.1.1.json000066400000000000000000000005441456050426100225750ustar00rootroot00000000000000{
    "alpha": false,
    "beta": false,
    "dev": false,
    "major": "5",
    "micro": "1",
    "minor": "1",
    "modifier_type": null,
    "modifier": null,
    "patch": "1",
    "prefix": null,
    "release_candidate": false,
    "sections": 3,
    "simple": true,
    "strategy": "SemVer",
    "string": "5.1.1",
    "valid": true,
    "year": "5"
}awesomeversion-24.2.0/tests/snapshots/SemVer/6.0.0.json000066400000000000000000000005441456050426100225740ustar00rootroot00000000000000{
    "alpha": false,
    "beta": false,
    "dev": false,
    "major": "6",
    "micro": "0",
    "minor": "0",
    "modifier_type": null,
    "modifier": null,
    "patch": "0",
    "prefix": null,
    "release_candidate": false,
    "sections": 3,
    "simple": true,
    "strategy": "SemVer",
    "string": "6.0.0",
    "valid": true,
    "year": "6"
}awesomeversion-24.2.0/tests/snapshots/SemVer/6.1.0.json000066400000000000000000000005441456050426100225750ustar00rootroot00000000000000{
    "alpha": false,
    "beta": false,
    "dev": false,
    "major": "6",
    "micro": "0",
    "minor": "1",
    "modifier_type": null,
    "modifier": null,
    "patch": "0",
    "prefix": null,
    "release_candidate": false,
    "sections": 3,
    "simple": true,
    "strategy": "SemVer",
    "string": "6.1.0",
    "valid": true,
    "year": "6"
}awesomeversion-24.2.0/tests/snapshots/SemVer/6.2.0.json000066400000000000000000000005441456050426100225760ustar00rootroot00000000000000{
    "alpha": false,
    "beta": false,
    "dev": false,
    "major": "6",
    "micro": "0",
    "minor": "2",
    "modifier_type": null,
    "modifier": null,
    "patch": "0",
    "prefix": null,
    "release_candidate": false,
    "sections": 3,
    "simple": true,
    "strategy": "SemVer",
    "string": "6.2.0",
    "valid": true,
    "year": "6"
}awesomeversion-24.2.0/tests/snapshots/SemVer/7.0.0.json000066400000000000000000000005441456050426100225750ustar00rootroot00000000000000{
    "alpha": false,
    "beta": false,
    "dev": false,
    "major": "7",
    "micro": "0",
    "minor": "0",
    "modifier_type": null,
    "modifier": null,
    "patch": "0",
    "prefix": null,
    "release_candidate": false,
    "sections": 3,
    "simple": true,
    "strategy": "SemVer",
    "string": "7.0.0",
    "valid": true,
    "year": "7"
}awesomeversion-24.2.0/tests/snapshots/SemVer/7.1.0.json000066400000000000000000000005441456050426100225760ustar00rootroot00000000000000{
    "alpha": false,
    "beta": false,
    "dev": false,
    "major": "7",
    "micro": "0",
    "minor": "1",
    "modifier_type": null,
    "modifier": null,
    "patch": "0",
    "prefix": null,
    "release_candidate": false,
    "sections": 3,
    "simple": true,
    "strategy": "SemVer",
    "string": "7.1.0",
    "valid": true,
    "year": "7"
}awesomeversion-24.2.0/tests/snapshots/SemVer/7.1.1.json000066400000000000000000000005441456050426100225770ustar00rootroot00000000000000{
    "alpha": false,
    "beta": false,
    "dev": false,
    "major": "7",
    "micro": "1",
    "minor": "1",
    "modifier_type": null,
    "modifier": null,
    "patch": "1",
    "prefix": null,
    "release_candidate": false,
    "sections": 3,
    "simple": true,
    "strategy": "SemVer",
    "string": "7.1.1",
    "valid": true,
    "year": "7"
}awesomeversion-24.2.0/tests/snapshots/SemVer/v1.0.1.json000066400000000000000000000005431456050426100227550ustar00rootroot00000000000000{
    "alpha": false,
    "beta": false,
    "dev": false,
    "major": "1",
    "micro": "1",
    "minor": "0",
    "modifier_type": null,
    "modifier": null,
    "patch": "1",
    "prefix": "v",
    "release_candidate": false,
    "sections": 3,
    "simple": true,
    "strategy": "SemVer",
    "string": "1.0.1",
    "valid": true,
    "year": "1"
}awesomeversion-24.2.0/tests/snapshots/SemVer/v1.1.1.json000066400000000000000000000005431456050426100227560ustar00rootroot00000000000000{
    "alpha": false,
    "beta": false,
    "dev": false,
    "major": "1",
    "micro": "1",
    "minor": "1",
    "modifier_type": null,
    "modifier": null,
    "patch": "1",
    "prefix": "v",
    "release_candidate": false,
    "sections": 3,
    "simple": true,
    "strategy": "SemVer",
    "string": "1.1.1",
    "valid": true,
    "year": "1"
}awesomeversion-24.2.0/tests/snapshots/SemVer/v1.2.1.json000066400000000000000000000005431456050426100227570ustar00rootroot00000000000000{
    "alpha": false,
    "beta": false,
    "dev": false,
    "major": "1",
    "micro": "1",
    "minor": "2",
    "modifier_type": null,
    "modifier": null,
    "patch": "1",
    "prefix": "v",
    "release_candidate": false,
    "sections": 3,
    "simple": true,
    "strategy": "SemVer",
    "string": "1.2.1",
    "valid": true,
    "year": "1"
}awesomeversion-24.2.0/tests/snapshots/SemVer/v2.0.1.json000066400000000000000000000005431456050426100227560ustar00rootroot00000000000000{
    "alpha": false,
    "beta": false,
    "dev": false,
    "major": "2",
    "micro": "1",
    "minor": "0",
    "modifier_type": null,
    "modifier": null,
    "patch": "1",
    "prefix": "v",
    "release_candidate": false,
    "sections": 3,
    "simple": true,
    "strategy": "SemVer",
    "string": "2.0.1",
    "valid": true,
    "year": "2"
}awesomeversion-24.2.0/tests/snapshots/SemVer/v2.1.1.json000066400000000000000000000005431456050426100227570ustar00rootroot00000000000000{
    "alpha": false,
    "beta": false,
    "dev": false,
    "major": "2",
    "micro": "1",
    "minor": "1",
    "modifier_type": null,
    "modifier": null,
    "patch": "1",
    "prefix": "v",
    "release_candidate": false,
    "sections": 3,
    "simple": true,
    "strategy": "SemVer",
    "string": "2.1.1",
    "valid": true,
    "year": "2"
}awesomeversion-24.2.0/tests/snapshots/SemVer/v2.2.1.json000066400000000000000000000005431456050426100227600ustar00rootroot00000000000000{
    "alpha": false,
    "beta": false,
    "dev": false,
    "major": "2",
    "micro": "1",
    "minor": "2",
    "modifier_type": null,
    "modifier": null,
    "patch": "1",
    "prefix": "v",
    "release_candidate": false,
    "sections": 3,
    "simple": true,
    "strategy": "SemVer",
    "string": "2.2.1",
    "valid": true,
    "year": "2"
}awesomeversion-24.2.0/tests/snapshots/SimpleVer/000077500000000000000000000000001456050426100217425ustar00rootroot00000000000000awesomeversion-24.2.0/tests/snapshots/SimpleVer/0.1.json000066400000000000000000000005471456050426100231410ustar00rootroot00000000000000{
    "alpha": false,
    "beta": false,
    "dev": false,
    "major": "0",
    "micro": null,
    "minor": "1",
    "modifier_type": null,
    "modifier": null,
    "patch": null,
    "prefix": null,
    "release_candidate": false,
    "sections": 2,
    "simple": true,
    "strategy": "SimpleVer",
    "string": "0.1",
    "valid": true,
    "year": "0"
}awesomeversion-24.2.0/tests/snapshots/SimpleVer/1.0.json000066400000000000000000000005471456050426100231410ustar00rootroot00000000000000{
    "alpha": false,
    "beta": false,
    "dev": false,
    "major": "1",
    "micro": null,
    "minor": "0",
    "modifier_type": null,
    "modifier": null,
    "patch": null,
    "prefix": null,
    "release_candidate": false,
    "sections": 2,
    "simple": true,
    "strategy": "SimpleVer",
    "string": "1.0",
    "valid": true,
    "year": "1"
}awesomeversion-24.2.0/tests/snapshots/SimpleVer/1.1.json000066400000000000000000000005471456050426100231420ustar00rootroot00000000000000{
    "alpha": false,
    "beta": false,
    "dev": false,
    "major": "1",
    "micro": null,
    "minor": "1",
    "modifier_type": null,
    "modifier": null,
    "patch": null,
    "prefix": null,
    "release_candidate": false,
    "sections": 2,
    "simple": true,
    "strategy": "SimpleVer",
    "string": "1.1",
    "valid": true,
    "year": "1"
}awesomeversion-24.2.0/tests/snapshots/SimpleVer/1.2.3.4.5.6.6.8.json000066400000000000000000000005611456050426100242630ustar00rootroot00000000000000{
    "alpha": false,
    "beta": false,
    "dev": false,
    "major": "1",
    "micro": "3",
    "minor": "2",
    "modifier_type": null,
    "modifier": null,
    "patch": "3",
    "prefix": null,
    "release_candidate": false,
    "sections": 8,
    "simple": true,
    "strategy": "SimpleVer",
    "string": "1.2.3.4.5.6.6.8",
    "valid": true,
    "year": "1"
}awesomeversion-24.2.0/tests/snapshots/SimpleVer/1.2.3.4.5.6.7.8.9.json000066400000000000000000000005631456050426100244350ustar00rootroot00000000000000{
    "alpha": false,
    "beta": false,
    "dev": false,
    "major": "1",
    "micro": "3",
    "minor": "2",
    "modifier_type": null,
    "modifier": null,
    "patch": "3",
    "prefix": null,
    "release_candidate": false,
    "sections": 9,
    "simple": true,
    "strategy": "SimpleVer",
    "string": "1.2.3.4.5.6.7.8.9",
    "valid": true,
    "year": "1"
}awesomeversion-24.2.0/tests/snapshots/SimpleVer/1.2.3.4.5.6.7.8.json000066400000000000000000000005611456050426100242640ustar00rootroot00000000000000{
    "alpha": false,
    "beta": false,
    "dev": false,
    "major": "1",
    "micro": "3",
    "minor": "2",
    "modifier_type": null,
    "modifier": null,
    "patch": "3",
    "prefix": null,
    "release_candidate": false,
    "sections": 8,
    "simple": true,
    "strategy": "SimpleVer",
    "string": "1.2.3.4.5.6.7.8",
    "valid": true,
    "year": "1"
}awesomeversion-24.2.0/tests/snapshots/SimpleVer/1.2.3.4.5.json000066400000000000000000000005531456050426100236060ustar00rootroot00000000000000{
    "alpha": false,
    "beta": false,
    "dev": false,
    "major": "1",
    "micro": "3",
    "minor": "2",
    "modifier_type": null,
    "modifier": null,
    "patch": "3",
    "prefix": null,
    "release_candidate": false,
    "sections": 5,
    "simple": true,
    "strategy": "SimpleVer",
    "string": "1.2.3.4.5",
    "valid": true,
    "year": "1"
}awesomeversion-24.2.0/tests/snapshots/SimpleVer/1.2.3.4.json000066400000000000000000000005511456050426100234410ustar00rootroot00000000000000{
    "alpha": false,
    "beta": false,
    "dev": false,
    "major": "1",
    "micro": "3",
    "minor": "2",
    "modifier_type": null,
    "modifier": null,
    "patch": "3",
    "prefix": null,
    "release_candidate": false,
    "sections": 4,
    "simple": true,
    "strategy": "SimpleVer",
    "string": "1.2.3.4",
    "valid": true,
    "year": "1"
}awesomeversion-24.2.0/tests/snapshots/SimpleVer/5.10.json000066400000000000000000000005511456050426100232210ustar00rootroot00000000000000{
    "alpha": false,
    "beta": false,
    "dev": false,
    "major": "5",
    "micro": null,
    "minor": "10",
    "modifier_type": null,
    "modifier": null,
    "patch": null,
    "prefix": null,
    "release_candidate": false,
    "sections": 2,
    "simple": true,
    "strategy": "SimpleVer",
    "string": "5.10",
    "valid": true,
    "year": "5"
}awesomeversion-24.2.0/tests/snapshots/SimpleVer/5.11.json000066400000000000000000000005511456050426100232220ustar00rootroot00000000000000{
    "alpha": false,
    "beta": false,
    "dev": false,
    "major": "5",
    "micro": null,
    "minor": "11",
    "modifier_type": null,
    "modifier": null,
    "patch": null,
    "prefix": null,
    "release_candidate": false,
    "sections": 2,
    "simple": true,
    "strategy": "SimpleVer",
    "string": "5.11",
    "valid": true,
    "year": "5"
}awesomeversion-24.2.0/tests/snapshots/SimpleVer/6.0.json000066400000000000000000000005471456050426100231460ustar00rootroot00000000000000{
    "alpha": false,
    "beta": false,
    "dev": false,
    "major": "6",
    "micro": null,
    "minor": "0",
    "modifier_type": null,
    "modifier": null,
    "patch": null,
    "prefix": null,
    "release_candidate": false,
    "sections": 2,
    "simple": true,
    "strategy": "SimpleVer",
    "string": "6.0",
    "valid": true,
    "year": "6"
}awesomeversion-24.2.0/tests/snapshots/SimpleVer/v1.0.json000066400000000000000000000005461456050426100233260ustar00rootroot00000000000000{
    "alpha": false,
    "beta": false,
    "dev": false,
    "major": "1",
    "micro": null,
    "minor": "0",
    "modifier_type": null,
    "modifier": null,
    "patch": null,
    "prefix": "v",
    "release_candidate": false,
    "sections": 2,
    "simple": true,
    "strategy": "SimpleVer",
    "string": "1.0",
    "valid": true,
    "year": "1"
}awesomeversion-24.2.0/tests/snapshots/SimpleVer/v1.1.json000066400000000000000000000005461456050426100233270ustar00rootroot00000000000000{
    "alpha": false,
    "beta": false,
    "dev": false,
    "major": "1",
    "micro": null,
    "minor": "1",
    "modifier_type": null,
    "modifier": null,
    "patch": null,
    "prefix": "v",
    "release_candidate": false,
    "sections": 2,
    "simple": true,
    "strategy": "SimpleVer",
    "string": "1.1",
    "valid": true,
    "year": "1"
}awesomeversion-24.2.0/tests/snapshots/SimpleVer/v1.2.json000066400000000000000000000005461456050426100233300ustar00rootroot00000000000000{
    "alpha": false,
    "beta": false,
    "dev": false,
    "major": "1",
    "micro": null,
    "minor": "2",
    "modifier_type": null,
    "modifier": null,
    "patch": null,
    "prefix": "v",
    "release_candidate": false,
    "sections": 2,
    "simple": true,
    "strategy": "SimpleVer",
    "string": "1.2",
    "valid": true,
    "year": "1"
}awesomeversion-24.2.0/tests/snapshots/SimpleVer/v2.0.json000066400000000000000000000005461456050426100233270ustar00rootroot00000000000000{
    "alpha": false,
    "beta": false,
    "dev": false,
    "major": "2",
    "micro": null,
    "minor": "0",
    "modifier_type": null,
    "modifier": null,
    "patch": null,
    "prefix": "v",
    "release_candidate": false,
    "sections": 2,
    "simple": true,
    "strategy": "SimpleVer",
    "string": "2.0",
    "valid": true,
    "year": "2"
}awesomeversion-24.2.0/tests/snapshots/SimpleVer/v2.1.json000066400000000000000000000005461456050426100233300ustar00rootroot00000000000000{
    "alpha": false,
    "beta": false,
    "dev": false,
    "major": "2",
    "micro": null,
    "minor": "1",
    "modifier_type": null,
    "modifier": null,
    "patch": null,
    "prefix": "v",
    "release_candidate": false,
    "sections": 2,
    "simple": true,
    "strategy": "SimpleVer",
    "string": "2.1",
    "valid": true,
    "year": "2"
}awesomeversion-24.2.0/tests/snapshots/SimpleVer/v2.2.json000066400000000000000000000005461456050426100233310ustar00rootroot00000000000000{
    "alpha": false,
    "beta": false,
    "dev": false,
    "major": "2",
    "micro": null,
    "minor": "2",
    "modifier_type": null,
    "modifier": null,
    "patch": null,
    "prefix": "v",
    "release_candidate": false,
    "sections": 2,
    "simple": true,
    "strategy": "SimpleVer",
    "string": "2.2",
    "valid": true,
    "year": "2"
}awesomeversion-24.2.0/tests/snapshots/SpecialContainer/000077500000000000000000000000001456050426100232575ustar00rootroot00000000000000awesomeversion-24.2.0/tests/snapshots/SpecialContainer/beta.json000066400000000000000000000005621456050426100250700ustar00rootroot00000000000000{
    "alpha": false,
    "beta": true,
    "dev": false,
    "major": null,
    "micro": null,
    "minor": null,
    "modifier_type": null,
    "modifier": null,
    "patch": null,
    "prefix": null,
    "release_candidate": false,
    "sections": 1,
    "simple": false,
    "strategy": "SpecialContainer",
    "string": "beta",
    "valid": true,
    "year": null
}awesomeversion-24.2.0/tests/snapshots/SpecialContainer/dev.json000066400000000000000000000005611456050426100247320ustar00rootroot00000000000000{
    "alpha": false,
    "beta": false,
    "dev": true,
    "major": null,
    "micro": null,
    "minor": null,
    "modifier_type": null,
    "modifier": null,
    "patch": null,
    "prefix": null,
    "release_candidate": false,
    "sections": 1,
    "simple": false,
    "strategy": "SpecialContainer",
    "string": "dev",
    "valid": true,
    "year": null
}awesomeversion-24.2.0/tests/snapshots/SpecialContainer/latest.json000066400000000000000000000005651456050426100254540ustar00rootroot00000000000000{
    "alpha": false,
    "beta": false,
    "dev": false,
    "major": null,
    "micro": null,
    "minor": null,
    "modifier_type": null,
    "modifier": null,
    "patch": null,
    "prefix": null,
    "release_candidate": false,
    "sections": 1,
    "simple": false,
    "strategy": "SpecialContainer",
    "string": "latest",
    "valid": true,
    "year": null
}awesomeversion-24.2.0/tests/snapshots/SpecialContainer/stable.json000066400000000000000000000005651456050426100254320ustar00rootroot00000000000000{
    "alpha": false,
    "beta": false,
    "dev": false,
    "major": null,
    "micro": null,
    "minor": null,
    "modifier_type": null,
    "modifier": null,
    "patch": null,
    "prefix": null,
    "release_candidate": false,
    "sections": 1,
    "simple": false,
    "strategy": "SpecialContainer",
    "string": "stable",
    "valid": true,
    "year": null
}awesomeversion-24.2.0/tests/snapshots/unknown/000077500000000000000000000000001456050426100215335ustar00rootroot00000000000000awesomeversion-24.2.0/tests/snapshots/unknown/.json000066400000000000000000000005471456050426100225130ustar00rootroot00000000000000{
    "alpha": false,
    "beta": false,
    "dev": false,
    "major": null,
    "micro": null,
    "minor": null,
    "modifier_type": null,
    "modifier": null,
    "patch": null,
    "prefix": null,
    "release_candidate": false,
    "sections": 0,
    "simple": false,
    "strategy": "unknown",
    "string": "",
    "valid": false,
    "year": null
}awesomeversion-24.2.0/tests/snapshots/unknown/00AABB00.json000066400000000000000000000005571456050426100234220ustar00rootroot00000000000000{
    "alpha": false,
    "beta": false,
    "dev": false,
    "major": null,
    "micro": null,
    "minor": null,
    "modifier_type": null,
    "modifier": null,
    "patch": null,
    "prefix": null,
    "release_candidate": false,
    "sections": 1,
    "simple": false,
    "strategy": "unknown",
    "string": "00AABB00",
    "valid": false,
    "year": null
}awesomeversion-24.2.0/tests/snapshots/unknown/0X01002604.json000066400000000000000000000005611456050426100235340ustar00rootroot00000000000000{
    "alpha": false,
    "beta": false,
    "dev": false,
    "major": null,
    "micro": null,
    "minor": null,
    "modifier_type": null,
    "modifier": null,
    "patch": null,
    "prefix": null,
    "release_candidate": false,
    "sections": 1,
    "simple": false,
    "strategy": "unknown",
    "string": "0X01002604",
    "valid": false,
    "year": null
}awesomeversion-24.2.0/tests/snapshots/unknown/0x0g.json000066400000000000000000000005531456050426100232070ustar00rootroot00000000000000{
    "alpha": false,
    "beta": false,
    "dev": false,
    "major": null,
    "micro": null,
    "minor": null,
    "modifier_type": null,
    "modifier": null,
    "patch": null,
    "prefix": null,
    "release_candidate": false,
    "sections": 1,
    "simple": false,
    "strategy": "unknown",
    "string": "0x0g",
    "valid": false,
    "year": null
}awesomeversion-24.2.0/tests/snapshots/unknown/1.0.0beta0.json000066400000000000000000000005641456050426100240030ustar00rootroot00000000000000{
    "alpha": true,
    "beta": true,
    "dev": false,
    "major": null,
    "micro": null,
    "minor": null,
    "modifier_type": "beta",
    "modifier": "beta0",
    "patch": null,
    "prefix": null,
    "release_candidate": false,
    "sections": 3,
    "simple": false,
    "strategy": "unknown",
    "string": "1.0.0beta0",
    "valid": false,
    "year": null
}awesomeversion-24.2.0/tests/snapshots/unknown/1.0.a0.json000066400000000000000000000005531456050426100232260ustar00rootroot00000000000000{
    "alpha": true,
    "beta": false,
    "dev": false,
    "major": null,
    "micro": null,
    "minor": null,
    "modifier_type": "a",
    "modifier": "a0",
    "patch": null,
    "prefix": null,
    "release_candidate": false,
    "sections": 2,
    "simple": false,
    "strategy": "unknown",
    "string": "1.0.a0",
    "valid": false,
    "year": null
}awesomeversion-24.2.0/tests/snapshots/unknown/1.0.alpha1.json000066400000000000000000000005671456050426100241010ustar00rootroot00000000000000{
    "alpha": true,
    "beta": false,
    "dev": false,
    "major": null,
    "micro": null,
    "minor": null,
    "modifier_type": "alpha",
    "modifier": "alpha1",
    "patch": null,
    "prefix": null,
    "release_candidate": false,
    "sections": 2,
    "simple": false,
    "strategy": "unknown",
    "string": "1.0.alpha1",
    "valid": false,
    "year": null
}awesomeversion-24.2.0/tests/snapshots/unknown/1.0.b0.json000066400000000000000000000005531456050426100232270ustar00rootroot00000000000000{
    "alpha": false,
    "beta": true,
    "dev": false,
    "major": null,
    "micro": null,
    "minor": null,
    "modifier_type": "b",
    "modifier": "b0",
    "patch": null,
    "prefix": null,
    "release_candidate": false,
    "sections": 2,
    "simple": false,
    "strategy": "unknown",
    "string": "1.0.b0",
    "valid": false,
    "year": null
}awesomeversion-24.2.0/tests/snapshots/unknown/1.0.b1.json000066400000000000000000000005531456050426100232300ustar00rootroot00000000000000{
    "alpha": false,
    "beta": true,
    "dev": false,
    "major": null,
    "micro": null,
    "minor": null,
    "modifier_type": "b",
    "modifier": "b1",
    "patch": null,
    "prefix": null,
    "release_candidate": false,
    "sections": 2,
    "simple": false,
    "strategy": "unknown",
    "string": "1.0.b1",
    "valid": false,
    "year": null
}awesomeversion-24.2.0/tests/snapshots/unknown/1.0.b2.json000066400000000000000000000005531456050426100232310ustar00rootroot00000000000000{
    "alpha": false,
    "beta": true,
    "dev": false,
    "major": null,
    "micro": null,
    "minor": null,
    "modifier_type": "b",
    "modifier": "b2",
    "patch": null,
    "prefix": null,
    "release_candidate": false,
    "sections": 2,
    "simple": false,
    "strategy": "unknown",
    "string": "1.0.b2",
    "valid": false,
    "year": null
}awesomeversion-24.2.0/tests/snapshots/unknown/1.0.d1.json000066400000000000000000000005531456050426100232320ustar00rootroot00000000000000{
    "alpha": false,
    "beta": false,
    "dev": true,
    "major": null,
    "micro": null,
    "minor": null,
    "modifier_type": "d",
    "modifier": "d1",
    "patch": null,
    "prefix": null,
    "release_candidate": false,
    "sections": 2,
    "simple": false,
    "strategy": "unknown",
    "string": "1.0.d1",
    "valid": false,
    "year": null
}awesomeversion-24.2.0/tests/snapshots/unknown/1.0.invalid4.json000066400000000000000000000005741456050426100244430ustar00rootroot00000000000000{
    "alpha": true,
    "beta": false,
    "dev": true,
    "major": null,
    "micro": null,
    "minor": null,
    "modifier_type": "invalid",
    "modifier": "invalid4",
    "patch": null,
    "prefix": null,
    "release_candidate": false,
    "sections": 2,
    "simple": false,
    "strategy": "unknown",
    "string": "1.0.invalid4",
    "valid": false,
    "year": null
}awesomeversion-24.2.0/tests/snapshots/unknown/.json000066400000000000000000000005641456050426100246410ustar00rootroot00000000000000{
    "alpha": false,
    "beta": false,
    "dev": false,
    "major": null,
    "micro": null,
    "minor": null,
    "modifier_type": null,
    "modifier": null,
    "patch": null,
    "prefix": null,
    "release_candidate": false,
    "sections": 1,
    "simple": false,
    "strategy": "unknown",
    "string": "",
    "valid": false,
    "year": null
}awesomeversion-24.2.0/tests/snapshots/unknown/.json000066400000000000000000000006061456050426100303560ustar00rootroot00000000000000{
    "alpha": false,
    "beta": false,
    "dev": false,
    "major": null,
    "micro": null,
    "minor": null,
    "modifier_type": null,
    "modifier": null,
    "patch": null,
    "prefix": null,
    "release_candidate": false,
    "sections": 1,
    "simple": false,
    "strategy": "unknown",
    "string": "",
    "valid": false,
    "year": null
}awesomeversion-24.2.0/tests/snapshots/unknown/False.json000066400000000000000000000005541456050426100234640ustar00rootroot00000000000000{
    "alpha": false,
    "beta": false,
    "dev": false,
    "major": null,
    "micro": null,
    "minor": null,
    "modifier_type": null,
    "modifier": null,
    "patch": null,
    "prefix": null,
    "release_candidate": false,
    "sections": 1,
    "simple": false,
    "strategy": "unknown",
    "string": "False",
    "valid": false,
    "year": null
}awesomeversion-24.2.0/tests/snapshots/unknown/None.json000066400000000000000000000005531456050426100233300ustar00rootroot00000000000000{
    "alpha": false,
    "beta": false,
    "dev": false,
    "major": null,
    "micro": null,
    "minor": null,
    "modifier_type": null,
    "modifier": null,
    "patch": null,
    "prefix": null,
    "release_candidate": false,
    "sections": 1,
    "simple": false,
    "strategy": "unknown",
    "string": "None",
    "valid": false,
    "year": null
}awesomeversion-24.2.0/tests/snapshots/unknown/True.json000066400000000000000000000005531456050426100233500ustar00rootroot00000000000000{
    "alpha": false,
    "beta": false,
    "dev": false,
    "major": null,
    "micro": null,
    "minor": null,
    "modifier_type": null,
    "modifier": null,
    "patch": null,
    "prefix": null,
    "release_candidate": false,
    "sections": 1,
    "simple": false,
    "strategy": "unknown",
    "string": "True",
    "valid": false,
    "year": null
}awesomeversion-24.2.0/tests/snapshots/unknown/a.b.c.json000066400000000000000000000005521456050426100233110ustar00rootroot00000000000000{
    "alpha": false,
    "beta": false,
    "dev": false,
    "major": null,
    "micro": null,
    "minor": null,
    "modifier_type": "c",
    "modifier": "c",
    "patch": null,
    "prefix": null,
    "release_candidate": false,
    "sections": 2,
    "simple": false,
    "strategy": "unknown",
    "string": "a.b.c",
    "valid": false,
    "year": null
}awesomeversion-24.2.0/tests/snapshots/unknown/unknown.json000066400000000000000000000005701456050426100241270ustar00rootroot00000000000000{
    "alpha": false,
    "beta": false,
    "dev": false,
    "major": null,
    "micro": null,
    "minor": null,
    "modifier_type": "unknown",
    "modifier": "unknown",
    "patch": null,
    "prefix": null,
    "release_candidate": false,
    "sections": 0,
    "simple": false,
    "strategy": "unknown",
    "string": "unknown",
    "valid": false,
    "year": null
}awesomeversion-24.2.0/tests/test_awesomeversion.py000066400000000000000000000211431456050426100224720ustar00rootroot00000000000000"""Test awesomeversion."""

from __future__ import annotations

import json
import warnings

import pytest

from awesomeversion import (
    AwesomeVersion,
    AwesomeVersionStrategy,
    AwesomeVersionStrategyException,
)
from awesomeversion.exceptions import (
    AwesomeVersionCompareException,
    AwesomeVersionException,
)
from awesomeversion.strategy import COMPARABLE_STRATEGIES
from awesomeversion.typing import VersionType


def test_awesomeversion() -> None:
    """Test awesomeversion."""
    version = AwesomeVersion("2020.12.1")
    assert not version.beta
    assert version.valid

    version = AwesomeVersion("2020.12.1a0")
    assert version.alpha
    assert version.valid

    version = AwesomeVersion("2020.12.1b0")
    assert version.beta
    assert version.valid

    version = AwesomeVersion("2020.12.1dev0")
    assert version.dev
    assert version.valid

    version = AwesomeVersion("2020.12.1d0")
    assert version.dev
    assert version.valid

    version = AwesomeVersion("2020.12.1rc0")
    assert version.release_candidate
    assert version.prefix is None
    assert version.valid

    version = AwesomeVersion("v2020.12.1rc0")
    assert version.prefix == "v"
    assert version.valid

    version2 = AwesomeVersion(version)
    assert version == version2
    assert str(version) == str(version2)

    assert str(version) == "v2020.12.1rc0"
    assert version.string == "2020.12.1rc0"
    assert repr(version) == ""

    assert AwesomeVersion("1.0.0-beta.2").modifier == "beta.2"
    assert AwesomeVersion("2020.2.0b1").modifier_type == "b"

    with AwesomeVersion("20.12.0") as current:
        with AwesomeVersion(
            "20.12.1", ensure_strategy=AwesomeVersionStrategy.SEMVER
        ) as upstream:
            assert upstream > current


def test_major() -> None:
    """Test major."""
    assert AwesomeVersion("1.0.0.0").major == 1
    assert AwesomeVersion("1.0.0").major == 1
    assert AwesomeVersion("1.0").major == 1
    assert AwesomeVersion("1").major == 1


def test_minor() -> None:
    """Test minor."""
    assert AwesomeVersion("1.1.0.0").minor == 1
    assert AwesomeVersion("1.1.0").minor == 1
    assert AwesomeVersion("1.1").minor == 1
    assert AwesomeVersion("1").minor is None


def test_patch() -> None:
    """Test patch."""
    assert AwesomeVersion("1.1.1.1").patch == 1
    assert AwesomeVersion("1.1.1").patch == 1
    assert AwesomeVersion("1.1").patch is None
    assert AwesomeVersion("1").patch is None


def test_serialization() -> None:
    """Test to and from JSON serialization."""
    version = AwesomeVersion("20.12.1")
    dumps = json.dumps({"version": version})
    assert dumps == '{"version": "20.12.1"}'

    assert json.loads(dumps)["version"] == version.string


test_data = [
    ("2020.12.1b0"),
    ("2020.12.1"),
    ("2021.2.0.dev20210118"),
]


@pytest.mark.parametrize("version", test_data)
def test_nesting(version: VersionType) -> None:
    """Test nesting AwesomeVersion objects."""
    obj = AwesomeVersion(version)
    assert obj.string == version
    assert str(obj) == version
    assert AwesomeVersion(obj) == AwesomeVersion(version)
    assert AwesomeVersion(obj).string == AwesomeVersion(version)
    assert str(AwesomeVersion(obj)) == AwesomeVersion(version)
    assert AwesomeVersion(obj) == version
    assert AwesomeVersion(obj).string == version
    assert str(AwesomeVersion(obj)) == version

    assert (
        AwesomeVersion(
            AwesomeVersion(AwesomeVersion(AwesomeVersion(AwesomeVersion(obj))))
        )
        == version
    )

    assert (
        AwesomeVersion(
            AwesomeVersion(AwesomeVersion(AwesomeVersion(AwesomeVersion(obj))))
        ).string
        == version
    )

    assert str(
        (
            AwesomeVersion(
                AwesomeVersion(AwesomeVersion(AwesomeVersion(AwesomeVersion(obj))))
            )
        )
        == version
    )


def test_ensure_strategy() -> None:
    """test ensure_strategy."""
    obj = AwesomeVersion("1.0.0", ensure_strategy=COMPARABLE_STRATEGIES)
    assert obj.strategy == AwesomeVersionStrategy.SEMVER

    obj = AwesomeVersion(
        "1.0.0",
        [AwesomeVersionStrategy.SEMVER, AwesomeVersionStrategy.SPECIALCONTAINER],
    )
    assert obj.strategy in [
        AwesomeVersionStrategy.SEMVER,
        AwesomeVersionStrategy.SPECIALCONTAINER,
    ]

    with pytest.raises(AwesomeVersionStrategyException):
        AwesomeVersion("1", AwesomeVersionStrategy.SEMVER)

    with pytest.raises(AwesomeVersionStrategyException):
        AwesomeVersion("1", AwesomeVersionStrategy.UNKNOWN)

    with pytest.raises(AwesomeVersionStrategyException):
        AwesomeVersion(
            "1",
            [AwesomeVersionStrategy.SEMVER, AwesomeVersionStrategy.SPECIALCONTAINER],
        )


@pytest.mark.parametrize(
    "version,strategy,result",
    [
        ("14.0 (Debian 14.0-1.pgdg110+1)", AwesomeVersionStrategy.SIMPLEVER, "14.0"),
        (
            "PostgreSQL 11.13 (Debian 11.13-0+deb10u1) on x86_64-pc-linux-gnu",
            AwesomeVersionStrategy.SIMPLEVER,
            "11.13",
        ),
        (
            "5.7.26-0ubuntu0.18.04.1",
            AwesomeVersionStrategy.SIMPLEVER,
            "5.7.26",
        ),
        (
            "5.7.26-0ubuntu0.18.04.1",
            AwesomeVersionStrategy.CALVER,
            "18.04.1",
        ),
        (
            "0.4.7-MariaDB",
            AwesomeVersionStrategy.SIMPLEVER,
            "0.4.7",
        ),
        (
            "10.4.7-MariaDB-log-ubuntu0.18.04.1-whatever",
            AwesomeVersionStrategy.SIMPLEVER,
            "10.4.7",
        ),
        (
            "Linux 2b4de6616b33 5.11.0-38-generic #42~20.04.1-Ubuntu",
            AwesomeVersionStrategy.SEMVER,
            "5.11.0-38",
        ),
    ],
)
def test_find_first_match(
    version: VersionType,
    strategy: AwesomeVersionStrategy,
    result: str,
) -> None:
    """Test find_first_match"""
    obj = AwesomeVersion(
        version=version,
        ensure_strategy=strategy,
        find_first_match=True,
    )
    assert obj.string == result
    assert AwesomeVersion(version, strategy, True).string == obj.string


def test_find_first_match_exception() -> None:
    """Test"""
    with warnings.catch_warnings(record=True) as warning_list:
        assert AwesomeVersion("1", find_first_match=True)
        assert "Can not use find_first_match without ensure_strategy" in str(
            warning_list[-1].message
        )


def test_diff() -> None:
    """Test .diff"""
    version = AwesomeVersion("2020.12.1")

    assert version.diff("2021.12.1").major
    assert not version.diff("2021.12.1").minor
    assert not version.diff("2021.12.1").patch
    assert not version.diff("2021.12.1").modifier
    assert not version.diff("2021.12.1").strategy

    assert version.diff("2021.11.1").minor
    assert version.diff("2021.12.2").patch
    assert version.diff("2021.12.1dev2").modifier
    assert version.diff("2.11.1").strategy

    diff = version - "2021.12.1"
    assert diff.major
    assert repr(diff).startswith("AwesomeVersionDiff(")

    with pytest.raises(AwesomeVersionException):
        version.diff(None)


@pytest.mark.parametrize(
    "lowest,version,highest,result",
    [
        ("14.0", "14.0", "14.0", True),
        ("14.0", "12.0", "15.0", False),
        ("14", "12.1", "15", False),
        ("14", "14.3", "15", True),
        ("1", 13, "15", True),
        ("1", AwesomeVersion(2), "15", True),
    ],
)
def test_in_range(
    lowest: VersionType,
    version: VersionType,
    highest: VersionType,
    result: bool,
) -> None:
    """Test AwesomeVersion.in_range"""
    assert AwesomeVersion(version).in_range(lowest, highest) == result


@pytest.mark.parametrize(
    "lowest,version,highest,match",
    [
        (None, "14.0", "14.0", "Lowest version is not valid"),
        ("14.0", "14.0", None, "Highest version is not valid"),
    ],
)
def test_in_range_exception(
    lowest: VersionType | None,
    version: VersionType,
    highest: VersionType | None,
    match: str,
) -> None:
    """Test AwesomeVersion.in_range exceptions"""
    with pytest.raises(AwesomeVersionCompareException, match=match):
        AwesomeVersion(version).in_range(lowest, highest)


def test_hash() -> None:
    """Test hash."""
    version = AwesomeVersion("2020.12.1")
    assert hash(version) == hash("2020.12.1") == str.__hash__("2020.12.1")

    version_set = set(
        [
            version,
            AwesomeVersion("2020.12.1"),
            AwesomeVersion("2020.12.2"),
            version,
        ]
    )
    assert len(version_set) == 2
    assert version in version_set
    assert "2020.12.1" in version_set
    assert AwesomeVersion("2021.12.1") not in version_set
awesomeversion-24.2.0/tests/test_compare.py000066400000000000000000000110101456050426100210420ustar00rootroot00000000000000"""Test compare."""

import pytest

from awesomeversion import AwesomeVersion
from awesomeversion.exceptions import AwesomeVersionCompareException
from awesomeversion.typing import VersionType


@pytest.mark.parametrize(
    "version_a,version_b",
    [
        ("1.0.0-beta.10", "1.0.0-beta.9"),
        ("1.0.0-alpha10", "1.0.0-alpha9"),
        ("2021.2.0", "2021.2.0.dev20210118"),
        ("2021.2.0b0", "2021.2.0.dev20210118"),
        ("2021.2.0", "2021.2.0b0"),
        ("2020.12.1", "2020.12.0"),
        ("2", "1"),
        ("2", 1),
        (2, "1"),
        (2, 1),
        ("5.11", "5.10"),
        ("1.1", "1.0"),
        ("2020", "2019"),
        ("1.2.3.4", "1.2.3"),
        ("2020.1", "2020"),
        ("2020.2.0", "2020.1.1."),
        ("1.2.3.4.5.6.7.8.9", "1"),
        ("2020.12.0", "2020.12.dev1602"),
        ("2020.12.dev1603", "2020.12.dev1602"),
        ("2021.1.0", "2021.1.0b0"),
        ("2021.1.0", "2021.1.0b0"),
        ("2021.1.0", "2021.1.0b1"),
        ("2021.1.0", "2021.1.0dev20210101"),
        ("2021.1.0b0", "2021.1.0a0"),
        ("2021.1.0b1", "2021.1.0b0"),
        ("2021.1.0b1", "2021.1.0dev0"),
        ("2021.1.0b1", "2021.1.0.dev0"),
        ("2021.1.0", "2021.1.0.dev0"),
        ("2021.2.0", "2021.1.0b0"),
        ("2021.2.0b0", "2021.1.0"),
        ("2021.2.0b10", "2021.1.0b2"),
        ("beta", "stable"),
        ("1.2.3-2", "1.2.3-1"),
        ("dev", "latest"),
        ("latest", "2020.21.1"),
        ("latest", "beta"),
        ("1.0.0-beta0", "1.0.0-alpha1"),
        ("1.0.0-beta", "1.0.0-beta.1"),
        ("1.0.0-beta1", "1.0.0-beta"),
        ("1.0.0-beta.2", "1.0.0-beta.1"),
        ("1.0.0-rc0", "1.0.0-alpha1"),
        ("1.0.0-beta", "1.0.0-alpha"),
        ("1.0.0", "1.0.0-beta1"),
        ("1.0.0", "1.0.0-beta"),
        ("6.0.rc1", "6.0.dev20210429"),
        ("6.0", "6.0.rc1"),
        ("1.2.3.4.5.6.7.8", "1.2.3.4.5.6.6.8"),
        ("1.0.0b1", "1.0.0b0"),
        ("1.0.0b10", "1.0.0b9"),
        ("1.0.0", "1.0.0b0"),
        (1.0, "1.0.0rc0"),
        ("0x2df35", "1"),
        ("0x01002604", "0x01002100"),
        ("9", "0x0"),
    ],
)
def test_compare(version_a: VersionType, version_b: VersionType) -> None:
    """Test compare."""
    ver_a = AwesomeVersion(version_a)
    ver_b = AwesomeVersion(version_b)

    assert ver_a > ver_b
    assert ver_a >= ver_b
    assert ver_a != ver_b
    assert ver_a > version_b
    assert ver_a >= version_b
    assert ver_a != version_b
    assert version_a > ver_b
    assert version_a >= ver_b
    assert version_a != ver_b
    assert ver_b < ver_a
    assert ver_b <= ver_a
    assert ver_b < version_a
    assert ver_b <= version_a

    if str(version_a).endswith("."):
        version_a = str(version_a)[:-1]
    if str(version_b).endswith("."):
        version_b = str(version_b)[:-1]

    assert ver_a.string == str(version_a)
    assert ver_b.string == str(version_b)


def test_invalid_compare() -> None:
    """Test invalid compare."""
    invalid = None
    with pytest.raises(
        AwesomeVersionCompareException, match="Not a valid AwesomeVersion object"
    ):
        assert AwesomeVersion("2020.12.1") > invalid

    with pytest.raises(
        AwesomeVersionCompareException, match="Not a valid AwesomeVersion object"
    ):
        assert AwesomeVersion("2020.12.1") < invalid

    with pytest.raises(
        AwesomeVersionCompareException, match="Not a valid AwesomeVersion object"
    ):
        assert AwesomeVersion("2020.12.1") == invalid

    with pytest.raises(
        AwesomeVersionCompareException,
        match="Can't compare  and ",
    ):
        assert AwesomeVersion("2020.12.1") > AwesomeVersion("string")

    with pytest.raises(
        AwesomeVersionCompareException,
        match="Can't compare  and ",
    ):
        assert AwesomeVersion("2020.12.1") < AwesomeVersion("")

    with pytest.raises(
        AwesomeVersionCompareException,
        match="Can't compare  and ",
    ):
        assert AwesomeVersion("2020.12.1") < AwesomeVersion(None)


@pytest.mark.parametrize(
    "version",
    [1, "1", 1.0, "1.0", 5.10, "5.10"],
)
def test_falsy_compare(version: VersionType) -> None:
    """Test compare."""
    ver_a = AwesomeVersion(version)
    ver_b = AwesomeVersion(version)

    assert ver_a == ver_b
    assert ver_a <= ver_b
    assert ver_a >= ver_b

    assert not version != ver_b
    assert not version > ver_b
    assert not version < ver_b

    assert not ver_a != version
    assert not ver_a > version
    assert not ver_a < version
awesomeversion-24.2.0/tests/test_equals.py000066400000000000000000000012131456050426100207120ustar00rootroot00000000000000"""Test equals."""

import pytest

from awesomeversion import AwesomeVersion
from awesomeversion.typing import VersionType


@pytest.mark.parametrize(
    "version",
    [
        ("1"),
        ("2020.12.1"),
        ("2020"),
        ("2021.2.0b0"),
        ("2021.2.0.dev20210118"),
    ],
)
def test_equals(version: VersionType) -> None:
    """Test equals."""
    version_object = AwesomeVersion(version)
    assert version_object == version
    assert str(version_object) == version
    assert version_object.string == version
    assert version_object == AwesomeVersion(f"v{version}")
    assert version_object == AwesomeVersion(f"V{version}")
awesomeversion-24.2.0/tests/test_handlers.py000066400000000000000000000046561456050426100212360ustar00rootroot00000000000000"""Test compare handlers."""

from __future__ import annotations

import pytest

from awesomeversion import AwesomeVersion
from awesomeversion.comparehandlers.modifier import compare_handler_semver_modifier
from awesomeversion.comparehandlers.sections import compare_modifier_section
from awesomeversion.typing import VersionType


@pytest.mark.parametrize(
    "ver_a,ver_b,result",
    (
        (False, True, None),
        ("2", "1", True),
        ("1", "2", False),
        ("1", "1", False),
        ("1.0", "1.0", False),
        ("5.10", "5.10", False),
        ("1.2.3.4.5b0", "1.2b0", True),
        ("1.0b1", "1.0b0", True),
        ("1.0", "1.0b0", True),
        ("1.0b0", "1.0b1", False),
        ("1.0b0", "1.0", False),
        ("1.dev1", "1.dev0", True),
        ("1.dev0", "1.dev1", False),
        ("latest", "stable", True),
        ("1.2.3-dev.1", "1.2.3-alpha.1", False),
        ("latest", "1", True),
        ("1.2.3.4.5.6.7.8.9", "1.2.3.4.5.6.7.8.9", False),
        ("1.0.0", "stable", False),
        ("0x01002604", "0x01002604", False),
        ("0x01002604", "0x01002100", True),
        ("0x01002100", "0x01002604", False),
    ),
)
def test_compare_handlers(
    ver_a: VersionType,
    ver_b: VersionType,
    result: bool | None,
) -> None:
    """Test handlers."""
    version_a = AwesomeVersion(ver_a)
    version_b = AwesomeVersion(ver_b)

    if (
        version_a.strategy_description is not None
        or version_b.strategy_description is not None
    ):
        assert (AwesomeVersion(ver_a) > ver_b) == result


def test_semver_modifier() -> None:
    """Test semver modifier."""
    result = compare_handler_semver_modifier(
        AwesomeVersion("1.0"), AwesomeVersion("1.0")
    )
    assert result is None


@pytest.mark.parametrize(
    "ver_a,ver_b,result",
    (
        ("1.0.b2", "1.0.invalid4", False),
        ("2", "1", None),
        ("1.0.rc2", "1.0.dev1", True),
        ("1.0.rc2", "1.0.d1", True),
        ("1.0.b0", "1.0.dev1", True),
        ("1.0.0beta0", "1.0.dev1", True),
        ("1.0.b0", "1.0.b1", False),
        ("1.0.0beta0", "1.0.dev1", True),
        ("1.0.a0", "1.0.dev1", True),
        ("1.0.dev0", "1.0.alpha1", False),
    ),
)
def test_compare_modifier_section(
    ver_a: VersionType,
    ver_b: VersionType,
    result: bool | None,
) -> None:
    """Test compare_modifier_section."""
    assert (
        compare_modifier_section(AwesomeVersion(ver_a), AwesomeVersion(ver_b)) == result
    )
awesomeversion-24.2.0/tests/test_snapshots.py000066400000000000000000000024711456050426100214510ustar00rootroot00000000000000"""Testing with snapshots."""

import json

import pytest
from pytest_snapshot.plugin import Snapshot  # type: ignore

from awesomeversion import AwesomeVersion
from awesomeversion.typing import VersionType

from .test_versions import TEST_VERSIONS


@pytest.mark.parametrize("version", TEST_VERSIONS)
def test_awesomeversion_output_with_snapshot(
    version: VersionType,
    snapshot: Snapshot,
) -> None:
    """Test AwesomeVersion output with snapshot."""
    version_obj = AwesomeVersion(version)

    snapshot.snapshot_dir = f"tests/snapshots/{version_obj.strategy.value}"
    snapshot.assert_match(
        json.dumps(
            {
                key: getattr(version_obj, key)
                for key in [
                    "alpha",
                    "beta",
                    "dev",
                    "major",
                    "micro",
                    "minor",
                    "modifier_type",
                    "modifier",
                    "patch",
                    "prefix",
                    "release_candidate",
                    "sections",
                    "simple",
                    "strategy",
                    "string",
                    "valid",
                    "year",
                ]
            },
            indent=4,
        ),
        f"{version}.json",
    )
awesomeversion-24.2.0/tests/test_strategy.py000066400000000000000000000054471456050426100212770ustar00rootroot00000000000000"""Test match."""

import pytest

from awesomeversion import AwesomeVersion
from awesomeversion.strategy import AwesomeVersionStrategy
from awesomeversion.typing import VersionType


@pytest.mark.parametrize(
    "version,strategy",
    [
        *[
            (v, AwesomeVersionStrategy.BUILDVER)
            for v in (
                "1",
                "123",
                "0",
            )
        ],
        *[
            (v, AwesomeVersionStrategy.CALVER)
            for v in (
                "20.1.0",
                "20.1",
                "2021.1.0.0",
            )
        ],
        *[
            (v, AwesomeVersionStrategy.PEP440)
            for v in (
                "1.0a1",
                "1.0.dev1",
                "1.0b2.post345.dev456",
                "1.dev0",
                "1.0.dev456",
                "1.0a1",
                "1.0a2.dev456",
                "1.0a12.dev456",
                "1.0a12",
                "1.0b1.dev456",
                "1.0b2",
                "1.0b2.post345.dev456",
                "1.0b2.post345",
                "1.0rc1.dev456",
                "1.0rc1",
                "1.0.post456.dev34",
                "1.0.post456",
                "1.1.dev1",
            )
        ],
        *[
            (v, AwesomeVersionStrategy.SEMVER)
            for v in (
                "0.118.0",
                "1.0.0-alpha",
                "1.0.0-alpha+1.2",
                "1.0.0",
                "1.2.3",
                "1.8.2-beta.1.10",
                "1.8.2-beta.1.13",
                "2.1.3",
                "2.4.6-8",
                "1.8.2-beta.1.10+somebuild",
            )
        ],
        *[
            (v, AwesomeVersionStrategy.SIMPLEVER)
            for v in (
                "1.0",
                "0.1",
                "1.2.3.4.5",
            )
        ],
        *[
            (v, AwesomeVersionStrategy.SPECIALCONTAINER)
            for v in (
                "beta",
                "dev",
                "latest",
                "stable",
            )
        ],
        *[
            (v, AwesomeVersionStrategy.UNKNOWN)
            for v in (
                "",
                "unknown",
                None,
                False,
                True,
                str,
                AwesomeVersionStrategy,
            )
        ],
    ],
)
def test_strategy_match(version: VersionType, strategy: AwesomeVersionStrategy) -> None:
    """Test that the version matches the expected strategy."""
    assert AwesomeVersion(version).strategy == strategy

    if strategy != AwesomeVersionStrategy.UNKNOWN:
        awesome_version = AwesomeVersion(
            version,
            ensure_strategy=strategy,
            find_first_match=True,
        )
        assert awesome_version.valid
        assert awesome_version.strategy == strategy
awesomeversion-24.2.0/tests/test_version_scheme.py000066400000000000000000000043041456050426100224350ustar00rootroot00000000000000"""Test test_version_scheme."""

from __future__ import annotations

import pytest

from awesomeversion import AwesomeVersion
from awesomeversion.strategy import AwesomeVersionStrategy
from awesomeversion.typing import VersionType


@pytest.mark.parametrize(
    "version,strategy,dev,beta,modifier_type",
    [
        ("0.118.0", AwesomeVersionStrategy.SEMVER, False, False, None),
        ("1.0.0b1", AwesomeVersionStrategy.PEP440, False, True, "b"),
        ("1.0.0-beta.1", AwesomeVersionStrategy.SEMVER, False, True, "beta"),
        ("v1.0.0-beta.1", AwesomeVersionStrategy.SEMVER, False, True, "beta"),
        ("2021.2.0.dev1", AwesomeVersionStrategy.CALVER, True, False, "dev"),
        ("stable", AwesomeVersionStrategy.SPECIALCONTAINER, False, False, None),
    ],
)
def test_version_scheme(
    version: VersionType,
    strategy: AwesomeVersionStrategy,
    dev: bool,
    beta: bool,
    modifier_type: str | None,
) -> None:
    """Test that the version matches the expected scheme."""
    version_object = AwesomeVersion(version)
    assert str(version_object) == version
    assert version_object.strategy == strategy
    assert version_object.dev == dev
    assert version_object.beta == beta
    assert version_object.modifier_type == modifier_type


def test_semver_sections() -> None:
    """Test semver sections."""
    ver_a = AwesomeVersion("1.0.0-beta.1")
    ver_b = AwesomeVersion("2.0.0")
    assert ver_a.strategy == AwesomeVersionStrategy.SEMVER
    assert ver_b.strategy == AwesomeVersionStrategy.SEMVER

    assert ver_a.major == "1"
    assert ver_a.minor == "0"
    assert ver_a.patch == "0"

    assert ver_a.major < ver_b.major


def test_named_sections() -> None:
    """Test named sections."""
    version = AwesomeVersion("2020.1.1")
    assert version.major == version.year == "2020"
    assert version.minor == "1"
    assert version.patch == "1"
    assert version.micro == version.patch == "1"


def test_named_sections_invalid() -> None:
    """Test invalid named sections."""
    version = AwesomeVersion("latest")
    assert version.major is None
    assert version.minor is None
    assert version.patch is None

    assert version.year == version.major
    assert version.micro == version.patch
awesomeversion-24.2.0/tests/test_versions.py000066400000000000000000000062741456050426100213040ustar00rootroot00000000000000"""Test versions."""

from awesomeversion.strategy import AwesomeVersionStrategy

TEST_VERSIONS = [
    "",
    "0.1",
    "0.118.0",
    "0",
    "1.0.0-alpha.1",
    "1.0.0-alpha.2",
    "1.0.0-alpha",
    "1.0.0-alpha+1.2",
    "1.0.0-alpha1",
    "1.0.0-alpha10",
    "1.0.0-alpha9",
    "1.0.0-beta.1",
    "1.0.0-beta.10",
    "1.0.0-beta.2",
    "1.0.0-beta.9",
    "1.0.0-beta",
    "1.0.0-beta0",
    "1.0.0-beta1",
    "1.0.0-rc.1",
    "1.0.0-rc.2",
    "1.0.0-rc0",
    "1.0.0",
    "1.0.0b0",
    "1.0.0b1",
    "1.0.0b10",
    "1.0.0b9",
    "1.0.0beta0",
    "1.0.0rc0",
    "1.0.1",
    "1.0.a0",
    "1.0.alpha1",
    "1.0.b0",
    "1.0.b1",
    "1.0.b2",
    "1.0.d1",
    "1.0.dev0",
    "1.0.dev1",
    "1.0.dev456",
    "1.0.invalid4",
    "1.0.post456.dev34",
    "1.0.post456",
    "1.0.rc2",
    "1.0",
    "1.0a1",
    "1.0a12.dev456",
    "1.0a12",
    "1.0a2.dev456",
    "1.0b0",
    "1.0b1.dev456",
    "1.0b1",
    "1.0b2.post345.dev456",
    "1.0b2.post345",
    "1.0b2",
    "1.0rc1.dev456",
    "1.0rc1",
    "1.1.dev1",
    "1.1",
    "1.2.3-1",
    "1.2.3-2",
    "1.2.3-alpha.1",
    "1.2.3-dev.1",
    "1.2.3.4.5.6.6.8",
    "1.2.3.4.5.6.7.8.9",
    "1.2.3.4.5.6.7.8",
    "1.2.3.4.5",
    "1.2.3.4.5b0",
    "1.2.3.4",
    "1.2.3",
    "1.2b0",
    "1.8.2-beta.1.10",
    "1.8.2-beta.1.10+somebuild",
    "1.8.2-beta.1.13",
    "1.dev0",
    "1.dev1",
    "1",
    "123",
    "2.0.0-alpha.1",
    "2.0.0-alpha.2",
    "2.0.0-beta.1",
    "2.0.0-beta.2",
    "2.0.0-rc.1",
    "2.0.0-rc.2",
    "2.0.0",
    "2.1.0",
    "2.1.1",
    "2.1.3",
    "2.4.6-8",
    "2",
    "20.1.0",
    "20.1",
    "2019",
    "2020.1.1.",
    "2020.1",
    "2020.12.0",
    "2020.12.1",
    "2020.12.dev1602",
    "2020.12.dev1603",
    "2020.2.0",
    "2020.21.1",
    "2020",
    "2021.1.0.0",
    "2021.1.0.dev0",
    "2021.1.0",
    "2021.1.0a0",
    "2021.1.0b0",
    "2021.1.0b1",
    "2021.1.0b2",
    "2021.1.0dev0",
    "2021.1.0dev20210101",
    "2021.2.0.dev20210118",
    "2021.2.0",
    "2021.2.0b0",
    "2021.2.0b10",
    "2022.01.01",
    "2022.01.02",
    "2022.02.01",
    "2022.02.02",
    "2022.03.01",
    "2022.03.02",
    "2023.01.01",
    "2023.01.02",
    "2023.02.01",
    "2023.02.02",
    "2023.03.01",
    "2023.03.02",
    "3.0.0-alpha.1",
    "3.0.0-alpha.2",
    "3.0.0-beta.1",
    "3.0.0-beta.2",
    "3.0.0-rc.1",
    "3.0.0-rc.2",
    "3.0.0",
    "3.0.1",
    "4.0.0",
    "4.1.0",
    "4.2.0",
    "5.0.0",
    "5.1.0",
    "5.1.1",
    "5.10",
    "5.11",
    "6.0.0",
    "6.0.dev20210429",
    "6.0.rc1",
    "6.0",
    "6.1.0",
    "6.2.0",
    "7.0.0",
    "7.1.0",
    "7.1.1",
    "a.b.c",
    "beta",
    "dev",
    "latest",
    "stable",
    "unknown",
    "v1.0.1",
    "v1.0",
    "v1.1.1",
    "v1.1",
    "v1.2.1",
    "v1.2",
    "v2.0.1",
    "v2.0",
    "v2.1.1",
    "v2.1",
    "v2.2.1",
    "v2.2",
    "00AABB00",
    "01234567",
    "0x0",
    "0x01002100",
    0x01002101,
    "0X01002604",
    "0x2df35",
    "0x00AABB00",
    "0x23089631",
    "0x0g",
    AwesomeVersionStrategy,
    False,
    None,
    str,
    True,
]


def test_human_error_in_version_list() -> None:
    """Test for human error in version list."""
    assert len(TEST_VERSIONS) == len(set(TEST_VERSIONS))
awesomeversion-24.2.0/tests/utils/000077500000000000000000000000001456050426100171525ustar00rootroot00000000000000awesomeversion-24.2.0/tests/utils/__init__.py000066400000000000000000000000001456050426100212510ustar00rootroot00000000000000awesomeversion-24.2.0/tests/utils/test_validate.py000066400000000000000000000006041456050426100223540ustar00rootroot00000000000000"""Tests for the validate util."""

import pytest

from awesomeversion.utils.validate import value_is_base16


@pytest.mark.parametrize(
    ("value", "expected"),
    (
        ("0x0", True),
        ("0xah", False),
        ("0", True),
    ),
)
def test_value_is_base16(value: str, expected: bool) -> None:
    """Test value is base16."""
    assert value_is_base16(value) == expected