version-query 1.4.0rc1__tar.gz → 1.5.2__tar.gz

{version-query-1.4.0rc1 → version-query-1.5.2}/MANIFEST.in

@@ -1,4 +1,3 @@
-include setup_boilerplate.py
 include requirements.txt
 include LICENSE
 include NOTICE

{version-query-1.4.0rc1/version_query.egg-info → version-query-1.5.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: version-query
-Version: 1.4.0rc1
+Version: 1.5.2
 Summary: Zero-overhead package versioning for Python.
 Home-page: https://github.com/mbdevpl/version-query
 Download-URL: 
@@ -18,6 +18,7 @@ Classifier: Natural Language :: English
 Classifier: Operating System :: MacOS :: MacOS X
 Classifier: Operating System :: Microsoft :: Windows
 Classifier: Operating System :: POSIX :: Linux
+Classifier: Programming Language :: Python :: 3.8
 Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
@@ -27,7 +28,7 @@ Classifier: Topic :: Software Development :: Version Control :: Git
 Classifier: Topic :: System :: Software Distribution
 Classifier: Topic :: Utilities
 Classifier: Typing :: Typed
-Requires-Python: >=3.9
+Requires-Python: >=3.8
 Description-Content-Type: text/x-rst; charset=UTF-8
 License-File: LICENSE
 License-File: NOTICE
@@ -62,7 +63,7 @@ Zero-overhead package versioning for Python.
     :alt: grade from Codacy
 
 .. image:: https://img.shields.io/github/license/mbdevpl/version-query.svg
-    :target: https://github.com/mbdevpl/version-query/blob/v1.4.0rc1/NOTICE
+    :target: https://github.com/mbdevpl/version-query/blob/v1.5.2/NOTICE
     :alt: license
 
 Package versioning toolkit for Python which relies on git tags, git history traversal
@@ -470,10 +471,10 @@ using version-query without any issues.
 Requirements
 ============
 
-Python version 3.9 or later.
+Python version 3.8 or later.
 
-Python libraries as specified in `requirements.txt <https://github.com/mbdevpl/version-query/blob/v1.4.0rc1/requirements.txt>`_.
+Python libraries as specified in `requirements.txt <https://github.com/mbdevpl/version-query/blob/v1.5.2/requirements.txt>`_.
 
-Building and running tests additionally requires packages listed in `requirements_test.txt <https://github.com/mbdevpl/version-query/blob/v1.4.0rc1/requirements_test.txt>`_.
+Building and running tests additionally requires packages listed in `requirements_test.txt <https://github.com/mbdevpl/version-query/blob/v1.5.2/requirements_test.txt>`_.
 
 Tested on Linux, OS X and Windows.

{version-query-1.4.0rc1 → version-query-1.5.2}/README.rst

@@ -436,7 +436,7 @@ using version-query without any issues.
 Requirements
 ============
 
-Python version 3.9 or later.
+Python version 3.8 or later.
 
 Python libraries as specified in `<requirements.txt>`_.
 

{version-query-1.4.0rc1 → version-query-1.5.2}/pyproject.toml

@@ -1,10 +1,21 @@
 [build-system]
-requires = ['docutils', 'GitPython', 'packaging', 'semver', 'setuptools', 'wheel']
+requires = [
+    'boilerplates[setup] ~= 0.1',
+    'GitPython ~= 3.1',
+    'packaging >= 23.0',
+    'semver ~= 2.13'
+]
 
 [tool.flake8]
 max-line-length = 100
 max-doc-length = 100
 
+[[tool.mypy.overrides]]
+module = [
+    'semver'
+]
+ignore_missing_imports = true
+
 [tool.pydocstyle]
 ignore = [
     'D102', 'D103', 'D105', 'D107',

{version-query-1.4.0rc1 → version-query-1.5.2}/requirements.txt

@@ -1,4 +1,3 @@
 GitPython ~= 3.1
 packaging >= 23.0
 semver ~= 2.13
-setuptools >= 67.4

version-query-1.5.2/requirements_test.txt

@@ -0,0 +1,4 @@
+-r requirements.txt
+boilerplates[packaging_tests] ~= 0.1
+colorlog ~= 6.7
+setuptools >= 67.4

{version-query-1.4.0rc1 → version-query-1.5.2}/setup.py

@@ -1,9 +1,9 @@
 """Setup script for version_query package."""
 
-import setup_boilerplate
+import boilerplates.setup
 
 
-class Package(setup_boilerplate.Package):
+class Package(boilerplates.setup.Package):
     """Package metadata."""
 
     name = 'version-query'
@@ -20,6 +20,7 @@ class Package(setup_boilerplate.Package):
         'Operating System :: MacOS :: MacOS X',
         'Operating System :: Microsoft :: Windows',
         'Operating System :: POSIX :: Linux',
+        'Programming Language :: Python :: 3.8',
         'Programming Language :: Python :: 3.9',
         'Programming Language :: Python :: 3.10',
         'Programming Language :: Python :: 3.11',

version-query-1.5.2/test/test_packaging.py

@@ -0,0 +1,7 @@
+"""Tests for packaging."""
+
+import boilerplates.packaging_tests
+
+
+class Tests(boilerplates.packaging_tests.PackagingTests):
+    pass

{version-query-1.4.0rc1 → version-query-1.5.2}/test/test_query.py

@@ -10,6 +10,8 @@ import sys
 import tempfile
 import unittest
 
+from boilerplates.packaging_tests import run_module
+
 from version_query.version import VersionComponent, Version
 from version_query.git_query import query_git_repo, predict_git_repo
 from version_query.py_query import query_metadata_json, query_pkg_info, query_package_folder
@@ -18,7 +20,6 @@ from version_query.query import \
 from .examples import \
     PY_LIB_DIR, GIT_REPO_EXAMPLES, METADATA_JSON_EXAMPLE_PATHS, PKG_INFO_EXAMPLE_PATHS, \
     PACKAGE_FOLDER_EXAMPLES
-from .test_setup import run_module
 
 _LOG = logging.getLogger(__name__)
 
@@ -61,7 +62,7 @@ class Tests(unittest.TestCase):
 
     def _query_test_case(self, paths, query_function):
         for path in paths:
-            if any(_ in path.parts for _ in IGNORED_FOLDER_NAMES):
+            if any(_ in path.parts for _ in IGNORED_FOLDER_NAMES) or not path.exists():
                 continue
             with self.subTest(path=path, query_function=query_function):
                 _LOG.debug('testing %s() on %s', query_function.__name__, path)

{version-query-1.4.0rc1 → version-query-1.5.2}/version_query/git_query.py

@@ -46,7 +46,8 @@ def _latest_git_version_tag_on_branches(
             t.Optional[git.objects.Commit], t.Optional[git.TagReference], t.Optional[Version],
             int]]:
     _LOG.log(logging.NOTSET, 'entering %i branches...', len(commit.parents))
-    results = []
+    results: t.List[t.Tuple[
+        t.Optional[git.objects.Commit], t.Optional[git.TagReference], Version, int]] = []
     main_commit_distance = None
     for parent in commit.parents:
         try:
@@ -57,7 +58,7 @@ def _latest_git_version_tag_on_branches(
         if main_commit_distance is None:
             main_commit_distance = result[3]
         if result[2] is not None:
-            results.append(result)
+            results.append(result)  # type: ignore
     if not results:
         if main_commit_distance is None:
             raise ValueError(f'reached max commit distance {MAX_COMMIT_DISTANCE}'
@@ -73,8 +74,9 @@ MAX_COMMIT_DISTANCE = 999
 
 
 def _latest_git_version_tag(
-        repo: git.Repo, assume_if_none: bool = False, base_commit: git.objects.Commit = None,
-        commit_distance: int = 0, skip_commits: t.Set[git.objects.Commit] = None) -> t.Tuple[
+        repo: git.Repo, assume_if_none: bool = False,
+        base_commit: t.Optional[git.objects.Commit] = None, commit_distance: int = 0,
+        skip_commits: t.Optional[t.Set[git.objects.Commit]] = None) -> t.Tuple[
             t.Optional[git.objects.Commit], t.Optional[git.TagReference], t.Optional[Version], int]:
     """Return (commit, tag at that commit if any, latest version, distance from the version)."""
     version_tags = _git_version_tags(repo)

{version-query-1.4.0rc1 → version-query-1.5.2/version_query.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: version-query
-Version: 1.4.0rc1
+Version: 1.5.2
 Summary: Zero-overhead package versioning for Python.
 Home-page: https://github.com/mbdevpl/version-query
 Download-URL: 
@@ -18,6 +18,7 @@ Classifier: Natural Language :: English
 Classifier: Operating System :: MacOS :: MacOS X
 Classifier: Operating System :: Microsoft :: Windows
 Classifier: Operating System :: POSIX :: Linux
+Classifier: Programming Language :: Python :: 3.8
 Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
@@ -27,7 +28,7 @@ Classifier: Topic :: Software Development :: Version Control :: Git
 Classifier: Topic :: System :: Software Distribution
 Classifier: Topic :: Utilities
 Classifier: Typing :: Typed
-Requires-Python: >=3.9
+Requires-Python: >=3.8
 Description-Content-Type: text/x-rst; charset=UTF-8
 License-File: LICENSE
 License-File: NOTICE
@@ -62,7 +63,7 @@ Zero-overhead package versioning for Python.
     :alt: grade from Codacy
 
 .. image:: https://img.shields.io/github/license/mbdevpl/version-query.svg
-    :target: https://github.com/mbdevpl/version-query/blob/v1.4.0rc1/NOTICE
+    :target: https://github.com/mbdevpl/version-query/blob/v1.5.2/NOTICE
     :alt: license
 
 Package versioning toolkit for Python which relies on git tags, git history traversal
@@ -470,10 +471,10 @@ using version-query without any issues.
 Requirements
 ============
 
-Python version 3.9 or later.
+Python version 3.8 or later.
 
-Python libraries as specified in `requirements.txt <https://github.com/mbdevpl/version-query/blob/v1.4.0rc1/requirements.txt>`_.
+Python libraries as specified in `requirements.txt <https://github.com/mbdevpl/version-query/blob/v1.5.2/requirements.txt>`_.
 
-Building and running tests additionally requires packages listed in `requirements_test.txt <https://github.com/mbdevpl/version-query/blob/v1.4.0rc1/requirements_test.txt>`_.
+Building and running tests additionally requires packages listed in `requirements_test.txt <https://github.com/mbdevpl/version-query/blob/v1.5.2/requirements_test.txt>`_.
 
 Tested on Linux, OS X and Windows.

{version-query-1.4.0rc1 → version-query-1.5.2}/version_query.egg-info/SOURCES.txt

@@ -6,8 +6,13 @@ pyproject.toml
 requirements.txt
 requirements_test.txt
 setup.py
-setup_boilerplate.py
 ./test/__init__.py
+./test/examples.py
+./test/test_git.py
+./test/test_packaging.py
+./test/test_query.py
+./test/test_version.py
+./test/test_with_git_repo.py
 ./version_query/__init__.py
 ./version_query/__main__.py
 ./version_query/_version.py
@@ -19,8 +24,8 @@ setup_boilerplate.py
 ./version_query/version.py
 test/examples.py
 test/test_git.py
+test/test_packaging.py
 test/test_query.py
-test/test_setup.py
 test/test_version.py
 test/test_with_git_repo.py
 version_query.egg-info/PKG-INFO

{version-query-1.4.0rc1 → version-query-1.5.2}/version_query.egg-info/requires.txt

@@ -1,4 +1,3 @@
 GitPython~=3.1
 packaging>=23.0
 semver~=2.13
-setuptools>=67.4

{version-query-1.4.0rc1 → version-query-1.5.2}/version_query.egg-info/top_level.txt

@@ -1 +1,2 @@
+test
 version_query

version-query-1.4.0rc1/requirements_test.txt

@@ -1,6 +0,0 @@
-colorlog ~= 6.7
-docutils ~= 0.19
-pip >= 23.0
-Pygments ~= 2.14
-wheel >= 0.40
--r requirements.txt

version-query-1.4.0rc1/setup_boilerplate.py

@@ -1,393 +0,0 @@
-"""Below code is generic boilerplate and normally should not be changed.
-
-See the implementation of setup_boilerplate.Package for available options.
-Also, some fields have default values. See DEFAULT_* constants below for those values.
-
-To avoid setup script boilerplate, create "setup.py" file with the minimal contents as given
-below and modify it according to the specifics of your package.
-Note: string limiters need to be adjusted.
-
-"" "Setup script." ""
-
-import setup_boilerplate
-
-
-class Package(setup_boilerplate.Package):
-    "" "Package metadata." ""
-
-    name = ''
-    description = ''
-    url = 'https://github.com/mbdevpl/...'
-    classifiers = [
-        'Development Status :: 1 - Planning',
-        'Programming Language :: Python :: 3.7',
-        'Programming Language :: Python :: 3.8',
-        'Programming Language :: Python :: 3.9',
-        'Programming Language :: Python :: 3.10',
-        'Programming Language :: Python :: 3 :: Only']
-    keywords = []
-
-
-if __name__ == '__main__':
-    Package.setup()
-"""
-
-import logging
-import pathlib
-import runpy
-import sys
-import typing as t
-
-import docutils.frontend
-import docutils.nodes
-import docutils.parsers.rst
-import docutils.utils
-import setuptools
-
-__version__ = '2023.03.09'
-
-_LOG = logging.getLogger(__name__)
-
-HERE = pathlib.Path(__file__).resolve().parent
-
-DEFAULT_URL = 'https://github.com/mbdevpl'
-DEFAULT_AUTHOR = 'Mateusz Bysiek'
-DEFAULT_AUTHOR_EMAIL = 'mateusz.bysiek@gmail.com'
-DEFAULT_LICENSE_STR = 'Apache License 2.0'
-
-
-def find_version(
-        package_name: str, version_module_name: str = '_version',
-        version_variable_name: str = 'VERSION') -> str:
-    """Simulate behaviour of "from package_name._version import VERSION", and return VERSION.
-
-    To avoid importing whole package only to read the version, just module containing the version
-    is imported. Therefore relative imports in that module will break the setup.
-
-    :param package_name: name of the package
-    :param version_module_name: name of the module containing the version
-    :param version_variable_name: name of the variable containing the version
-    :return: version string
-    """
-    version_module_path = f'{package_name.replace("-", "_")}/{version_module_name}.py'
-    version_module_vars = runpy.run_path(version_module_path)
-    return version_module_vars[version_variable_name]
-
-
-def find_packages(root_directory: str = '.') -> t.List[str]:
-    """Find packages to pack.
-
-    :param root_directory: directory to start searching from
-    :return: list of packages
-    """
-    exclude = ['test', 'test.*'] if ('bdist_wheel' in sys.argv or 'bdist' in sys.argv) else []
-    packages_list = setuptools.find_packages(root_directory, exclude=exclude)
-    return packages_list
-
-
-def parse_requirements(
-        requirements_path: str = 'requirements.txt') -> t.List[str]:
-    """Read contents of requirements.txt file and return data from its relevant lines.
-
-    Only non-empty and non-comment lines are relevant.
-
-    :param requirements_path: path to the requirements file if custom one is used
-    :return: list of requirements
-    """
-    requirements = []
-    with HERE.joinpath(requirements_path).open(encoding='utf-8') as requirements_file:
-        for requirement in [line.strip() for line in requirements_file.read().splitlines()]:
-            if not requirement or requirement.startswith('#'):
-                continue
-            requirements.append(requirement)
-    return requirements
-
-
-def partition_version_classifiers(
-        classifiers: t.Sequence[str], version_prefix: str = 'Programming Language :: Python :: ',
-        only_suffix: str = ' :: Only'
-        ) -> t.Tuple[t.List[t.Tuple[int, ...]], t.List[t.Tuple[int, ...]]]:
-    """Find version number classifiers in given list and partition them into 2 groups.
-
-    The 2 groups being:
-    1. minimum versions, any version at least as high this is compatible
-    2. only versions, this specific version is compatible, but nothing is said about other versions
-
-    :param classifiers: sequence of trove classifiers to be analysed
-    :param version_prefix: prefix that identifies a version classifier
-    :param only_suffix: prefix that identifies an "only version" classifier
-    :return: parsed and partitioned version tuples
-    """
-    versions_min: t.List[t.Tuple[int, ...]] = []
-    versions_only: t.List[t.Tuple[int, ...]] = []
-    for classifier in classifiers:
-        version = classifier.replace(version_prefix, '')
-        versions = versions_min
-        if version.endswith(only_suffix):
-            version = version.replace(only_suffix, '')
-            versions = versions_only
-        try:
-            versions.append(tuple(int(_) for _ in version.split('.')))
-        except ValueError:
-            pass
-    return versions_min, versions_only
-
-
-def find_required_python_version(
-        classifiers: t.Sequence[str], version_prefix: str = 'Programming Language :: Python :: ',
-        only_suffix: str = ' :: Only') -> t.Optional[str]:
-    """Determine the minimum required Python version.
-
-    :param classifiers: sequence of trove classifiers to be analysed
-    :param version_prefix: prefix that identifies a version classifier
-    :param only_suffix: prefix that identifies an "only version" classifier
-    :return: minimum required Python version string, if any
-    """
-    versions_min, versions_only = partition_version_classifiers(
-        classifiers, version_prefix, only_suffix)
-    if len(versions_only) > 1:
-        raise ValueError(f'more than one "{only_suffix}" version encountered in {versions_only}')
-    only_version = None
-    if len(versions_only) == 1:
-        only_version = versions_only[0]
-        for version in versions_min:
-            if version[:len(only_version)] != only_version:
-                raise ValueError(f'the "{only_suffix}" version {only_version}'
-                                 f' is inconsistent with version {version}')
-    min_supported_version = None
-    for version in versions_min:
-        if min_supported_version is None or \
-                (len(version) >= len(min_supported_version) and version < min_supported_version):
-            min_supported_version = version
-    if min_supported_version is None:
-        if only_version is not None:
-            return '.'.join([str(_) for _ in only_version])
-    else:
-        return '>=' + '.'.join([str(_) for _ in min_supported_version])
-    return None
-
-
-def parse_rst(text: str) -> docutils.nodes.document:
-    """Parse text assuming it's an RST markup."""
-    parser = docutils.parsers.rst.Parser()
-    components = (docutils.parsers.rst.Parser,)
-    settings = docutils.frontend.OptionParser(components=components).get_default_values()
-    document = docutils.utils.new_document('<rst-doc>', settings=settings)
-    parser.parse(text, document)
-    return document
-
-
-class RelativeRefFinder(docutils.nodes.NodeVisitor):
-    """Find all relative references in a given docutils document that point to existing files."""
-
-    def __init__(self, root_dir: pathlib.Path, *args, **kwargs):
-        """Initialize the RelativeRefFinder object."""
-        super().__init__(*args, **kwargs)
-        self.root_dir = root_dir
-        self.references: t.List[docutils.nodes.reference] = []
-
-    def visit_reference(self, node: docutils.nodes.reference) -> None:
-        """Call for "reference" nodes."""
-        assert isinstance(node, docutils.nodes.TextElement), type(node)
-        _LOG.debug('RelativeRefFinder: examining reference %s', node)
-        if len(node.children) != 1 or 'refuri' not in node.attributes \
-                or node.attributes['refuri'].startswith(('http://', 'https://')):
-            return
-        # _LOG.debug('  RelativeRefFinder: reference passed initial check')
-        path = pathlib.Path(node.attributes['refuri'])
-        if path.is_absolute():
-            return
-        if '#' in path.name:
-            # reference points to a section in a file
-            # we ignore the section part when checking if file exists
-            path = path.with_name(path.name[:path.name.index('#')])
-        try:
-            self.root_dir.joinpath(path).resolve(strict=True)
-        except FileNotFoundError:
-            return
-        _LOG.debug('RelativeRefFinder: reference points to existing file')
-        self.references.append(node)
-
-    def unknown_visit(self, node: docutils.nodes.Node) -> None:
-        """Call for unknown node types."""
-        return
-
-
-def resolve_relative_rst_links(text: str, base_link: str) -> str:
-    """Resolve all relative links in a given string representing an RST document.
-
-    Links are resolved only if they point to files existing in the project's working directory.
-
-    All links of form `link`_ become `link <absolute_link>`_.
-
-    And all link of the form :target: link become :target: absolute_link.
-
-    Where absolute_link is made by concatenating base_link to link with no separator added
-    in between. So in most cases base_link should end with a slash.
-    """
-    document = parse_rst(text)
-    finder = RelativeRefFinder(HERE, document)
-    document.walk(finder)
-    for target in finder.references:
-        _LOG.info('resolve_relative_rst_links: resolving reference %s', target)
-        assert isinstance(target, docutils.nodes.TextElement), type(target)
-        refuri = target.attributes['refuri']
-        if 'name' in target.attributes:
-            name = target.attributes['name']
-            if name == refuri:
-                old_link = f'`<{refuri}>`_'
-            else:
-                old_link = f'`{name} <{refuri}>`_'
-            new_link = f'`{name} <{base_link}{refuri}>`_'
-        else:
-            old_link = f' :target: {refuri}'
-            new_link = f' :target: {base_link}{refuri}'
-        text = text.replace(old_link, new_link)
-        _LOG.info('resolve_relative_rst_links: replaced "%s" with "%s"', old_link, new_link)
-    return text
-
-
-class Package:
-    """Default metadata and behaviour for a Python package setup script."""
-
-    root_directory: str = '.'
-    """Root directory of the source code of the package, relative to the setup.py file location."""
-
-    name: str
-    """Package name."""
-
-    version: str
-    """Package version as string.
-
-    If None, it will be obtained from "package_name._version.VERSION" variable.
-    """
-
-    description: str
-    """One line of text that shortly describes the package."""
-
-    long_description: str
-    """Full description of the package, can be arbitrarily long.
-
-    If not set, it will be generated from readme.
-    """
-
-    long_description_content_type: str
-    """Content type of the long description.
-
-    Usually one of 'text/x-rst', 'text/markdown' or 'text/plain'.
-
-    If not set, it will be set according to readme file extension.
-    For this field to be automatically set, also long_description field cannot be set.
-    """
-
-    url: str = DEFAULT_URL
-    download_url: str = ''
-    author: str = DEFAULT_AUTHOR
-    author_email: str = DEFAULT_AUTHOR_EMAIL
-    maintainer: str
-    maintainer_email: str
-    license_str: str = DEFAULT_LICENSE_STR
-
-    classifiers: t.List[str] = []
-    """List of trove classifiers for the package.
-
-    List of valid classifiers: https://pypi.org/pypi?:action=list_classifiers
-    """
-
-    keywords: t.List[str] = []
-
-    packages: t.List[str]
-    """List of Python packages to be included in the distributed file.
-
-    Usually it's just one package per distributed file, but any number is supported.
-
-    If not set, determined with help of setuptools.
-    """
-
-    package_data: t.Dict[str, t.List[str]] = {}
-    exclude_package_data: t.Dict[str, t.List[str]] = {}
-
-    install_requires: t.Optional[t.List[str]] = None
-    """If None, determined using requirements.txt."""
-
-    extras_require: t.Mapping[str, t.List[str]] = {}
-    """A dictionary containing entries of type 'some_feature': ['requirement1', 'requirement2']."""
-
-    python_requires: t.Optional[str] = None
-    """If None, determined from provided classifiers."""
-
-    entry_points: t.Mapping[str, t.List[str]] = {}
-    """A dictionary used to enable automatic creation of console scripts, gui scripts and plugins.
-
-    Example entry:
-    'console_scripts': ['script_name = package.subpackage:function']
-    """
-
-    test_suite: str = 'test'
-
-    @classmethod
-    def try_fields(cls, *names) -> t.Optional[t.Any]:
-        """Return first existing of given class field names."""
-        for name in names:
-            if hasattr(cls, name):
-                return getattr(cls, name)
-        raise AttributeError((cls, names))
-
-    @classmethod
-    def parse_readme(cls, readme_filename: str = 'README.rst',
-                     encoding: str = 'utf-8') -> t.Tuple[str, str]:
-        """Parse readme and resolve relative links in it if it is feasible.
-
-        Links are resolved if readme is in rst format and the package is hosted on GitHub.
-        """
-        readme_path = HERE.joinpath(readme_filename)
-        with readme_path.open(encoding=encoding) as readme_file:
-            long_description: str = readme_file.read()
-
-        if readme_path.suffix.lower() == '.rst' and cls.url.startswith('https://github.com/'):
-            base_url = f'{cls.url}/blob/v{cls.version}/'
-            long_description = resolve_relative_rst_links(long_description, base_url)
-
-        long_description_content_type = {'.rst': 'text/x-rst', '.md': 'text/markdown'}.get(
-            readme_path.suffix.lower(), 'text/plain')
-        long_description_content_type += '; charset=UTF-8'
-
-        return long_description, long_description_content_type
-
-    @classmethod
-    def prepare(cls) -> None:
-        """Fill in possibly missing package metadata."""
-        if not hasattr(cls, 'version'):
-            cls.version = find_version(cls.name)
-        if not hasattr(cls, 'long_description'):
-            cls.long_description, cls.long_description_content_type = cls.parse_readme()
-        if not hasattr(cls, 'maintainer'):
-            cls.maintainer = cls.author
-        if not hasattr(cls, 'maintainer_email'):
-            cls.maintainer_email = cls.author_email
-        if not hasattr(cls, 'packages'):
-            cls.packages = find_packages(cls.root_directory)
-        if cls.install_requires is None:
-            cls.install_requires = parse_requirements()
-        if cls.python_requires is None:
-            cls.python_requires = find_required_python_version(cls.classifiers)
-
-    @classmethod
-    def setup(cls) -> None:
-        """Call setuptools.setup with correct arguments."""
-        cls.prepare()
-        setuptools.setup(
-            name=cls.name, version=cls.version, description=cls.description,
-            long_description=cls.long_description,
-            long_description_content_type=cls.long_description_content_type,
-            url=cls.url, download_url=cls.download_url,
-            author=cls.author, author_email=cls.author_email,
-            maintainer=cls.maintainer,
-            maintainer_email=cls.maintainer_email,
-            license=cls.license_str, classifiers=cls.classifiers, keywords=cls.keywords,
-            packages=cls.packages, package_dir={'': cls.root_directory},
-            include_package_data=True,
-            package_data=cls.package_data, exclude_package_data=cls.exclude_package_data,
-            install_requires=cls.install_requires, extras_require=cls.extras_require,
-            python_requires=cls.python_requires,
-            entry_points=cls.entry_points, test_suite=cls.test_suite)

version-query-1.4.0rc1/test/test_setup.py

@@ -1,364 +0,0 @@
-"""Tests for setup scripts."""
-
-import importlib
-import itertools
-import logging
-import os
-import pathlib
-import runpy
-import subprocess
-import sys
-import tempfile
-import types
-import typing as t
-import unittest
-
-__version__ = '2023.03.09'
-
-_LOG = logging.getLogger(__name__)
-
-
-def expand_args_by_globbing_items(*args: str) -> t.Tuple[str, ...]:
-    """Expand a list of glob expressions."""
-    cwd = pathlib.Path.cwd()
-    expanded_args = []
-    for arg in args:
-        if '*' not in arg:
-            expanded_args.append(arg)
-            continue
-        expanded_arg = [str(_.relative_to(cwd)) for _ in cwd.glob(arg)]
-        assert expanded_arg, arg
-        _LOG.debug('expanded arg "%s" to %s', arg, expanded_arg)
-        expanded_args += expanded_arg
-    _LOG.debug('expanded args to %s', expanded_args)
-    return tuple(expanded_args)
-
-
-def run_program(*args, glob: bool = False) -> None:
-    """Run subprocess with given args. Use path globbing for each arg that contains an asterisk."""
-    if glob:
-        args = expand_args_by_globbing_items(*args)
-    try:
-        subprocess.run(args, check=True)
-    except subprocess.CalledProcessError as err:
-        raise AssertionError(f'execution of {args} failed') from err
-
-
-def run_pip(*args, **kwargs) -> None:
-    run_program(sys.executable, '-m', 'pip', *args, **kwargs)
-
-
-def run_module(name: str, *args, run_name: str = '__main__') -> None:
-    backup_sys_argv = sys.argv
-    sys.argv = [name + '.py'] + list(args)
-    runpy.run_module(name, run_name=run_name)
-    sys.argv = backup_sys_argv
-
-
-def import_module(name: str = 'setup') -> types.ModuleType:
-    setup_module = importlib.import_module(name)
-    return setup_module
-
-
-def import_module_member(module_name: str, member_name: str) -> t.Any:
-    module = import_module(module_name)
-    return getattr(module, member_name)
-
-
-CLASSIFIERS_LICENSES = (
-    'License :: OSI Approved :: Python License (CNRI Python License)',
-    'License :: OSI Approved :: Python Software Foundation License',
-    'License :: Other/Proprietary License',
-    'License :: Public Domain')
-
-CLASSIFIERS_PYTHON_VERSIONS = tuple("""Programming Language :: Python
-Programming Language :: Python :: 3
-Programming Language :: Python :: 3.0
-Programming Language :: Python :: 3.5
-Programming Language :: Python :: 3 :: Only""".splitlines())
-
-CLASSIFIERS_PYTHON_IMPLEMENTATIONS = tuple("""Programming Language :: Python :: Implementation
-Programming Language :: Python :: Implementation :: CPython
-Programming Language :: Python :: Implementation :: Jython
-Programming Language :: Python :: Implementation :: PyPy
-Programming Language :: Python :: Implementation :: Stackless""".splitlines())
-
-CLASSIFIERS_VARIOUS = (
-    'Framework :: IPython',
-    'Topic :: Scientific/Engineering',
-    'Topic :: Sociology',
-    'Topic :: Security :: Cryptography',
-    'Topic :: Software Development :: Libraries :: Python Modules',
-    'Topic :: Software Development :: Version Control :: Git',
-    'Topic :: System',
-    'Topic :: Utilities')
-
-CLASSIFIERS_LICENSES_TUPLES = tuple((_,) for _ in CLASSIFIERS_LICENSES) + ((),)
-
-CLASSIFIERS_PYTHON_VERSIONS_COMBINATIONS = tuple((_,) for _ in CLASSIFIERS_PYTHON_VERSIONS)
-
-CLASSIFIERS_PYTHON_IMPLEMENTATIONS_TUPLES = tuple((_,) for _ in CLASSIFIERS_PYTHON_IMPLEMENTATIONS)
-
-CLASSIFIERS_VARIOUS_COMBINATIONS = tuple(itertools.combinations(
-    CLASSIFIERS_VARIOUS, len(CLASSIFIERS_VARIOUS) - 1)) + (CLASSIFIERS_VARIOUS,)
-
-ALL_CLASSIFIERS_VARIANTS = [
-    licenses + versions + implementations + various
-    for licenses in CLASSIFIERS_LICENSES_TUPLES
-    for versions in CLASSIFIERS_PYTHON_VERSIONS_COMBINATIONS
-    for implementations in CLASSIFIERS_PYTHON_IMPLEMENTATIONS_TUPLES
-    for various in CLASSIFIERS_VARIOUS_COMBINATIONS]
-
-LINK_EXAMPLES = [
-    (None, 'setup.py', True), ('this file', 'setup.py', True), (None, 'test/test_setup.py', True),
-    (None, 'test/test_setup.py#L98', True), ('line 5 of this file', 'setup.py#L5', True),
-    (None, 'http://site.com', False), (None, '../something/else', False), (None, 'no.thing', False),
-    (None, '/my/abs/path', False), ('test dir', 'test', True)]
-
-
-def get_package_folder_name():
-    """Attempt to guess the built package name."""
-    cwd = pathlib.Path.cwd()
-    directories = [
-        path for path in cwd.iterdir() if pathlib.Path(cwd, path).is_dir()
-        and pathlib.Path(cwd, path, '__init__.py').is_file() and path.name != 'test']
-    assert len(directories) == 1, directories
-    return directories[0].name
-
-
-class UnitTests(unittest.TestCase):
-    """Test basic functionalities of the setup boilerplate."""
-
-    def test_find_version(self):
-        find_version = import_module_member('setup_boilerplate', 'find_version')
-        result = find_version(get_package_folder_name())
-        self.assertIsInstance(result, str)
-
-    def test_find_packages(self):
-        find_packages = import_module_member('setup_boilerplate', 'find_packages')
-        results = find_packages()
-        self.assertIsInstance(results, list)
-        for result in results:
-            self.assertIsInstance(result, str)
-
-    def test_requirements(self):
-        parse_requirements = import_module_member('setup_boilerplate', 'parse_requirements')
-        results = parse_requirements()
-        self.assertIsInstance(results, list)
-        self.assertTrue(all(isinstance(result, str) for result in results), msg=results)
-
-    def test_requirements_empty(self):
-        parse_requirements = import_module_member('setup_boilerplate', 'parse_requirements')
-        with tempfile.NamedTemporaryFile('w', delete=False) as reqs_file:
-            pass
-        results = parse_requirements(reqs_file.name)
-        self.assertIsInstance(results, list)
-        self.assertEqual(len(results), 0)
-        os.remove(reqs_file.name)
-
-    def test_requirements_comments(self):
-        parse_requirements = import_module_member('setup_boilerplate', 'parse_requirements')
-        reqs = ['# comment', 'numpy', '', '# another comment', 'scipy', '', '# one more comment']
-        with tempfile.NamedTemporaryFile('w', delete=False) as reqs_file:
-            for req in reqs:
-                print(req, file=reqs_file)
-        results = parse_requirements(reqs_file.name)
-        self.assertIsInstance(results, list)
-        self.assertGreater(len(results), 0)
-        self.assertLess(len(results), len(reqs))
-        os.remove(reqs_file.name)
-
-    def test_python_versions(self):
-        find_required_python_version = import_module_member(
-            'setup_boilerplate', 'find_required_python_version')
-        for variant in ALL_CLASSIFIERS_VARIANTS:
-            with self.subTest(variant=variant):
-                result = find_required_python_version(variant)
-                if result is not None:
-                    self.assertIsInstance(result, str)
-
-    def test_python_versions_combined(self):
-        find_required_python_version = import_module_member(
-            'setup_boilerplate', 'find_required_python_version')
-        classifiers = [
-            'Programming Language :: Python :: 3 :: Only',
-            'Programming Language :: Python :: 3.5']
-        req = find_required_python_version(classifiers)
-        self.assertEqual(req, '>=3.5')
-
-    def test_python_versions_reversed(self):
-        find_required_python_version = import_module_member(
-            'setup_boilerplate', 'find_required_python_version')
-        classifiers = [
-            'Programming Language :: Python :: 3.4',
-            'Programming Language :: Python :: 3.5',
-            'Programming Language :: Python :: 3.6']
-        req = find_required_python_version(classifiers)
-        self.assertEqual(req, '>=3.4')
-        req = find_required_python_version(reversed(classifiers))
-        self.assertEqual(req, '>=3.4')
-
-    def test_python_versions_none(self):
-        find_required_python_version = import_module_member(
-            'setup_boilerplate', 'find_required_python_version')
-        result = find_required_python_version([])
-        self.assertIsNone(result)
-
-    def test_python_versions_many_only(self):
-        find_required_python_version = import_module_member(
-            'setup_boilerplate', 'find_required_python_version')
-        classifiers = [
-            'Programming Language :: Python :: 2 :: Only',
-            'Programming Language :: Python :: 3 :: Only']
-        with self.assertRaises(ValueError):
-            find_required_python_version(classifiers)
-
-    def test_python_versions_conflict(self):
-        find_required_python_version = import_module_member(
-            'setup_boilerplate', 'find_required_python_version')
-        classifier_variants = [
-            ['Programming Language :: Python :: 2.7',
-             'Programming Language :: Python :: 3 :: Only'],
-            ['Programming Language :: Python :: 2 :: Only',
-             'Programming Language :: Python :: 3.0']]
-        for classifiers in classifier_variants:
-            with self.assertRaises(ValueError):
-                find_required_python_version(classifiers)
-
-
-class PackageTests(unittest.TestCase):
-    """Test methods of Package class."""
-
-    def test_try_fields(self):
-        package = import_module_member('setup_boilerplate', 'Package')
-
-        class Package(package):  # pylint: disable=too-few-public-methods
-            name = 'package name'
-            description = 'package description'
-        self.assertEqual(Package.try_fields('name', 'description'), 'package name')
-        self.assertEqual(Package.try_fields('bad_field', 'description'), 'package description')
-        with self.assertRaises(AttributeError):
-            self.assertIsNone(Package.try_fields())
-        with self.assertRaises(AttributeError):
-            Package.try_fields('bad_field', 'another_bad_field')
-
-    def test_parse_readme(self):
-        package = import_module_member('setup_boilerplate', 'Package')
-
-        class Package(package):  # pylint: disable=too-few-public-methods
-            name = 'package name'
-            description = 'package description'
-            version = '1.2.3.4'
-            url = 'https://github.com/example'
-
-        with tempfile.NamedTemporaryFile('w', suffix='.md', delete=False) as temp_file:
-            temp_file.write('test test test')
-        result, content_type = Package.parse_readme(temp_file.name)
-        os.remove(temp_file.name)
-        self.assertIsInstance(result, str)
-        self.assertIsInstance(content_type, str)
-
-        prefix = 'https://github.com/example/blob/v1.2.3.4/'
-        for name, link, done in LINK_EXAMPLES:
-            name = '' if name is None else name + ' '
-            text = f'Please see `{name}<{link}>`_ for details.'
-            with tempfile.NamedTemporaryFile('w', suffix='.rst', delete=False) as temp_file:
-                temp_file.write(text)
-            result, content_type = Package.parse_readme(temp_file.name)
-            os.remove(temp_file.name)
-            self.assertIsInstance(result, str)
-            self.assertIsInstance(content_type, str)
-            if not done:
-                self.assertEqual(result, text)
-                continue
-            if name == '':
-                name = link + ' '
-            self.assertIn(f'`{name}<{prefix}{link}>`_', result)
-
-    def test_prepare(self):
-        package = import_module_member('setup_boilerplate', 'Package')
-
-        version_ = '1.2.3.4.5.6.7'
-        long_description_ = 'long package description'
-
-        class Package(package):  # pylint: disable=too-few-public-methods, missing-docstring
-            name = 'package name'
-            version = version_
-            description = 'package description'
-            long_description = long_description_
-            packages = []
-            install_requires = []
-            python_requires = ''
-
-        self.assertEqual(Package.version, version_)
-        self.assertEqual(Package.long_description, long_description_)
-        Package.prepare()
-        self.assertEqual(Package.version, version_)
-        self.assertEqual(Package.long_description, long_description_)
-
-        del Package.long_description
-        del Package.packages
-        del Package.install_requires
-        del Package.python_requires
-        Package.prepare()
-
-        del Package.version
-        with self.assertRaises(FileNotFoundError):
-            Package.prepare()
-
-
-@unittest.skipUnless(os.environ.get('TEST_PACKAGING') or os.environ.get('CI'),
-                     'skipping packaging tests for actual package')
-class IntegrationTests(unittest.TestCase):
-    """Test if the boilerplate can actually create a valid package."""
-
-    pkg_name = get_package_folder_name()
-
-    def test_build_binary(self):
-        run_module('setup', 'bdist')
-        self.assertTrue(os.path.isdir('dist'))
-
-    def test_build_wheel(self):
-        run_module('setup', 'bdist_wheel')
-        self.assertTrue(os.path.isdir('dist'))
-
-    def test_build_source(self):
-        run_module('setup', 'sdist', '--formats=gztar,zip')
-        self.assertTrue(os.path.isdir('dist'))
-
-    def test_install_code(self):
-        with tempfile.TemporaryDirectory() as temporary_folder:
-            run_pip('install', '--prefix', temporary_folder, '.')
-        self.assertFalse(pathlib.Path(temporary_folder).exists())
-
-    def test_install_source_tar(self):
-        find_version = import_module_member('setup_boilerplate', 'find_version')
-        version = find_version(self.pkg_name)
-        with tempfile.TemporaryDirectory() as temporary_folder:
-            run_pip(
-                'install', '--prefix', temporary_folder, f'dist/*-{version}.tar.gz', glob=True)
-        self.assertFalse(pathlib.Path(temporary_folder).exists())
-
-    def test_install_source_zip(self):
-        find_version = import_module_member('setup_boilerplate', 'find_version')
-        version = find_version(self.pkg_name)
-        with tempfile.TemporaryDirectory() as temporary_folder:
-            run_pip('install', '--prefix', temporary_folder, f'dist/*-{version}.zip', glob=True)
-        self.assertFalse(pathlib.Path(temporary_folder).exists())
-
-    def test_install_wheel(self):
-        find_version = import_module_member('setup_boilerplate', 'find_version')
-        version = find_version(self.pkg_name)
-        with tempfile.TemporaryDirectory() as temporary_folder:
-            run_pip(
-                'install', '--prefix', temporary_folder, f'dist/*-{version}-*.whl', glob=True)
-        self.assertFalse(pathlib.Path(temporary_folder).exists())
-
-    def test_pip_error(self):
-        with self.assertRaises(AssertionError):
-            run_pip('wrong_pip_command')
-
-    def test_setup_do_nothing_or_error(self):
-        run_module('setup', 'wrong_setup_command', run_name='__not_main__')
-        with self.assertRaises(SystemExit):
-            run_module('setup', 'wrong_setup_command')