github_releases.py

#!/usr/bin/env python3
"""
This script fetches all releases from a GitHub repository starting from a given date,
differentiates between full releases and pre-releases (alpha, beta, etc.) according to
semantic versioning, filters by an optional package name, and saves the release tag and date pairs to a file.
"""

import argparse
import logging
import requests
import sys
import datetime
from urllib.parse import urlparse
from packaging.version import Version, InvalidVersion


def setup_logging():
 """Sets up the logging configuration."""
 logging.basicConfig(
 level=logging.DEBUG, # Set to DEBUG for detailed output
 format='%(asctime)s - %(levelname)s - %(message)s'
 )


def parse_arguments():
 """
 Parses command-line arguments.

 Returns:
 tuple: GitHub repository URL, start date, output file name, package name, API token, include_prereleases.
 """
 parser = argparse.ArgumentParser(description='Fetch GitHub repository releases.')
 parser.add_argument('repo_url', help='GitHub repository URL')
 parser.add_argument('start_date', help='Start date in YYYY-MM-DD format')
 parser.add_argument(
 '-o', '--output', help='Output file name'
 )
 parser.add_argument(
 '-p', '--package-name', help='Package name to filter releases', default=None
 )
 parser.add_argument(
 '-t', '--token', help='GitHub Personal Access Token', default=None
 )
 parser.add_argument(
 '--include-prereleases', action='store_true',
 help='Include pre-releases in the output'
 )
 args = parser.parse_args()
 return (
 args.repo_url, args.start_date, args.output,
 args.package_name, args.token, args.include_prereleases
 )


def parse_github_url(repo_url):
 """
 Parses the GitHub repository URL to extract the owner and repository name.

 Args:
 repo_url (str): The GitHub repository URL.

 Returns:
 tuple: Owner and repository name.
 """
 try:
 parsed_url = urlparse(repo_url)
 path_parts = parsed_url.path.strip('/').split('/')
 if len(path_parts) >= 2:
 owner = path_parts[0]
 repo = path_parts[1]
 return owner, repo
 else:
 logging.error('Invalid GitHub repository URL.')
 sys.exit(1)
 except Exception as e:
 logging.error(f'Error parsing GitHub URL: {e}')
 sys.exit(1)


def fetch_releases(owner, repo, token=None):
 """
 Fetches all releases from the GitHub API.

 Args:
 owner (str): Repository owner.
 repo (str): Repository name.
 token (str): GitHub Personal Access Token.

 Returns:
 list: List of releases.
 """
 releases = []
 page = 1
 per_page = 100
 headers = {'Accept': 'application/vnd.github.v3+json'}
 if token:
 headers['Authorization'] = f'token {token}'

 while True:
 try:
 url = f'https://api.github.com/repos/{owner}/{repo}/releases?page={page}&per_page={per_page}'
 logging.info(f'Fetching releases from {url}')
 response = requests.get(url, headers=headers)
 response.raise_for_status()
 page_releases = response.json()
 if not page_releases:
 break
 releases.extend(page_releases)
 page += 1
 except requests.exceptions.RequestException as e:
 logging.error(f'Error fetching releases: {e}')
 sys.exit(1)
 return releases


def extract_version(tag_name, package_name=None):
 """
 Extracts the version number from a tag name.

 Args:
 tag_name (str): The tag name.
 package_name (str): The package name to filter.

 Returns:
 Version or None: Parsed Version object or None if invalid.
 """
 try:
 if package_name:
 expected_prefix = f"{package_name}=="
 if tag_name.startswith(expected_prefix):
 version_str = tag_name[len(expected_prefix):]
 else:
 logging.debug(f"Tag '{tag_name}' does not match package name '{package_name}'")
 return None
 else:
 # No package_name specified
 version_str = tag_name

 # Remove any leading 'v' from version string
 if version_str.startswith('v'):
 version_str = version_str[1:]

 version = Version(version_str)
 return version
 except InvalidVersion as e:
 logging.debug(f"Invalid version '{tag_name}': {e}")
 return None


def filter_releases(releases, start_date, package_name=None, include_prereleases=False):
 """
 Filters releases based on the start date, package name, and whether they are full releases.

 Args:
 releases (list): List of releases.
 start_date (datetime.date): The start date.
 package_name (str): Package name to filter releases.
 include_prereleases (bool): Whether to include pre-releases.

 Returns:
 list: Filtered list of (tag_name, release_date) tuples.
 """
 filtered_releases = []
 for release in releases:
 try:
 release_date_str = release['published_at']
 release_date = datetime.datetime.strptime(
 release_date_str, '%Y-%m-%dT%H:%M:%SZ'
 ).date()
 if release_date < start_date:
 logging.debug(f"Skipping release '{release['tag_name']}' before start date")
 continue

 tag_name = release['tag_name']
 version = extract_version(tag_name, package_name)
 if version is None:
 continue

 if not include_prereleases and version.is_prerelease:
 logging.debug(f"Skipping pre-release '{tag_name}'")
 continue

 filtered_releases.append((tag_name, release_date))
 except Exception as e:
 logging.error(f'Error processing release {release}: {e}')
 return filtered_releases


def save_to_file(releases, output_file):
 """
 Saves the releases to a file.

 Args:
 releases (list): List of (tag_name, release_date) tuples.
 output_file (str): The output file name.
 """
 try:
 with open(output_file, 'w') as f:
 for tag, date in releases:
 f.write(f'{tag}, {date}\n')
 logging.info(f'Releases saved to {output_file}')
 except Exception as e:
 logging.error(f'Error writing to file {output_file}: {e}')
 sys.exit(1)


def main():
 """Main function."""
 setup_logging()
 try:
 (
 repo_url, start_date_str, output_file,
 package_name, token, include_prereleases
 ) = parse_arguments()
 start_date = datetime.datetime.strptime(start_date_str, '%Y-%m-%d').date()
 owner, repo = parse_github_url(repo_url)
 releases = fetch_releases(owner, repo, token)
 filtered_releases = filter_releases(
 releases, start_date, package_name, include_prereleases
 )
 for tag, date in filtered_releases:
 print(f'{tag}, {date}')
 # Generate output file name if not provided
 if not output_file:
 if package_name:
 output_file = f"{owner}_{repo}_{package_name}_releases.txt"
 else:
 output_file = f"{owner}_{repo}_releases.txt"
 logging.info(f"No output file provided. Using default: {output_file}")
 save_to_file(filtered_releases, output_file)
 except Exception as e:
 logging.error(f'An unexpected error occurred: {e}')
 sys.exit(1)


if __name__ == '__main__':
 main()