proviso 0.0.1__tar.gz

proviso-0.0.1/LICENSE

@@ -0,0 +1,25 @@
+MIT License
+
+Copyright (c) 2021 Ross McFarland & the octoDNS Maintainers
+Copyright (c) 2017 GitHub, Inc.
+
+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.

proviso-0.0.1/PKG-INFO

@@ -0,0 +1,147 @@
+Metadata-Version: 2.4
+Name: proviso
+Version: 0.0.1
+Summary:  Proviso requirements.txt management
+Home-page: https://github.com/octodns/proviso
+Author: Ross McFarland
+Author-email: rwmcfa1@gmail.com
+License: MIT
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: build>=0.7.0
+Requires-Dist: resolvelib>=1.0.0
+Requires-Dist: setuptools>=40.8.0
+Requires-Dist: unearth>=0.17.0
+Provides-Extra: dev
+Requires-Dist: pytest; extra == "dev"
+Requires-Dist: pytest-cov; extra == "dev"
+Requires-Dist: pytest-network; extra == "dev"
+Requires-Dist: black<26.0.0,>=25.0.0; extra == "dev"
+Requires-Dist: changelet; extra == "dev"
+Requires-Dist: isort>=5.11.5; extra == "dev"
+Requires-Dist: pyflakes>=2.2.0; extra == "dev"
+Requires-Dist: readme_renderer[md]>=26.0; extra == "dev"
+Requires-Dist: twine>=3.4.2; extra == "dev"
+Provides-Extra: test
+Requires-Dist: pytest; extra == "test"
+Requires-Dist: pytest-cov; extra == "test"
+Requires-Dist: pytest-network; extra == "test"
+Dynamic: author
+Dynamic: author-email
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: license
+Dynamic: license-file
+Dynamic: provides-extra
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+## Proviso requirements.txt management
+
+A tool for managing requirements.txt version pinning and updating. Proviso extracts dependencies from your project's setup.py or pyproject.toml, resolves all transitive dependencies using PyPI, and generates a fully pinned requirements.txt file that works across multiple Python versions.
+
+### Installation
+
+#### Command line
+
+```
+pip install proviso
+```
+
+#### requirements.txt/setup.py
+
+Pinning specific versions or SHAs is recommended to avoid unplanned upgrades.
+
+##### Versions
+
+```
+# Start with the latest versions and don't just copy what's here
+proviso==0.0.1
+```
+
+##### SHAs
+
+```
+# Start with the latest/specific versions and don't just copy what's here
+-e git+https://git@github.com/octodns/proviso.git@ec9661f8b335241ae4746eea467a8509205e6a30#egg=proviso
+```
+
+### Usage
+
+#### Basic usage
+
+Generate a requirements.txt for all currently active Python versions:
+
+```bash
+proviso
+```
+
+This will:
+1. Read dependencies from your project's setup.py or pyproject.toml
+2. Resolve all transitive dependencies from PyPI
+3. Generate a requirements.txt with pinned versions that work across all currently active Python versions (queried from endoflife.date)
+
+#### Common options
+
+Generate requirements for specific Python versions:
+
+```bash
+proviso --python-versions 3.10,3.11,3.12
+```
+
+Include specific extras (e.g., dev dependencies):
+
+```bash
+proviso --extras dev,test
+```
+
+Specify a custom output file:
+
+```bash
+proviso --filename requirements-dev.txt
+```
+
+Customize the header comment:
+
+```bash
+proviso --header "# Generated requirements - do not edit"
+```
+
+#### Full command-line reference
+
+```console
+usage: proviso [-h] [--directory DIRECTORY] [--extras EXTRAS] [--python-versions PYTHON_VERSIONS] [--filename FILENAME]
+               [--level {DEBUG,INFO,WARNING,ERROR}] [--header HEADER]
+
+Extract project requirements, resolve dependencies, and manage requirements.txt
+
+options:
+  -h, --help            show this help message and exit
+  --directory DIRECTORY
+                        Project root directory (default: current directory)
+  --extras EXTRAS       Comma-separated list of extras to include (e.g., "dev,test"). Defaults to all defined extras.
+  --python-versions PYTHON_VERSIONS
+                        Comma-separated list of Python versions (e.g., "3.9,3.10,3.11"). Defaults to currently active versions
+                        per endoflife.date.
+  --filename FILENAME   Output filename or path for requirements (default: requirements.txt). If just a filename, will be placed
+                        in --directory; if a path, will be used as-is.
+  --level {DEBUG,INFO,WARNING,ERROR}
+                        Logging level (default: WARNING)
+  --header HEADER       Header comment to place at the top of the requirements file. Use the string "[command line]" to insert the
+                        actual command that was run. (default: "# DO NOT EDIT THIS FILE DIRECTLY - use [command line]")
+```
+
+#### Features
+
+- **Multi-version support**: Generates a single requirements.txt that works across multiple Python versions, using environment markers (e.g., `package==1.0.0; python_version=='3.10'`) when different versions are needed
+- **Complete dependency resolution**: Recursively resolves all transitive dependencies from PyPI
+- **Automatic Python version detection**: Uses endoflife.date API to determine currently active Python versions
+- **Extras support**: Include optional dependency groups (dev, test, etc.) from your setup.py or pyproject.toml
+- **Flexible output**: Generate requirements files with custom names and locations
+
+### Development
+
+See the [/script/](/script/) directory for some tools to help with the development process. They generally follow the [Script to rule them all](https://github.com/github/scripts-to-rule-them-all) pattern. Most useful is `./script/bootstrap` which will create a venv and install both the runtime and development related requirements. It will also hook up a pre-commit hook that covers most of what's run by CI.

proviso-0.0.1/README.md

@@ -0,0 +1,106 @@
+## Proviso requirements.txt management
+
+A tool for managing requirements.txt version pinning and updating. Proviso extracts dependencies from your project's setup.py or pyproject.toml, resolves all transitive dependencies using PyPI, and generates a fully pinned requirements.txt file that works across multiple Python versions.
+
+### Installation
+
+#### Command line
+
+```
+pip install proviso
+```
+
+#### requirements.txt/setup.py
+
+Pinning specific versions or SHAs is recommended to avoid unplanned upgrades.
+
+##### Versions
+
+```
+# Start with the latest versions and don't just copy what's here
+proviso==0.0.1
+```
+
+##### SHAs
+
+```
+# Start with the latest/specific versions and don't just copy what's here
+-e git+https://git@github.com/octodns/proviso.git@ec9661f8b335241ae4746eea467a8509205e6a30#egg=proviso
+```
+
+### Usage
+
+#### Basic usage
+
+Generate a requirements.txt for all currently active Python versions:
+
+```bash
+proviso
+```
+
+This will:
+1. Read dependencies from your project's setup.py or pyproject.toml
+2. Resolve all transitive dependencies from PyPI
+3. Generate a requirements.txt with pinned versions that work across all currently active Python versions (queried from endoflife.date)
+
+#### Common options
+
+Generate requirements for specific Python versions:
+
+```bash
+proviso --python-versions 3.10,3.11,3.12
+```
+
+Include specific extras (e.g., dev dependencies):
+
+```bash
+proviso --extras dev,test
+```
+
+Specify a custom output file:
+
+```bash
+proviso --filename requirements-dev.txt
+```
+
+Customize the header comment:
+
+```bash
+proviso --header "# Generated requirements - do not edit"
+```
+
+#### Full command-line reference
+
+```console
+usage: proviso [-h] [--directory DIRECTORY] [--extras EXTRAS] [--python-versions PYTHON_VERSIONS] [--filename FILENAME]
+               [--level {DEBUG,INFO,WARNING,ERROR}] [--header HEADER]
+
+Extract project requirements, resolve dependencies, and manage requirements.txt
+
+options:
+  -h, --help            show this help message and exit
+  --directory DIRECTORY
+                        Project root directory (default: current directory)
+  --extras EXTRAS       Comma-separated list of extras to include (e.g., "dev,test"). Defaults to all defined extras.
+  --python-versions PYTHON_VERSIONS
+                        Comma-separated list of Python versions (e.g., "3.9,3.10,3.11"). Defaults to currently active versions
+                        per endoflife.date.
+  --filename FILENAME   Output filename or path for requirements (default: requirements.txt). If just a filename, will be placed
+                        in --directory; if a path, will be used as-is.
+  --level {DEBUG,INFO,WARNING,ERROR}
+                        Logging level (default: WARNING)
+  --header HEADER       Header comment to place at the top of the requirements file. Use the string "[command line]" to insert the
+                        actual command that was run. (default: "# DO NOT EDIT THIS FILE DIRECTLY - use [command line]")
+```
+
+#### Features
+
+- **Multi-version support**: Generates a single requirements.txt that works across multiple Python versions, using environment markers (e.g., `package==1.0.0; python_version=='3.10'`) when different versions are needed
+- **Complete dependency resolution**: Recursively resolves all transitive dependencies from PyPI
+- **Automatic Python version detection**: Uses endoflife.date API to determine currently active Python versions
+- **Extras support**: Include optional dependency groups (dev, test, etc.) from your setup.py or pyproject.toml
+- **Flexible output**: Generate requirements files with custom names and locations
+
+### Development
+
+See the [/script/](/script/) directory for some tools to help with the development process. They generally follow the [Script to rule them all](https://github.com/github/scripts-to-rule-them-all) pattern. Most useful is `./script/bootstrap` which will create a venv and install both the runtime and development related requirements. It will also hook up a pre-commit hook that covers most of what's run by CI.

proviso-0.0.1/proviso/__init__.py

@@ -0,0 +1,5 @@
+#
+#
+#
+
+__version__ = '0.0.1'

proviso-0.0.1/proviso/builder.py

@@ -0,0 +1,29 @@
+from functools import cached_property
+from os import environ
+from os.path import join
+from subprocess import run
+from tempfile import TemporaryDirectory
+
+from build import ProjectBuilder
+from packaging.metadata import Metadata
+
+
+def _runner(cmd, cwd=None, extra_environ=None):
+    env = environ.copy()
+    if extra_environ is not None:
+        env.update(extra_environ)
+
+    run(cmd, cwd=cwd, env=env, capture_output=True, check=True)
+
+
+class Builder:
+    def __init__(self, directory):
+        self.directory = directory
+
+    @cached_property
+    def metadata(self):
+        builder = ProjectBuilder(self.directory, runner=_runner)
+        with TemporaryDirectory() as tmpdir:
+            metadata_path = builder.metadata_path(tmpdir)
+            with open(join(metadata_path, 'METADATA')) as f:
+                return Metadata.from_email(f.read())

proviso-0.0.1/proviso/main.py

@@ -0,0 +1,271 @@
+from argparse import ArgumentParser
+from collections import defaultdict
+from logging import DEBUG, ERROR, INFO, WARNING, basicConfig, getLogger
+from os import getcwd
+from os.path import dirname, expanduser, join
+from sys import argv, exit
+
+from build import BuildBackendException
+
+from proviso.builder import Builder
+from proviso.python import Python
+from proviso.resolver import Resolver
+
+log = getLogger('proviso')
+
+
+def build_project_metadata(directory):
+    """Build project metadata and handle exceptions."""
+    builder = Builder(directory)
+    try:
+        return builder.metadata
+    except BuildBackendException as e:
+        cpe = e.exception
+        log.error(
+            f'''Failed to build project.
+
+captured stdout:
+--------------------------------------------------------------------------------
+{cpe.output.decode('utf-8')}
+--------------------------------------------------------------------------------
+captured stderr:
+--------------------------------------------------------------------------------
+{cpe.stderr.decode('utf-8')}
+--------------------------------------------------------------------------------
+'''
+        )
+        exit(1)
+
+
+def format_and_print_metadata(metadata, extras, python_versions):
+    """Format and print project metadata."""
+    log.info(
+        f'Project: {metadata.name} {metadata.version}, '
+        f'extras: {", ".join(extras)}, '
+        f'python_versions: {", ".join(python_versions)}'
+    )
+
+
+def get_requirements_with_extras(metadata, extras):
+    """Get requirements including extras."""
+    requires_dist = metadata.requires_dist or []
+
+    # base runtime direct requirements
+    requirements = [r for r in requires_dist if r.marker is None]
+    for extra in extras:
+        requirements.extend(
+            r
+            for r in requires_dist
+            if r.marker and r.marker.evaluate({'extra': extra})
+        )
+
+    return requirements
+
+
+def find_requirements(requirements, python_versions):
+
+    if not requirements:
+        return {}
+
+    log.info(f'Requirements: {", ".join([str(r) for r in requirements])}')
+
+    # Create one resolver instance (shared cache across all Python versions)
+    resolver = Resolver()
+
+    # Collect versions: versions[package][version] = [python_versions]
+    versions = defaultdict(lambda: defaultdict(list))
+
+    # Resolve for each Python version
+    for python_version in python_versions:
+        log.info(f'Resolving dependencies for Python {python_version}')
+
+        resolved = resolver.resolve(requirements, python_version=python_version)
+
+        log.info(
+            f'Resolved {len(resolved)} dependencies for Python {python_version}'
+        )
+
+        # Accumulate into versions dict
+        for name, info in resolved.items():
+            versions[name][info['version']].append(python_version)
+
+    return versions
+
+
+def write_requirements_to_file(
+    versions, python_versions, filename, header=None
+):
+    """Write resolved requirements to file."""
+    with open(filename, 'w') as fh:  # Changed to 'w' mode for writing
+        if header:
+            fh.write(header)
+            if not header.endswith('\n'):
+                fh.write('\n')
+        for pkg, vers in sorted(versions.items()):
+            for ver, pythons in vers.items():
+                # same pkg ver for all pythons
+                fh.write(pkg)
+                fh.write('==')
+                fh.write(ver)
+                if pythons != python_versions:
+                    fh.write('; ')
+                    for i, python in enumerate(pythons):
+                        if i:
+                            fh.write(' or ')
+                        fh.write("python_version=='")
+                        fh.write(python)
+                        fh.write("'")
+                fh.write('\n')
+
+
+def parse_and_validate_args(metadata, args):
+    """Parse and validate command line arguments.
+
+    Returns a dict with parsed values:
+    - directory: expanded directory path
+    - extras: set of extras to include
+    - python_versions: list of Python versions
+    - output_path: full path for output file
+    - header: header string to write to file
+    """
+    # Expand user path (e.g., ~ -> /home/username)
+    directory = expanduser(args.directory)
+
+    # Parse extras from command line
+    if args.extras is None:
+        extras = metadata.provides_extra
+    else:
+        extras = set(e.strip() for e in args.extras.split(',') if e.strip())
+        # Validate that requested extras exist
+        available_extras = set(metadata.provides_extra)
+        invalid_extras = extras - available_extras
+        if invalid_extras:
+            log.error(
+                f"Invalid extras requested: {', '.join(sorted(invalid_extras))}. "
+                f"Available extras: {', '.join(sorted(available_extras)) if available_extras else 'none'}"
+            )
+            exit(1)
+
+    if args.python_versions is None:
+        # If no python versions specified, use active versions from endoflife.date
+        python = Python()
+        python_versions = [release['cycle'] for release in python.active]
+    else:
+        python_versions = [
+            v.strip() for v in args.python_versions.split(',') if v.strip()
+        ]
+
+    # Determine output path: if filename has a directory component, use as-is;
+    # otherwise place it in the project directory
+    filename = args.filename
+    if dirname(filename):
+        output_path = expanduser(filename)
+    else:
+        output_path = join(directory, filename)
+
+    # Build the header
+    if args.header is None:
+        # Default header
+        command_line = ' '.join(argv)
+        header = f'# DO NOT EDIT THIS FILE DIRECTLY - use {command_line}\n'
+    else:
+        # User-provided header, replace [command line] placeholder
+        command_line = ' '.join(argv)
+        header = args.header.replace('[command line]', command_line)
+        if header and not header.endswith('\n'):
+            header += '\n'
+
+    return {
+        'directory': directory,
+        'extras': extras,
+        'python_versions': python_versions,
+        'output_path': output_path,
+        'header': header,
+    }
+
+
+def main():  # pragma: no cover
+    parser = ArgumentParser(
+        description='Extract project requirements, resolve dependencies, and manage requirements.txt'
+    )
+    parser.add_argument(
+        '--directory',
+        default=getcwd(),
+        help='Project root directory (default: current directory)',
+    )
+    parser.add_argument(
+        '--extras',
+        default=None,
+        help='Comma-separated list of extras to include (e.g., "dev,test"). Defaults to all defined extras.',
+    )
+    parser.add_argument(
+        '--python-versions',
+        default=None,
+        help='Comma-separated list of Python versions (e.g., "3.9,3.10,3.11"). Defaults to currently active versions per endoflife.date.',
+    )
+    parser.add_argument(
+        '--filename',
+        default='requirements.txt',
+        help='Output filename or path for requirements (default: requirements.txt). If just a filename, will be placed in --directory; if a path, will be used as-is.',
+    )
+    level_map = {
+        'DEBUG': DEBUG,
+        'INFO': INFO,
+        'WARNING': WARNING,
+        'ERROR': ERROR,
+        'debug': DEBUG,
+        'info': INFO,
+        'warning': WARNING,
+        'error': ERROR,
+    }
+    parser.add_argument(
+        '--level',
+        default='WARNING',
+        choices=sorted(level_map.keys()),
+        help='Logging level (default: WARNING)',
+    )
+    parser.add_argument(
+        '--header',
+        default=None,
+        help='Header comment to place at the top of the requirements file. Use the string "[command line]" to insert the actual command that was run. (default: "# DO NOT EDIT THIS FILE DIRECTLY - use [command line]")',
+    )
+
+    args = parser.parse_args()
+
+    # Configure logging
+    basicConfig(
+        level=level_map.get(args.level, WARNING),
+        format='%(asctime)s [%(levelname)-8s] %(message)s',
+        datefmt='%Y-%m-%dT%H:%M:%S',
+    )
+
+    # Suppress verbose httpx logging unless we're in DEBUG mode
+    if args.level != 'DEBUG':
+        getLogger('httpx').setLevel(WARNING)
+
+    # Build project metadata
+    metadata = build_project_metadata(args.directory)
+
+    # Parse and validate arguments
+    parsed = parse_and_validate_args(metadata, args)
+
+    format_and_print_metadata(
+        metadata, parsed['extras'], parsed['python_versions']
+    )
+
+    requirements = get_requirements_with_extras(metadata, parsed['extras'])
+
+    versions = find_requirements(
+        requirements, python_versions=parsed['python_versions']
+    )
+
+    write_requirements_to_file(
+        versions,
+        parsed['python_versions'],
+        parsed['output_path'],
+        header=parsed['header'],
+    )
+
+
+if __name__ == '__main__':  # pragma: no cover
+    main()

proviso-0.0.1/proviso/python.py

@@ -0,0 +1,52 @@
+from datetime import date
+from functools import cached_property
+
+import httpx
+
+
+class Python:
+    """Fetches and filters active Python releases from endoflife.date."""
+
+    API_URL = 'https://endoflife.date/api/python.json'
+
+    @cached_property
+    def releases(self):
+        """Fetch all Python release data from endoflife.date API.
+
+        Returns:
+            List of dicts containing release information with fields:
+            - cycle: version string (e.g., "3.12")
+            - releaseDate: ISO date string
+            - eol: end-of-life ISO date string
+            - latest: latest patch version
+            - and other metadata
+        """
+        response = httpx.get(self.API_URL)
+        response.raise_for_status()
+        return response.json()
+
+    @property
+    def active(self):
+        """Return list of active Python releases.
+
+        A release is active if: releaseDate <= today <= eol
+
+        Returns:
+            List of release dicts sorted by version (oldest to newest)
+        """
+        today = date.today()
+        active_releases = []
+
+        for release in self.releases:
+            release_date = date.fromisoformat(release['releaseDate'])
+            eol_date = date.fromisoformat(release['eol'])
+
+            if release_date <= today <= eol_date:
+                active_releases.append(release)
+
+        # Sort by version number (oldest to newest)
+        active_releases.sort(
+            key=lambda r: tuple(map(int, r['cycle'].split('.')))
+        )
+
+        return active_releases