proviso 0.0.1__py3-none-any.whl

proviso/__init__.py

@@ -0,0 +1,5 @@
+#
+#
+#
+
+__version__ = '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/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/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

proviso/resolver.py

@@ -0,0 +1,248 @@
+from logging import getLogger
+from operator import attrgetter
+
+import httpx
+from packaging.markers import default_environment
+from packaging.metadata import Metadata
+from packaging.requirements import Requirement
+from packaging.utils import canonicalize_name
+from packaging.version import Version
+from resolvelib import AbstractProvider, BaseReporter
+from resolvelib import Resolver as ResolveLibResolver
+from unearth import PackageFinder, TargetPython
+from unearth.auth import MultiDomainBasicAuth
+
+from .utils import CachingClient, format_python_version_for_markers
+
+log = getLogger('proviso.resolver')
+
+
+class Candidate:
+    """Represents a concrete package version."""
+
+    def __init__(self, name, version, extras=None, dependencies=None):
+        self.name = canonicalize_name(name)
+        self.version = version
+        self.extras = extras or frozenset()
+        self._dependencies = dependencies
+
+    def __repr__(self):
+        return f"Candidate({self.name!r}, {self.version!r})"
+
+    def __eq__(self, other):
+        if not isinstance(other, Candidate):
+            return NotImplemented
+        return (
+            self.name == other.name
+            and self.version == other.version
+            and self.extras == other.extras
+        )
+
+    def __hash__(self):
+        return hash((self.name, self.version, self.extras))
+
+
+class PyPIProvider(AbstractProvider):
+    """Provider that queries PyPI for packages and their dependencies."""
+
+    def __init__(self, session, index_urls, python_version=None):
+        self.session = session
+        self._dependencies_cache = {}
+
+        # Create TargetPython if a specific version is requested
+        target_python = None
+        if python_version:
+            target_python = TargetPython(py_ver=Version(python_version).release)
+
+        # Create PackageFinder with the target Python version
+        self.finder = PackageFinder(
+            session=session, index_urls=index_urls, target_python=target_python
+        )
+
+        # Build environment for marker evaluation
+        if python_version:
+            # Start with default environment and override Python version
+            version_info_dict = format_python_version_for_markers(
+                python_version
+            )
+
+            self.environment = default_environment()
+            self.environment.update(version_info_dict)
+        else:
+            # Use current environment
+            self.environment = None
+
+    def identify(self, requirement_or_candidate):
+        """Return the package name as the identifier."""
+        if isinstance(requirement_or_candidate, Requirement):
+            return canonicalize_name(requirement_or_candidate.name)
+        return requirement_or_candidate.name
+
+    def get_preference(
+        self, identifier, resolutions, candidates, information, backtrack_causes
+    ):
+        """Return preference for resolving this requirement."""
+        # Simpler preference: prefer already resolved packages, then by number of candidates
+        return (
+            identifier not in resolutions,
+            len(list(candidates.get(identifier, []))),
+        )
+
+    def find_matches(self, identifier, requirements, incompatibilities):
+        """Find all candidates that match the given requirements."""
+        # Get all requirements for this identifier
+        reqs = list(requirements.get(identifier, []))
+        if not reqs:
+            return []
+
+        # Use the first requirement to search (they should all have the same name)
+        req = reqs[0]
+
+        log.debug(f'Finding matches for {identifier}: {req}')
+
+        # Find best match using unearth
+        result = self.finder.find_matches(str(req))
+
+        # Get all applicable versions
+        candidates = []
+        for package in result:
+            version = Version(package.version)
+
+            # Check if this version satisfies all requirements
+            if all(version in r.specifier for r in reqs):
+                # Check if it's not in incompatibilities
+                if version not in [
+                    c.version for c in incompatibilities.get(identifier, [])
+                ]:
+                    candidates.append(Candidate(identifier, version))
+
+        # Return candidates sorted by version (newest first)
+        log.debug(f'Found {len(candidates)} candidates for {identifier}')
+        return sorted(candidates, key=attrgetter('version'), reverse=True)
+
+    def is_satisfied_by(self, requirement, candidate):
+        """Check if the candidate satisfies the requirement."""
+        if canonicalize_name(requirement.name) != candidate.name:
+            return False
+        return candidate.version in requirement.specifier
+
+    def get_dependencies(self, candidate):
+        """Get dependencies for a candidate."""
+        cache_key = (candidate.name, candidate.version)
+
+        if cache_key in self._dependencies_cache:
+            log.debug(
+                f'Dependencies cache hit for {candidate.name}=={candidate.version}'
+            )
+            return self._dependencies_cache[cache_key]
+
+        log.debug(
+            f'Getting dependencies for {candidate.name}=={candidate.version}'
+        )
+
+        # Find the package to get its metadata
+        result = self.finder.find_best_match(
+            f"{candidate.name}=={candidate.version}"
+        )
+
+        if not result.best:
+            log.warning(
+                f'No matching package found for {candidate.name}=={candidate.version}'
+            )
+            self._dependencies_cache[cache_key] = []
+            return []
+
+        package = result.best
+
+        # Fetch metadata from dist_info_link if available
+        if package.link.dist_info_link:
+            url = package.link.dist_info_link.url
+
+            # Fetch (session caches if it's a CachingClient)
+            if self.session:
+                response = self.session.get(url)
+            else:
+                response = httpx.get(url)
+
+            # Disable validation to handle metadata version mismatches
+            metadata = Metadata.from_email(response.text, validate=False)
+        else:
+            # Fallback: no metadata available
+            self._dependencies_cache[cache_key] = []
+            return []
+
+        # Extract dependencies from metadata
+        dependencies = []
+        for req in metadata.requires_dist or []:
+            # Evaluate markers for target environment
+            if req.marker is None:
+                # No marker means always included
+                dependencies.append(req)
+            elif self.environment is None:
+                # No custom environment, use default
+                if req.marker.evaluate():
+                    dependencies.append(req)
+            else:
+                # Use custom environment for evaluation
+                if req.marker.evaluate(environment=self.environment):
+                    dependencies.append(req)
+
+        log.debug(
+            f'Found {len(dependencies)} dependencies for {candidate.name}=={candidate.version}'
+        )
+        self._dependencies_cache[cache_key] = dependencies
+        return dependencies
+
+
+class Resolver:
+    """Resolves package dependencies using PyPI."""
+
+    def __init__(self, index_urls=None):
+        """Initialize the resolver.
+
+        Args:
+            index_urls: List of package index URLs. Defaults to PyPI.
+        """
+        if index_urls is None:
+            index_urls = ['https://pypi.org/simple/']
+
+        self.index_urls = index_urls
+
+        # Create cached HTTP client shared across all resolutions
+        self._session = CachingClient()
+        self._session.auth = MultiDomainBasicAuth(index_urls=index_urls)
+
+    def resolve(self, requirements, python_version=None):
+        """Resolve dependencies for the given requirements.
+
+        Args:
+            requirements: List of packaging.requirements.Requirement objects
+            python_version: Target Python version string (e.g., "3.9", "3.10.5").
+                          Defaults to current Python version.
+
+        Returns:
+            Dict mapping package names to metadata dicts with 'version' and 'extras'
+
+        Raises:
+            resolvelib.ResolutionImpossible: If resolution fails
+        """
+        provider = PyPIProvider(
+            session=self._session,
+            index_urls=self.index_urls,
+            python_version=python_version,
+        )
+        reporter = BaseReporter()
+        resolver = ResolveLibResolver(provider, reporter)
+
+        # Resolve
+        result = resolver.resolve(requirements)
+
+        # Convert result to our format
+        resolved = {}
+        for identifier, candidate in result.mapping.items():
+            resolved[identifier] = {
+                'version': str(candidate.version),
+                'extras': list(candidate.extras),
+            }
+
+        return resolved

proviso/utils.py

@@ -0,0 +1,70 @@
+#
+#
+#
+
+from logging import getLogger
+
+import httpx
+from packaging.version import Version
+from unearth.fetchers import DEFAULT_SECURE_ORIGINS
+
+log = getLogger('proviso.utils')
+
+
+class CachingClient(httpx.Client):
+    """httpx.Client wrapper that implements the Fetcher protocol for unearth with caching."""
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self._cache = {}
+
+    def get(self, url, **kwargs):
+        """Override get() to add simple caching."""
+
+        # Create cache key from URL, lots of assumptions here, e.g. headers
+        # don't matter that should hold for our use cases
+        cache_key = url
+
+        # Check memory cache first
+        if cache_key in self._cache:
+            log.debug(f'Cache hit: {url}')
+            return self._cache[cache_key]
+
+        # Not in cache, fetch from network
+        log.debug(f'Cache miss, fetching: {url}')
+        response = super().get(url, **kwargs)
+
+        self._cache[cache_key] = response
+
+        return response
+
+    def get_stream(self, url, *, headers=None):
+        """Required by Fetcher protocol."""
+        return self.stream('GET', url, headers=headers)
+
+    def iter_secure_origins(self):
+        """Required by Fetcher protocol."""
+        yield from DEFAULT_SECURE_ORIGINS
+
+
+def format_python_version_for_markers(version_str):
+    """Format a Python version string for use in marker evaluation.
+
+    Args:
+        version_str: Version string like "3.9", "3.10.5", "3.11.0"
+
+    Returns:
+        Dict with 'python_version' and 'python_full_version' keys
+    """
+    v = Version(version_str)
+
+    # python_version is major.minor (e.g., "3.9")
+    python_version = f"{v.major}.{v.minor}"
+
+    # python_full_version includes patch
+    python_full_version = f"{v.major}.{v.minor}.{v.micro}"
+
+    return {
+        'python_version': python_version,
+        'python_full_version': python_full_version,
+    }

proviso-0.0.1.dist-info/METADATA

@@ -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.dist-info/RECORD

@@ -0,0 +1,12 @@
+proviso/__init__.py,sha256=L-G2-VrPD38RTsYd_nrRZgpBYoInjQDdcoFPGjBTgMw,29
+proviso/builder.py,sha256=mVBRjqsPtN4g_Y4ToyaluBIImZhpT3cPYEgW-ADe06U,850
+proviso/main.py,sha256=Owsdsylcqk9_EpI7Qy3e4Yr_UhKepqlamOU0BbOWy4I,8813
+proviso/python.py,sha256=mBGWBj9VuiZUiyMKPfIK8ddbHm2kvMDleuR4pRzGXU0,1526
+proviso/resolver.py,sha256=4GgXO4lpLUH1qiAJtOqtx9hcr9hJ9Y7PWdXfS3OQ-VA,8812
+proviso/utils.py,sha256=SF1fg__c0Z625FZgZiNB_CY-0n7083TXbrqoBhgDEV8,1925
+proviso-0.0.1.dist-info/licenses/LICENSE,sha256=vWCiWlB3SMjfbIdbGGhJu62IvKEEexHokAa8wFcqJr4,1129
+proviso-0.0.1.dist-info/METADATA,sha256=I7WutP407eMD_Am6bcDbw1nUwoxKWUya94FU4h6cN54,5269
+proviso-0.0.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+proviso-0.0.1.dist-info/entry_points.txt,sha256=vBNf22Y0c7ilXxM19a1jyO-48_Hj3Ro0g4bP5UHqIps,46
+proviso-0.0.1.dist-info/top_level.txt,sha256=TsNb9ftylxJVEPQwv7r2qoxmodkY7ejcx7XX5-PHvKQ,8
+proviso-0.0.1.dist-info/RECORD,,

proviso-0.0.1.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.9.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

proviso-0.0.1.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+proviso = proviso.main:main

proviso-0.0.1.dist-info/licenses/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.dist-info/top_level.txt

@@ -0,0 +1 @@
+proviso