find the version of a pypi package at a specific date

requirements_at_date.py

import requests
import argparse
from datetime import datetime


# Function to get the PyPI release data
def get_versions(package_name):
    url = f'https://pypi.org/pypi/{package_name}/json'
    response = requests.get(url)
    if response.status_code == 200:
        try:
            data = response.json()
            return data['releases']
        except:
            pass


# Function to find the version closest to the target date
def get_version_for_date(package_name, target_date):
    releases = get_versions(package_name)
    if releases:
        # Find the release date closest to the target date
        closest_version = None
        for version, release_info in releases.items():
            for release in release_info:
                release_date = release['upload_time']
                release_datetime = datetime.strptime(release_date, "%Y-%m-%dT%H:%M:%S")
                if release_datetime <= target_date:
                    closest_version = version
        return closest_version
    return None


# Function to process the requirements.txt and update it with pinned versions
def update_requirements(input_file, target_date, output_file=None):
    updated_lines = []

    with open(input_file, 'r') as f:
        lines = f.readlines()

    for line in lines:
        package = line.strip()
        if package.startswith("#"):
            continue

        if '==' in package:  # Skip lines that already have versions pinned
            updated_lines.append(line)
        else:
            package = package.split("<")[0].split(">")[0].split("[")[0]
            # Extract package name (in case of extra version specifiers like >, <, etc.)
            package_name = package.split('=')[0].strip()
            version = get_version_for_date(package_name, target_date)
            if version:
                #print(f"{package} -> {package_name}=={version}")
                updated_lines.append(f"{package_name}=={version}\n")
            else:
                print(f"ERROR - Could not find a suitable version for {package_name} on {target_date.strftime('%Y-%m-%d')}")

    # Write the updated requirements to the output file or stdout
    if output_file:
        with open(output_file, 'w') as f:
            f.writelines(updated_lines)
        print(f"Package versions at {target_date} written to {output_file}")
    else:
        print(f"Package versions at {target_date}:\n")
        print("".join(updated_lines))


# Main function to parse arguments and run the update process
def main():
    parser = argparse.ArgumentParser(description="Update requirements.txt with pinned versions based on a target date.")
    parser.add_argument('requirements_file', help="Path to the requirements.txt file")
    parser.add_argument('date', help="Target date in the format YYYY-MM-DD")
    parser.add_argument('--output', help="Optional output file to save updated requirements.txt")

    args = parser.parse_args()

    # Parse the target date from the arguments
    target_date = datetime.strptime(args.date, "%Y-%m-%d")

    # Update the requirements file with pinned versions
    update_requirements(args.requirements_file, target_date, args.output)


if __name__ == '__main__':
    main()

version_at_date.py

import requests
from datetime import datetime

# Function to get the PyPI release data
def get_versions(package_name):
    url = f'https://pypi.org/pypi/{package_name}/json'
    response = requests.get(url)
    if response.status_code == 200:
        data = response.json()
        return data['releases']
    else:
        return None

# Function to find version closest to the target date
def get_version_for_date(package_name, target_date):
    releases = get_versions(package_name)
    if releases:
        # Find the release date closest to the target date
        closest_version = None
        for version, release_info in releases.items():
            for release in release_info:
                release_date = release['upload_time']
                release_datetime = datetime.strptime(release_date, "%Y-%m-%dT%H:%M:%S")
                if release_datetime <= target_date:
                    closest_version = version
        return closest_version
    return None

target_date = datetime(2023, 1, 10)

package_name = "ovos-core"
version = get_version_for_date(package_name, target_date)

if version:
    print(f"Version of {package_name} on {target_date.strftime('%Y-%m-%d')}: {version}")
else:
    print(f"No version found for {package_name} on {target_date.strftime('%Y-%m-%d')}")