pretty-release-notes 1.4.0__py3-none-any.whl

pretty_release_notes/core/execution.py

@@ -0,0 +1,74 @@
+"""Execution strategies for parallel processing."""
+
+import threading
+from abc import ABC, abstractmethod
+from collections.abc import Callable
+from concurrent.futures import ThreadPoolExecutor, as_completed
+from typing import Any
+
+
+class ExecutionStrategy(ABC):
+	"""Abstract strategy for parallel execution."""
+
+	@abstractmethod
+	def execute_parallel(
+		self,
+		tasks: list[Callable[[], Any]],
+	) -> list[Any]:
+		"""Execute tasks in parallel and return results."""
+		pass
+
+
+class ThreadingStrategy(ExecutionStrategy):
+	"""Original threading implementation for backward compatibility."""
+
+	def execute_parallel(
+		self,
+		tasks: list[Callable[[], Any]],
+	) -> list[Any]:
+		threads = []
+		results = [None] * len(tasks)
+
+		def run_task(index: int, task: Callable[[], Any]):
+			results[index] = task()
+
+		for i, task in enumerate(tasks):
+			thread = threading.Thread(target=run_task, args=(i, task))
+			threads.append(thread)
+			thread.start()
+
+		for thread in threads:
+			thread.join()
+
+		return results
+
+
+class ThreadPoolStrategy(ExecutionStrategy):
+	"""Thread pool implementation for better resource management."""
+
+	def __init__(self, max_workers: int = 10):
+		self.max_workers = max_workers
+
+	def execute_parallel(
+		self,
+		tasks: list[Callable[[], Any]],
+	) -> list[Any]:
+		if not tasks:
+			return []
+
+		results = []
+		with ThreadPoolExecutor(max_workers=self.max_workers) as executor:
+			futures = [executor.submit(task) for task in tasks]
+			for future in as_completed(futures):
+				results.append(future.result())
+		return results
+
+
+class SequentialStrategy(ExecutionStrategy):
+	"""Sequential execution for debugging or environments without threading."""
+
+	def execute_parallel(
+		self,
+		tasks: list[Callable[[], Any]],
+	) -> list[Any]:
+		return [task() for task in tasks]

pretty_release_notes/core/interfaces.py

@@ -0,0 +1,35 @@
+from abc import ABC, abstractmethod
+from dataclasses import dataclass
+from typing import Any
+
+
+@dataclass
+class ProgressEvent:
+	type: str  # "info", "success", "error", "markdown"
+	message: str
+	metadata: dict[str, Any] | None = None
+
+
+class ProgressReporter(ABC):
+	@abstractmethod
+	def report(self, event: ProgressEvent) -> None:
+		"""Report a progress event."""
+		pass
+
+
+class NullProgressReporter(ProgressReporter):
+	"""No-op reporter for library usage."""
+
+	def report(self, event: ProgressEvent) -> None:
+		pass
+
+
+class CompositeProgressReporter(ProgressReporter):
+	"""Combine multiple reporters."""
+
+	def __init__(self, reporters: list[ProgressReporter]):
+		self.reporters = reporters
+
+	def report(self, event: ProgressEvent) -> None:
+		for reporter in self.reporters:
+			reporter.report(event)

pretty_release_notes/database.py

@@ -0,0 +1,152 @@
+import sqlite3
+import threading
+from contextlib import contextmanager
+from csv import DictReader, DictWriter
+from pathlib import Path
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+	from .models import Repository
+
+
+class Database:
+	def __init__(self, path: Path):
+		self.path = path
+
+	def get_sentence(self, repository: "Repository", pr_no: str) -> str | None:
+		pass
+
+	def store_sentence(self, repository: "Repository", pr_no: str, sentence: str) -> None:
+		pass
+
+	def delete_sentence(self, repository: "Repository", pr_no: str) -> None:
+		pass
+
+
+class CSVDatabase(Database):
+	columns = ["owner", "repo", "pr_no", "sentence"]
+
+	def get_sentence(self, repository: "Repository", pr_no: str) -> str | None:
+		if not self.path.exists():
+			return None
+
+		sentence = None
+		with open(self.path) as f:
+			reader = DictReader(f, fieldnames=self.columns)
+			for row in reader:
+				if row["owner"] == repository.owner and row["repo"] == repository.name and row["pr_no"] == pr_no:
+					sentence = row["sentence"]
+
+		return sentence
+
+	def store_sentence(self, repository: "Repository", pr_no: str, sentence: str) -> None:
+		write_header = not self.path.exists()
+		with open(self.path, "a") as f:
+			writer = DictWriter(f, self.columns)
+
+			if write_header:
+				writer.writeheader()
+
+			writer.writerow(
+				{
+					"owner": repository.owner,
+					"repo": repository.name,
+					"pr_no": pr_no,
+					"sentence": sentence,
+				}
+			)
+
+	def delete_sentence(self, repository: "Repository", pr_no: str) -> None:
+		with open(self.path) as f:
+			reader = DictReader(f, fieldnames=self.columns)
+			rows = [
+				row
+				for row in reader
+				if row["owner"] != repository.owner or row["repo"] != repository.name or row["pr_no"] != pr_no
+			]
+
+		with open(self.path, "w") as f:
+			writer = DictWriter(f, self.columns)
+			writer.writeheader()
+			writer.writerows(rows)
+
+
+class SQLiteDatabase(Database):
+	"""Thread-safe SQLite database with thread-local connections."""
+
+	def __init__(self, path: Path):
+		self.path = path
+		self._lock = threading.Lock()
+		self._local = threading.local()
+
+	@property
+	def connection(self):
+		"""Thread-local database connection."""
+		if not hasattr(self._local, "conn"):
+			self._local.conn = sqlite3.connect(self.path)
+			self._local.cursor = self._local.conn.cursor()
+			self._create_table()
+		return self._local.conn
+
+	@property
+	def cursor(self):
+		"""Thread-local cursor."""
+		_ = self.connection  # Ensure connection exists
+		return self._local.cursor
+
+	@contextmanager
+	def transaction(self):
+		"""Context manager for transactions with locking."""
+		with self._lock:
+			try:
+				yield self.cursor
+				self.connection.commit()
+			except Exception:
+				self.connection.rollback()
+				raise
+
+	def get_sentence(self, repository: "Repository", pr_no: str) -> str | None:
+		# Read operations don't need locking, just use thread-local connection
+		self.cursor.execute(
+			"SELECT sentence FROM sentences WHERE owner = ? AND repo = ? AND pr_no = ? ORDER BY rowid DESC LIMIT 1",
+			(repository.owner, repository.name, pr_no),
+		)
+		result = self.cursor.fetchone()
+		return result[0] if result else None
+
+	def store_sentence(self, repository: "Repository", pr_no: str, sentence: str) -> None:
+		with self.transaction():
+			self.cursor.execute(
+				"INSERT INTO sentences (owner, repo, pr_no, sentence) VALUES (?, ?, ?, ?)",
+				(repository.owner, repository.name, pr_no, sentence),
+			)
+
+	def delete_sentence(self, repository: "Repository", pr_no: str) -> None:
+		with self.transaction():
+			self.cursor.execute(
+				"DELETE FROM sentences WHERE owner = ? AND repo = ? AND pr_no = ?",
+				(repository.owner, repository.name, pr_no),
+			)
+
+	def _create_table(self):
+		"""Create table and index if they don't exist."""
+		self.cursor.execute("CREATE TABLE IF NOT EXISTS sentences (owner TEXT, repo TEXT, pr_no TEXT, sentence TEXT)")
+		self.cursor.execute("CREATE INDEX IF NOT EXISTS idx_owner_repo_pr_no ON sentences (owner, repo, pr_no)")
+		self.connection.commit()
+
+
+def get_db(db_type: str, db_name: str) -> Database:
+	db_path = Path(db_name)
+
+	# If path is relative (not absolute), use ~/.pretty-release-notes/ as base directory
+	if not db_path.is_absolute():
+		base_dir = Path.home() / ".pretty-release-notes"
+		base_dir.mkdir(parents=True, exist_ok=True)
+		db_path = base_dir / db_name
+
+	if db_type == "csv":
+		return CSVDatabase(db_path.with_suffix(".csv"))
+	elif db_type == "sqlite":
+		return SQLiteDatabase(db_path.with_suffix(".sqlite"))
+	else:
+		raise ValueError(f"Invalid database type: {db_type}")

pretty_release_notes/generator.py

@@ -0,0 +1,317 @@
+import time
+from collections.abc import Callable
+from functools import partial
+from typing import Any, cast
+
+from requests import HTTPError
+
+from .core.config import ReleaseNotesConfig
+from .core.execution import ExecutionStrategy, ThreadPoolStrategy
+from .core.interfaces import NullProgressReporter, ProgressEvent, ProgressReporter
+from .database import get_db
+from .github_client import GitHubClient
+from .models import ReleaseNotes, ReleaseNotesLine, Repository
+from .openai_client import format_model_name, get_chat_response
+
+
+def _unwrap_retry_error(error: Exception) -> Exception:
+	while True:
+		last_attempt = getattr(error, "last_attempt", None)
+		exception_getter = cast(Callable[[], object] | None, getattr(last_attempt, "exception", None))
+		if exception_getter is None:
+			return error
+		last_exception: object = exception_getter()
+		if not isinstance(last_exception, Exception) or last_exception is error:
+			return error
+		error = last_exception
+
+
+def _format_error(error: Exception) -> str:
+	unwrapped_error = _unwrap_retry_error(error)
+	error_message = str(unwrapped_error).strip()
+	if not error_message:
+		return unwrapped_error.__class__.__name__
+	return f"{unwrapped_error.__class__.__name__}: {error_message}"
+
+
+def _normalize_whitespace(value: str) -> str:
+	return " ".join(value.split())
+
+
+def _describe_change(change: object) -> str:
+	title = getattr(change, "title", None)
+	if isinstance(title, str) and title.strip():
+		pr_id = getattr(change, "id", None)
+		prefix = f"PR #{pr_id}" if pr_id is not None else "PR"
+		return f"{prefix}: {_normalize_whitespace(title)}"
+
+	message = getattr(change, "message", None)
+	if isinstance(message, str) and message.strip():
+		commit_id = getattr(change, "id", None)
+		short_commit_id = str(commit_id)[:7] if commit_id else None
+		prefix = f"Commit {short_commit_id}" if short_commit_id else "Commit"
+		first_line = _normalize_whitespace(message.splitlines()[0])
+		return f"{prefix}: {first_line}"
+
+	html_url = getattr(change, "html_url", None)
+	if isinstance(html_url, str) and html_url.strip():
+		return html_url
+
+	return type(change).__name__
+
+
+class ReleaseNotesGenerator:
+	def __init__(
+		self,
+		config: ReleaseNotesConfig,
+		progress_reporter: ProgressReporter | None = None,
+		execution_strategy: ExecutionStrategy | None = None,
+	):
+		self.config = config
+		self.github = GitHubClient(config.github.token)
+		self.repository: Repository | None = None
+		self.progress = progress_reporter or NullProgressReporter()
+		self.execution = execution_strategy or ThreadPoolStrategy()
+
+		# Store config values for easy access
+		self.exclude_change_types = config.filters.exclude_change_types
+		self.exclude_change_labels = config.filters.exclude_change_labels
+		self.exclude_authors = config.filters.exclude_authors
+		self.grouping = config.grouping
+		self.llm_api_key = config.llm.api_key
+		self.llm_model = config.llm.model
+		self.max_patch_size = config.llm.max_patch_size
+		self.reasoning_effort = config.llm.reasoning_effort
+		self.prompt_path = config.prompt_path
+		self.db_type = config.database.type
+		self.db_name = config.database.name
+		self.db_read_enabled = config.database.read_enabled
+		self.db_write_enabled = config.database.write_enabled
+		self.force_use_commits = config.force_use_commits
+
+	def initialize_repository(self, owner: str, name: str):
+		self.repository = self.github.get_repository(owner, name)
+
+	def generate(self, tag: str, previous_tag_name: str | None = None) -> str:
+		"""Generate release notes for a given tag.
+
+		Args:
+			tag: Git tag for the release
+			previous_tag_name: Optional previous tag to use as starting point
+		"""
+		assert self.repository is not None, "Repository must be initialized before generating release notes"
+		release = self._get_release(tag)
+		old_body = release["body"]
+
+		self.progress.report(
+			ProgressEvent(
+				type="release_notes",
+				message=old_body,
+				metadata={"heading": "Current Release Notes"},
+			)
+		)
+
+		if not previous_tag_name:
+			previous_tag_name = get_previous_tag_name(old_body, self.repository)
+
+		try:
+			gh_notes = self.github.generate_release_notes(self.repository, tag, previous_tag_name)
+			new_body = gh_notes["body"]
+			self.progress.report(
+				ProgressEvent(
+					type="release_notes",
+					message=new_body,
+					metadata={"heading": "Regenerated by GitHub"},
+				)
+			)
+		except HTTPError as e:
+			if e.response.status_code not in [403, 404]:
+				raise e
+
+			self.progress.report(
+				ProgressEvent(
+					type="error",
+					message="No permission to regenerate release notes, trying to proceed with old ones.",
+				)
+			)
+			new_body = old_body
+
+		self.progress.report(ProgressEvent(type="markdown", message="# Rewriting ..."))
+
+		release_notes = ReleaseNotes.from_string(new_body)
+		pr_start_time = time.time()
+		self._get_prs_for_lines(release_notes.lines)
+		pr_end_time = time.time()
+		self.progress.report(
+			ProgressEvent(
+				type="success",
+				message=f"Downloaded PRs in {pr_end_time - pr_start_time:.2f} seconds.",
+			)
+		)
+
+		if self.force_use_commits or (
+			not any(line.change for line in release_notes.lines) and "Full Changelog" in new_body
+		):
+			release_notes.lines = self._get_commit_lines(tag, previous_tag_name) + release_notes.lines
+
+		process_start_time = time.time()
+		self._process_lines(release_notes.lines)
+		process_end_time = time.time()
+		self.progress.report(
+			ProgressEvent(
+				type="success",
+				message=f"Processed lines in {process_end_time - process_start_time:.2f} seconds.",
+			)
+		)
+
+		reviewers_start_time = time.time()
+		release_notes.load_reviewers()
+		reviewers_end_time = time.time()
+		self.progress.report(
+			ProgressEvent(
+				type="success",
+				message=f"Loaded reviewers in {reviewers_end_time - reviewers_start_time:.2f} seconds.",
+			)
+		)
+
+		return release_notes.serialize(
+			self.exclude_change_types,
+			self.exclude_change_labels,
+			self.exclude_authors,
+			grouping=self.grouping,
+			model_name=format_model_name(self.llm_model),
+		)
+
+	def _get_prs_for_lines(self, lines: list["ReleaseNotesLine"]) -> None:
+		"""Download info for all PRs in parallel."""
+		tasks: list[Callable[[], Any]] = [
+			partial(self._get_pr_for_line, line) for line in lines if line.pr_no and not line.is_new_contributor
+		]
+
+		if tasks:
+			self.execution.execute_parallel(tasks)
+
+	def _get_pr_for_line(self, line: "ReleaseNotesLine"):
+		"""Download info for a single PR."""
+		assert self.repository is not None, "Repository must be initialized"
+		if line.pr_no and not line.is_new_contributor:
+			line.change = self.github.get_pr(self.repository, line.pr_no)
+
+	def _process_lines(self, lines: list["ReleaseNotesLine"]) -> None:
+		"""Process all lines in parallel."""
+		prompt_template = self.prompt_path.read_text()
+		tasks: list[Callable[[], Any]] = [partial(self._process_line, line, prompt_template) for line in lines]
+		if tasks:
+			self.execution.execute_parallel(tasks)
+
+	def update_on_github(self, new_body: str, tag: str):
+		"""Update release notes on GitHub."""
+		assert self.repository is not None, "Repository must be initialized before updating release notes"
+		release = self._get_release(tag)
+		try:
+			self.github.update_release(self.repository, release["id"], new_body)
+			self.progress.report(ProgressEvent(type="success", message="Release notes updated successfully."))
+		except HTTPError as e:
+			if e.response.status_code != 403:
+				raise e
+
+			self.progress.report(
+				ProgressEvent(
+					type="error",
+					message="No permission to update release notes, skipping.",
+				)
+			)
+
+	def _get_commit_lines(self, tag: str, previous_tag_name: str | None = None):
+		assert self.repository is not None, "Repository must be initialized"
+		if previous_tag_name:
+			commits = self.github.get_diff_commits(self.repository, tag, previous_tag_name)
+		else:
+			commits = self.github.get_tag_commits(self.repository, tag)
+
+		return (
+			[
+				# Add the same heading line for the commits, that is automatically added by GitHub for PRs
+				ReleaseNotesLine(
+					original_line="## What's Changed",
+				)
+			]
+			+ [
+				ReleaseNotesLine(
+					original_line="",
+					change=commit,
+				)
+				for commit in commits
+			]
+			+ [
+				# Add an empty line to separate commits from full changelog
+				ReleaseNotesLine(
+					original_line="",
+				)
+			]
+		)
+
+	def _process_line(self, line: "ReleaseNotesLine", prompt_template: str):
+		assert self.repository is not None, "Repository must be initialized"
+		needs_db = self.db_read_enabled or self.db_write_enabled
+		db = get_db(self.db_type, self.db_name) if needs_db else None
+
+		if not line.change or line.is_new_contributor:
+			self.progress.report(ProgressEvent(type="markdown", message=str(line)))
+			return
+
+		if line.change.conventional_type in self.exclude_change_types:
+			return
+
+		if line.change.labels and line.change.labels & self.exclude_change_labels:
+			return
+
+		change_id = line.change.get_summary_key()
+		if db and self.db_read_enabled:
+			stored_sentence = db.get_sentence(self.repository, change_id)
+			if stored_sentence:
+				line.sentence = stored_sentence
+				self.progress.report(ProgressEvent(type="markdown", message=str(line)))
+				return
+
+		prompt = line.change.get_prompt(
+			prompt_template=prompt_template,
+			max_patch_size=self.max_patch_size,
+		)
+
+		try:
+			change_summary = get_chat_response(
+				content=prompt,
+				model=self.llm_model,
+				api_key=self.llm_api_key,
+				reasoning_effort=self.reasoning_effort,
+			)
+		except Exception as e:
+			error_msg = (
+				f"LLM API error ({format_model_name(self.llm_model)}) "
+				f"for {_describe_change(line.change)}: {_format_error(e)}"
+			)
+			self.progress.report(ProgressEvent(type="error", message=error_msg))
+			return
+
+		if not change_summary:
+			return
+
+		change_summary = change_summary.lstrip(" -")
+		if db and self.db_write_enabled:
+			db.store_sentence(self.repository, change_id, change_summary)
+		line.sentence = change_summary
+		self.progress.report(ProgressEvent(type="markdown", message=str(line)))
+
+	def _get_release(self, tag: str):
+		assert self.repository is not None, "Repository must be initialized"
+		return self.github.get_release(self.repository, tag)
+
+
+def get_previous_tag_name(release_notes_body: str, repository: Repository) -> str | None:
+	compare_url = f"https://github.com/{repository.owner}/{repository.name}/compare/"
+	pos = release_notes_body.find(compare_url)
+	if pos != -1:
+		return release_notes_body[pos + len(compare_url) :].split("...")[0]
+
+	return None