check-python-versions 0.23.0__py3-none-any.whl

check_python_versions/sources/setup_py.py

@@ -0,0 +1,201 @@
+"""
+Support for setup.py.
+
+There are two ways of declaring Python versions in a setup.py:
+classifiers like
+
+    Programming Language :: Python :: 3.8
+
+and python_requires.
+
+check-python-versions supports both.
+"""
+
+import ast
+import os
+import shutil
+import sys
+from typing import List, Optional, TextIO, Union, cast
+
+from .base import Source
+from ..parsers.classifiers import (
+    get_versions_from_classifiers,
+    update_classifiers,
+)
+from ..parsers.python import (
+    AstValue,
+    eval_ast_node,
+    find_call_kwarg_in_ast,
+    update_call_arg_in_source,
+)
+from ..parsers.requires_python import (
+    compute_python_requires,
+    detect_style,
+    parse_python_requires,
+)
+from ..utils import (
+    FileLines,
+    FileOrFilename,
+    file_name,
+    is_file_object,
+    open_file,
+    pipe,
+    warn,
+)
+from ..versions import SortedVersionList
+
+
+SETUP_PY = 'setup.py'
+
+
+def get_supported_python_versions(
+    filename: FileOrFilename = SETUP_PY
+) -> SortedVersionList:
+    """Extract supported Python versions from classifiers in setup.py.
+
+    Note: if AST-based parsing fails, this falls back to executing
+    ``python setup.py --classifiers``.
+    """
+    classifiers = get_setup_py_keyword(filename, 'classifiers')
+    if classifiers is None and not is_file_object(filename):
+        # AST parsing is complicated
+        filename = cast(str, filename)
+        setup_py = os.path.basename(filename)
+        classifiers = pipe(find_python(), setup_py, "-q", "--classifiers",
+                           cwd=os.path.dirname(filename)).splitlines()
+    if classifiers is None:
+        # Note: do not return None because setup.py is not an optional source!
+        # We want errors to show up if setup.py fails to declare Python
+        # versions in classifiers.
+        return []
+    if not isinstance(classifiers, (list, tuple)):
+        warn(f'The value passed to setup(classifiers=...) in {filename}'
+             ' is not a list')
+        return []
+    return get_versions_from_classifiers(classifiers)
+
+
+def get_python_requires(
+    setup_py: FileOrFilename = SETUP_PY,
+) -> Optional[SortedVersionList]:
+    """Extract supported Python versions from python_requires in setup.py."""
+    python_requires = get_setup_py_keyword(setup_py, 'python_requires')
+    if python_requires is None:
+        return None
+    if not isinstance(python_requires, str):
+        warn('The value passed to setup(python_requires=...)'
+             f' in {file_name(setup_py)} is not a string')
+        return None
+    return parse_python_requires(python_requires, filename=file_name(setup_py))
+
+
+def update_supported_python_versions(
+    filename: FileOrFilename,
+    new_versions: SortedVersionList,
+) -> Optional[FileLines]:
+    """Update classifiers in a setup.py.
+
+    Does not touch the file but returns a list of lines with new file contents.
+    """
+    classifiers = get_setup_py_keyword(filename, 'classifiers')
+    if classifiers is None:
+        return None
+    if not isinstance(classifiers, (list, tuple)):
+        warn('The value passed to setup(classifiers=...) in'
+             f' {file_name(filename)} is not a list')
+        return None
+    new_classifiers = update_classifiers(classifiers, new_versions)
+    return update_setup_py_keyword(filename, 'classifiers', new_classifiers)
+
+
+def update_python_requires(
+    filename: FileOrFilename,
+    new_versions: SortedVersionList,
+) -> Optional[FileLines]:
+    """Update python_requires in a setup.py, if it's defined there.
+
+    Does not touch the file but returns a list of lines with new file contents.
+    """
+    python_requires = get_setup_py_keyword(filename, 'python_requires')
+    if not isinstance(python_requires, str):
+        return None
+    style = detect_style(python_requires)
+    new_python_requires = compute_python_requires(new_versions, **style)
+    if is_file_object(filename):
+        # Make sure we can read it twice please.
+        # XXX: I don't like this.
+        cast(TextIO, filename).seek(0)
+    return update_setup_py_keyword(filename, 'python_requires',
+                                   new_python_requires)
+
+
+def get_setup_py_keyword(
+    setup_py: FileOrFilename,
+    keyword: str,
+) -> Optional[AstValue]:
+    """Extract a value passed to setup() in a setup.py.
+
+    Parses the setup.py into an Abstact Syntax Tree and tries to figure out
+    what value was passed to the named keyword argument.
+
+    Returns None if the AST is too complicated to statically evaluate.
+    """
+    with open_file(setup_py) as f:
+        try:
+            tree = ast.parse(f.read(), f.name)
+        except SyntaxError as error:
+            warn(f'Could not parse {f.name}: {error}')
+            return None
+    node = find_call_kwarg_in_ast(tree, ('setup', 'setuptools.setup'), keyword,
+                                  filename=f.name)
+    if node is None:
+        return None
+    return eval_ast_node(node, keyword, filename=f.name)
+
+
+def update_setup_py_keyword(
+    setup_py: FileOrFilename,
+    keyword: str,
+    new_value: Union[str, List[str]],
+) -> FileLines:
+    """Update a value passed to setup() in a setup.py.
+
+    Does not touch the file but returns a list of lines with new file contents.
+    """
+    with open_file(setup_py) as f:
+        lines = f.readlines()
+    new_lines = update_call_arg_in_source(lines, ('setup', 'setuptools.setup'),
+                                          keyword, new_value, filename=f.name)
+    return new_lines
+
+
+def find_python() -> str:
+    """Find a Python interpreter."""
+    # The reason I prefer python3 or python from $PATH over sys.executable is
+    # this gives the user some control.  E.g. if the setup.py of the project
+    # requires some dependencies, the user could install them into a virtualenv
+    # and activate it.
+    if shutil.which('python3'):
+        return 'python3'
+    if shutil.which('python'):
+        return 'python'
+    return sys.executable
+
+
+SetupClassifiers = Source(
+    title=SETUP_PY,
+    filename=SETUP_PY,
+    extract=get_supported_python_versions,
+    update=update_supported_python_versions,
+    check_pypy_consistency=True,
+    has_upper_bound=True,
+)
+
+SetupPythonRequires = Source(
+    title='- python_requires',
+    filename=SETUP_PY,
+    extract=get_python_requires,
+    update=update_python_requires,
+    check_pypy_consistency=False,
+    has_upper_bound=False,  # TBH it might have one!
+)

check_python_versions/sources/tox.py

@@ -0,0 +1,265 @@
+"""
+Support for Tox.
+
+Tox is an amazing tool for running tests (and other tasks) in virtualenvs.
+You create a ``tox.ini``, tell it what Python versions you want to support
+and how to run your test suite, and Tox does everything else: create the
+right virtualenvs using the right Python interpreter versions, install your
+packages, and run the test commands you specified.
+
+The list of supported Python versions is extracted from ::
+
+    [tox]
+    envlist = py27,py36,py37,py38
+
+"""
+
+import configparser
+import re
+from typing import Iterable, List, Optional
+
+from .base import Source
+from ..parsers.ini import update_ini_setting
+from ..utils import FileLines, FileOrFilename, open_file, warn
+from ..versions import SortedVersionList, Version, VersionList
+
+
+TOX_INI = 'tox.ini'
+
+
+def get_tox_ini_python_versions(
+    filename: FileOrFilename = TOX_INI,
+) -> SortedVersionList:
+    """Extract supported Python versions from tox.ini."""
+    conf = configparser.ConfigParser()
+    try:
+        with open_file(filename) as fp:
+            conf.read_file(fp)
+        if conf.has_option('tox', 'env_list'):
+            envlist = conf.get('tox', 'env_list')
+        else:
+            envlist = conf.get('tox', 'envlist')
+    except configparser.Error:
+        return []
+    return sorted({
+        e for e in map(tox_env_to_py_version, parse_envlist(envlist)) if e
+    })
+
+
+def split_envlist(envlist: str) -> Iterable[str]:
+    """Split an environment list into items.
+
+    Tox allows commas or whitespace as separators.
+
+    The trick is that commas inside {...} brace groups do not count.
+
+    This function does not expand brace groups.
+    """
+    for part in re.split(r'((?:[{][^}]*[}]|[^,{\s])+)|,|\s+', envlist):
+        # NB: part can be None
+        part = (part or '').strip()
+        if part:
+            yield part
+
+
+def parse_envlist(envlist: str) -> List[str]:
+    """Parse an environment list.
+
+    This function expands brace groups.
+    """
+    envs = []
+    for part in split_envlist(envlist):
+        envs += brace_expand(part)
+    return envs
+
+
+def brace_expand(s: str) -> List[str]:
+    """Expand a braced group.
+
+    E.g. brace_expand('a{1,2}{b,c}x') == ['a1bx', 'a1cx', 'a2bx', 'a2cx'].
+
+    Note that this function doesn't support nested brace groups.  I'm not sure
+    Tox supports them.
+    """
+    m = re.match('^([^{]*)[{]([^}]*)[}](.*)$', s)
+    if not m:
+        return [s]
+    left = m.group(1)
+    right = m.group(3)
+    res = []
+    for alt in m.group(2).split(','):
+        res += brace_expand(left + alt.strip() + right)
+    return res
+
+
+def tox_env_to_py_version(env: str) -> Optional[Version]:
+    """Convert a Tox environment name to a Python version.
+
+    E.g. py34 becomes '3.4', pypy3 becomes 'PyPy3'.
+
+    Unrecognized environments are left alone.
+
+    If the environment name has dashes, only the first part is considered,
+    e.g. py34-django20 becomes '3.4', and jython-docs becomes 'jython'.
+    """
+    if '-' in env:
+        # e.g. py34-coverage, pypy-subunit
+        env = env.partition('-')[0]
+    if env.startswith('pypy'):
+        return Version.from_string('PyPy' + env[4:])
+    elif env.startswith('py') and len(env) >= 4 and env[2:].isdigit():
+        return Version.from_string(f'{env[2]}.{env[3:]}')
+    else:
+        return None
+
+
+def update_tox_ini_python_versions(
+    filename: FileOrFilename,
+    new_versions: SortedVersionList,
+) -> FileLines:
+    """Update supported Python versions in tox.ini.
+
+    Does not touch the file but returns a list of lines with new file contents.
+    """
+    with open_file(filename) as fp:
+        orig_lines = fp.readlines()
+        fp.seek(0)
+        conf = configparser.ConfigParser()
+        try:
+            conf.read_file(fp)
+            if conf.has_option('tox', 'env_list'):
+                conf_name = 'env_list'
+            else:
+                conf_name = 'envlist'
+            envlist = conf.get('tox', conf_name)
+        except configparser.Error as error:
+            warn(f"Could not parse {fp.name}: {error}")
+            return orig_lines
+
+    new_envlist = update_tox_envlist(envlist, new_versions)
+
+    new_lines = update_ini_setting(
+        orig_lines, 'tox', conf_name, new_envlist, filename=fp.name,
+    )
+    return new_lines
+
+
+def update_tox_envlist(envlist: str, new_versions: SortedVersionList) -> str:
+    """Update an environment list.
+
+    Makes sure all Python versions from ``new_versions`` are in the list.
+    Removes all Python versions not in ``new_versions``.  Leaves other
+    environments (e.g. flake8, docs) alone.
+
+    Tries to preserve formatting and braced groups.
+    """
+    # Find a comma outside brace groups and see what whitespace follows it
+    # (also note that items can be separated with whitespace without a comma,
+    # but the only whitespace used this way I've seen in the wild was newlines)
+    m = re.search(r',\s*|\n', re.sub(r'[{][^}]*[}]', '', envlist.strip()))
+    if m:
+        sep = m.group()
+    else:
+        sep = ','
+
+    trailing_comma = envlist.rstrip().endswith(',')
+
+    new_envs = [
+        toxenv_for_version(ver)
+        for ver in new_versions
+    ]
+
+    if 'py{' in envlist or '{py' in envlist:
+        # Try to preserve braced groups
+        parts = []
+        added_vers = False
+        for part in split_envlist(envlist):
+            m = re.match(
+                r'(py[{](?:\d+|py\d*)(?:,(?:\d+|py\d*))*[}])(?P<rest>.*)',
+                part
+            )
+            if m:
+                keep = [env for env in brace_expand(m.group(1))
+                        if should_keep(env, new_versions)]
+                parts.append(
+                    'py{' + ','.join(
+                        env[len('py'):] for env in new_envs + keep
+                    ) + '}' + m.group('rest')
+                )
+                added_vers = True
+                continue
+            m = re.match(
+                r'([{]py(?:\d+|py\d*)(?:,py(?:\d+|py\d*))*[}])(?P<rest>.*)',
+                part
+            )
+            if m:
+                keep = [env for env in brace_expand(m.group(1))
+                        if should_keep(env, new_versions)]
+                parts.append(
+                    '{' + ','.join(new_envs + keep) + '}' + m.group('rest')
+                )
+                added_vers = True
+                continue
+            vers = brace_expand(part)
+            if all(not should_keep(ver, new_versions) for ver in vers):
+                continue
+            if not all(should_keep(ver, new_versions) for ver in vers):
+                parts.append(sep.join(
+                    ver for ver in vers if should_keep(ver, new_versions)
+                ))
+                continue
+            parts.append(part)
+        if not added_vers:
+            parts = new_envs + parts
+        return sep.join(parts)
+
+    # Universal expansion, might destroy braced groups
+    keep_before: List[str] = []
+    keep_after: List[str] = []
+    keep = keep_before
+    for env in parse_envlist(envlist):
+        if should_keep(env, new_versions):
+            keep.append(env)
+        else:
+            keep = keep_after
+    new_envlist = sep.join(keep_before + new_envs + keep_after)
+    if trailing_comma:
+        new_envlist += ','
+    return new_envlist
+
+
+def toxenv_for_version(ver: Version) -> str:
+    """Compute a tox environment name for a Python version."""
+    return f"py{ver.major}{ver.minor if ver.minor >= 0 else ''}"
+
+
+def should_keep(env: str, new_versions: VersionList) -> bool:
+    """Check if a tox environment needs to be kept.
+
+    Any environments that refer to a specific Python version not in
+    ``new_versions`` will be removed.  All other environments are kept.
+
+    ``pypy`` and ``pypy3`` are kept only if there's at least one Python 2.x
+    or 3.x version respectively in ``new_versions``.
+
+    """
+    if not re.match(r'py(py)?\d*($|-)', env):
+        return True
+    if env == 'pypy':
+        return any(ver.major == 2 for ver in new_versions)
+    if env == 'pypy3':
+        return any(ver.major == 3 for ver in new_versions)
+    if '-' in env:
+        baseversion = tox_env_to_py_version(env)
+        if baseversion in new_versions:
+            return True
+    return False
+
+
+Tox = Source(
+    filename=TOX_INI,
+    extract=get_tox_ini_python_versions,
+    update=update_tox_ini_python_versions,
+    check_pypy_consistency=True,
+    has_upper_bound=True,
+)

check_python_versions/sources/travis.py

@@ -0,0 +1,213 @@
+"""
+Support for Travis CI.
+
+Travis CI is a hosted Continuous Integration solution that can be configured
+by dropping a file named ``.travis.yml`` into your source repository.
+
+There are multiple ways of selecting Python versions, some more canonical
+than others:
+
+- via the top-level ``python`` list
+- via ``python`` attributes in the jobs defined by ``jobs.include`` or its
+  deprecated alias ``matrix.include``
+- via ``TOXENV`` environment variables in the top-level ``env`` list
+  (this is discouraged and check-python-versions might drop support for this in
+  the future)
+"""
+
+from typing import Dict, List, Union
+
+import yaml
+
+from .base import Source
+from .tox import parse_envlist, tox_env_to_py_version
+from ..parsers.yaml import drop_yaml_node, quote_string, update_yaml_list
+from ..utils import FileLines, FileOrFilename, open_file
+from ..versions import SortedVersionList, Version, is_important
+
+
+TRAVIS_YML = '.travis.yml'
+
+
+# Back in the day you could do
+#
+#   dist: trusty
+#   python:
+#     - pypy
+#     - pypy3
+#
+# but then xenial came out and it did not recognize 'pypy' or 'pypy3', instead
+# requiring you to explicitly spell out full version numbers like
+#
+#   dist: trusty
+#   python:
+#     - pypy2.7-6.0.0
+#     - pypy3.5-6.0.0
+#
+# and check-python-versions could upgrade your .travis.yml from the old version
+# to the new.  Happily, this is no longer necessary, because Travis supports
+# 'pypy' and 'pypy3' once again.
+XENIAL_SUPPORTED_PYPY_VERSIONS: Dict[str, str] = {
+    # e.g. 'pypy': 'pypy2.7-7.1.1',
+}
+
+
+def get_travis_yml_python_versions(
+    filename: FileOrFilename = TRAVIS_YML,
+) -> SortedVersionList:
+    """Extract supported Python versions from .travis.yml."""
+    with open_file(filename) as fp:
+        conf = yaml.safe_load(fp)
+    versions: List[Version] = []
+    if conf.get('python'):
+        if isinstance(conf['python'], list):
+            versions += map(travis_normalize_py_version, conf['python'])
+        else:
+            versions.append(travis_normalize_py_version(conf['python']))
+    if 'matrix' in conf and 'include' in conf['matrix']:
+        for job in conf['matrix']['include']:
+            if 'python' in job:
+                versions.append(travis_normalize_py_version(job['python']))
+    if 'jobs' in conf and 'include' in conf['jobs']:
+        for job in conf['jobs']['include']:
+            if 'python' in job:
+                versions.append(travis_normalize_py_version(job['python']))
+    if 'env' in conf:
+        toxenvs = []
+        for env in conf['env']:
+            if env.startswith('TOXENV='):
+                toxenvs.extend(parse_envlist(env.partition('=')[-1]))
+        versions.extend(e for e in map(tox_env_to_py_version, toxenvs) if e)
+    return sorted(set(versions))
+
+
+def travis_normalize_py_version(v: Union[str, float]) -> Version:
+    """Determine Python version from Travis ``python`` value."""
+    v = str(v)
+    if v.startswith('pypy3'):
+        # could be pypy3, pypy3.5, pypy3.5-5.10.0
+        return Version.from_string('PyPy3')
+    elif v.startswith('pypy'):
+        # could be pypy, pypy2, pypy2.7, pypy2.7-5.10.0
+        return Version.from_string('PyPy')
+    else:
+        return Version.from_string(v)
+
+
+def needs_xenial(v: Version) -> bool:
+    """Check if a Python version needs dist: xenial.
+
+    This is obsolete now that dist: xenial is the default, but it may
+    be helpful to determine when we need to drop old dist: trusty.
+    """
+    return v >= Version(major=3, minor=7)
+
+
+def update_travis_yml_python_versions(
+    filename: FileOrFilename,
+    new_versions: SortedVersionList,
+) -> FileLines:
+    """Update supported Python versions in .travis.yml.
+
+    Does not touch the file but returns a list of lines with new file contents.
+    """
+    with open_file(filename) as fp:
+        orig_lines = fp.readlines()
+        fp.seek(0)
+        conf = yaml.safe_load(fp)
+    new_lines = orig_lines
+
+    # Make sure we're using dist: xenial if we want to use Python 3.7 or newer.
+    replacements = {}
+    if any(map(needs_xenial, new_versions)):
+        replacements.update(XENIAL_SUPPORTED_PYPY_VERSIONS)
+        if conf.get('dist') == 'trusty':
+            new_lines = drop_yaml_node(new_lines, 'dist', filename=fp.name)
+        if conf.get('sudo') is False:
+            # sudo is ignored nowadays, but in earlier times
+            # you needed both dist: xenial and sudo: required
+            # to get Python 3.7
+            new_lines = drop_yaml_node(new_lines, "sudo", filename=fp.name)
+
+    def keep_old(value: str) -> bool:
+        """Determine if a Python version line should be preserved."""
+        ver = travis_normalize_py_version(value)
+        if ver == Version.from_string('PyPy'):
+            return any(v.major == 2 for v in new_versions)
+        if ver == Version.from_string('PyPy3'):
+            return any(v.major == 3 for v in new_versions)
+        return not is_important(ver)
+
+    def keep_old_job(job: str) -> bool:
+        """Determine if a job line should be preserved."""
+        if job.startswith('python:'):
+            ver = job[len('python:'):].strip()
+            return not is_important(travis_normalize_py_version(ver))
+        else:
+            return True
+
+    quote_style = ''
+    old_versions = conf.get('python', [])
+    if isinstance(old_versions, (str, int, float)):
+        old_versions = [old_versions]
+    for toplevel in 'matrix', 'jobs':
+        for job in conf.get(toplevel, {}).get('include', []):
+            if 'python' in job:
+                old_versions.append(job['python'])
+    if old_versions and all(isinstance(v, str) for v in old_versions):
+        quote_style = '"'
+
+    yaml_new_versions = [
+        quote_string(str(v), quote_style)
+        for v in new_versions
+    ]
+
+    if conf.get('python'):
+        new_lines = update_yaml_list(
+            new_lines, "python", yaml_new_versions, filename=fp.name,
+            keep=keep_old,
+            replacements=replacements,
+        )
+    else:
+        replacements = {
+            f'python: {k}': f'python: {v}'
+            for k, v in replacements.items()
+        }
+        for toplevel in 'matrix', 'jobs':
+            if 'include' not in conf.get(toplevel, {}):
+                continue
+            new_jobs = [
+                f'python: {ver}'
+                for ver in yaml_new_versions
+            ]
+            new_lines = update_yaml_list(
+                new_lines, (toplevel, "include"), new_jobs, filename=fp.name,
+                replacements=replacements, keep=keep_old_job,
+            )
+
+    # If python 3.7 was enabled via matrix.include, we've just added a
+    # second 3.7 entry directly to top-level python by the above code.
+    # So let's drop the matrix.
+
+    if (
+        conf.get('python')
+            and 'include' in conf.get('matrix', {})
+            and all(
+                job.get('dist') == 'xenial'
+                and set(job) <= {'python', 'dist', 'sudo'}
+                for job in conf['matrix']['include']
+            )
+    ):
+        # XXX: this may drop too much or too little!
+        new_lines = drop_yaml_node(new_lines, "matrix", filename=fp.name)
+
+    return new_lines
+
+
+Travis = Source(
+    filename=TRAVIS_YML,
+    extract=get_travis_yml_python_versions,
+    update=update_travis_yml_python_versions,
+    check_pypy_consistency=True,
+    has_upper_bound=True,
+)