pyASDReader 1.2.2__tar.gz → 1.2.4__tar.gz

{pyasdreader-1.2.2 → pyasdreader-1.2.4}/.codecov.yml

@@ -28,8 +28,6 @@ comment:
   require_head: true
 
 flags:
-  ubuntu-latest-py3.8:
-    carryforward: false
   ubuntu-latest-py3.9:
     carryforward: false
   ubuntu-latest-py3.10:
@@ -38,8 +36,6 @@ flags:
     carryforward: false
   ubuntu-latest-py3.12:
     carryforward: false
-  windows-latest-py3.8:
-    carryforward: false
   windows-latest-py3.9:
     carryforward: false
   windows-latest-py3.10:
@@ -48,8 +44,6 @@ flags:
     carryforward: false
   windows-latest-py3.12:
     carryforward: false
-  macos-latest-py3.8:
-    carryforward: false
   macos-latest-py3.9:
     carryforward: false
   macos-latest-py3.10:

pyasdreader-1.2.4/.pre-commit-hooks/check_changelog_format.py

@@ -0,0 +1,148 @@
+#!/usr/bin/env python3
+"""
+Pre-commit hook to validate CHANGELOG.md format.
+
+Validates that CHANGELOG.md follows the Keep a Changelog format:
+- Has [Unreleased] section
+- Version entries follow format: ## [X.Y.Z] - YYYY-MM-DD
+- Versions are in descending order
+- Uses standard sections (Added, Changed, Fixed, etc.)
+"""
+
+import re
+import sys
+from datetime import datetime
+from pathlib import Path
+
+
+def check_unreleased_section(content):
+    """Check if [Unreleased] section exists."""
+    if not re.search(r'##\s+\[Unreleased\]', content):
+        return False, "[Unreleased] section is missing"
+    return True, None
+
+
+def extract_versions(content):
+    """Extract all version entries from CHANGELOG."""
+    # Match pattern: ## [X.Y.Z] - YYYY-MM-DD
+    pattern = r'##\s+\[(\d+\.\d+\.\d+)\]\s+-\s+(\d{4}-\d{2}-\d{2})'
+    matches = re.findall(pattern, content)
+    return matches
+
+
+def validate_version_format(version):
+    """Validate semantic version format."""
+    pattern = r'^\d+\.\d+\.\d+$'
+    return re.match(pattern, version) is not None
+
+
+def validate_date_format(date_str):
+    """Validate date format (YYYY-MM-DD)."""
+    try:
+        datetime.strptime(date_str, '%Y-%m-%d')
+        return True
+    except ValueError:
+        return False
+
+
+def check_version_order(versions):
+    """Check if versions are in descending order."""
+    version_numbers = [tuple(map(int, v[0].split('.'))) for v in versions]
+
+    for i in range(len(version_numbers) - 1):
+        if version_numbers[i] < version_numbers[i + 1]:
+            return False, f"Version {versions[i][0]} should come before {versions[i+1][0]}"
+
+    return True, None
+
+
+def check_standard_sections(content):
+    """Check if content uses standard Keep a Changelog sections."""
+    standard_sections = [
+        'Added', 'Changed', 'Deprecated', 'Removed',
+        'Fixed', 'Security', 'Technical Improvements'
+    ]
+
+    # Find all section headers (### Section)
+    section_pattern = r'###\s+([A-Za-z\s]+)'
+    found_sections = re.findall(section_pattern, content)
+
+    # Check if non-standard sections are used
+    warnings = []
+    for section in found_sections:
+        section = section.strip()
+        if section not in standard_sections and section != '':
+            warnings.append(f"Non-standard section: '{section}'")
+
+    return warnings
+
+
+def main():
+    """Validate CHANGELOG.md format."""
+    project_root = Path(__file__).parent.parent
+    changelog_path = project_root / 'CHANGELOG.md'
+
+    if not changelog_path.exists():
+        print("CHANGELOG.md not found")
+        return 1
+
+    with open(changelog_path, 'r', encoding='utf-8') as f:
+        content = f.read()
+
+    errors = []
+    warnings = []
+
+    # Check 1: Unreleased section
+    has_unreleased, error = check_unreleased_section(content)
+    if not has_unreleased:
+        errors.append(error)
+
+    # Check 2: Extract and validate version entries
+    versions = extract_versions(content)
+
+    if not versions:
+        errors.append("No version entries found in CHANGELOG.md")
+    else:
+        # Check version format
+        for version, date in versions:
+            if not validate_version_format(version):
+                errors.append(f"Invalid version format: {version}")
+            if not validate_date_format(date):
+                errors.append(f"Invalid date format for version {version}: {date}")
+
+        # Check version order
+        ordered, error = check_version_order(versions)
+        if not ordered:
+            errors.append(error)
+
+    # Check 3: Standard sections (warnings only)
+    section_warnings = check_standard_sections(content)
+    warnings.extend(section_warnings)
+
+    # Print results
+    if errors:
+        print("CHANGELOG.md validation failed")
+        print("\nErrors:")
+        for error in errors:
+            print(f"  - {error}")
+
+        if warnings:
+            print("\nWarnings:")
+            for warning in warnings:
+                print(f"  - {warning}")
+
+        print("\nPlease fix the errors and ensure CHANGELOG.md follows Keep a Changelog format.")
+        print("See: https://keepachangelog.com/en/1.0.0/")
+        return 1
+    else:
+        if warnings:
+            print("CHANGELOG.md validation passed with warnings:")
+            for warning in warnings:
+                print(f"  - {warning}")
+        else:
+            print("CHANGELOG.md validation passed")
+        return 0
+
+
+if __name__ == '__main__':
+    sys.exit(main())

pyasdreader-1.2.4/.pre-commit-hooks/check_commit_message.py

@@ -0,0 +1,127 @@
+#!/usr/bin/env python3
+"""
+Pre-commit hook to validate commit message format.
+
+Validates that commit messages follow Conventional Commits format:
+- type(scope): description
+- Valid types: feat, fix, docs, style, refactor, test, chore, perf, ci, build, revert
+
+Reference: https://www.conventionalcommits.org/
+"""
+
+import re
+import sys
+from pathlib import Path
+
+
+VALID_TYPES = [
+    'feat',      # New feature
+    'fix',       # Bug fix
+    'docs',      # Documentation changes
+    'style',     # Code style changes (formatting, etc.)
+    'refactor',  # Code refactoring
+    'test',      # Adding or updating tests
+    'chore',     # Maintenance tasks
+    'perf',      # Performance improvements
+    'ci',        # CI/CD changes
+    'build',     # Build system changes
+    'revert',    # Revert previous commit
+]
+
+
+def validate_commit_message(message):
+    """
+    Validate commit message format.
+
+    Expected format:
+    - type: description
+    - type(scope): description
+
+    Returns (is_valid, error_message)
+    """
+    lines = message.strip().split('\n')
+    if not lines:
+        return False, "Commit message is empty"
+
+    first_line = lines[0].strip()
+
+    # Check for merge commits (allowed)
+    if first_line.startswith('Merge '):
+        return True, None
+
+    # Check for revert commits (allowed)
+    if first_line.startswith('Revert '):
+        return True, None
+
+    # Pattern 1: type: description
+    # Pattern 2: type(scope): description
+    pattern = r'^(\w+)(\([a-zA-Z0-9_\-/]+\))?: .{3,}'
+
+    match = re.match(pattern, first_line)
+    if not match:
+        return False, (
+            f"Invalid commit message format: '{first_line}'\n"
+            "Expected format: 'type: description' or 'type(scope): description'\n"
+            f"Valid types: {', '.join(VALID_TYPES)}"
+        )
+
+    commit_type = match.group(1)
+    if commit_type not in VALID_TYPES:
+        return False, (
+            f"Invalid commit type: '{commit_type}'\n"
+            f"Valid types: {', '.join(VALID_TYPES)}"
+        )
+
+    # Check description length (at least 3 characters)
+    description_start = first_line.find(':') + 1
+    description = first_line[description_start:].strip()
+    if len(description) < 3:
+        return False, "Commit description too short (minimum 3 characters)"
+
+    # Check first line length (recommended: 72 chars, max: 100)
+    if len(first_line) > 100:
+        return False, f"First line too long ({len(first_line)} chars, max 100)"
+
+    # Check if description starts with capital letter
+    if description and not description[0].isupper():
+        return False, "Commit description should start with a capital letter"
+
+    return True, None
+
+
+def main():
+    """Main function to validate commit message."""
+    # Get commit message file path from arguments
+    if len(sys.argv) < 2:
+        print("Usage: check_commit_message.py <commit-msg-file>")
+        return 0
+
+    commit_msg_file = Path(sys.argv[1])
+
+    if not commit_msg_file.exists():
+        print(f"Error: Commit message file not found: {commit_msg_file}")
+        return 1
+
+    # Read commit message
+    with open(commit_msg_file, 'r', encoding='utf-8') as f:
+        commit_message = f.read()
+
+    # Validate
+    is_valid, error_message = validate_commit_message(commit_message)
+
+    if not is_valid:
+        print("\nCommit message validation failed")
+        print(error_message)
+        print("\nConventional Commits format:")
+        print("  feat: Add new feature")
+        print("  fix: Fix bug in parser")
+        print("  docs: Update README")
+        print("  chore(deps): Update dependencies")
+        print("\nSee: https://www.conventionalcommits.org/")
+        return 1
+
+    return 0
+
+
+if __name__ == '__main__':
+    sys.exit(main())

pyasdreader-1.2.4/.pre-commit-hooks/check_version_consistency.py

@@ -0,0 +1,120 @@
+#!/usr/bin/env python3
+"""
+Pre-commit hook to check version consistency across multiple files.
+
+Ensures that version numbers in CHANGELOG.md, README.md, pyproject.toml,
+and src/_version.py are consistent.
+"""
+
+import re
+import sys
+from pathlib import Path
+
+
+def extract_changelog_version(changelog_path):
+    """Extract the latest version from CHANGELOG.md."""
+    if not changelog_path.exists():
+        return None
+
+    with open(changelog_path, 'r', encoding='utf-8') as f:
+        content = f.read()
+
+    # Match pattern: ## [X.Y.Z] - YYYY-MM-DD
+    match = re.search(r'##\s+\[(\d+\.\d+\.\d+)\]\s+-\s+\d{4}-\d{2}-\d{2}', content)
+    if match:
+        return match.group(1)
+    return None
+
+
+def extract_readme_version(readme_path):
+    """Extract version from README.md citation section."""
+    if not readme_path.exists():
+        return None
+
+    with open(readme_path, 'r', encoding='utf-8') as f:
+        content = f.read()
+
+    # Match pattern: version = {X.Y.Z}
+    match = re.search(r'version\s*=\s*\{(\d+\.\d+\.\d+)\}', content)
+    if match:
+        return match.group(1)
+    return None
+
+
+def extract_pyproject_version(pyproject_path):
+    """Extract fallback_version from pyproject.toml."""
+    if not pyproject_path.exists():
+        return None
+
+    with open(pyproject_path, 'r', encoding='utf-8') as f:
+        content = f.read()
+
+    # Match pattern: fallback_version = "X.Y.Z"
+    match = re.search(r'fallback_version\s*=\s*["\'](\d+\.\d+\.\d+)["\']', content)
+    if match:
+        return match.group(1)
+    return None
+
+
+def extract_version_py_version(version_py_path):
+    """Extract __version__ from src/_version.py."""
+    if not version_py_path.exists():
+        return None
+
+    with open(version_py_path, 'r', encoding='utf-8') as f:
+        content = f.read()
+
+    # Match pattern: __version__ = "X.Y.Z"
+    match = re.search(r'__version__\s*=\s*["\'](\d+\.\d+\.\d+)["\']', content)
+    if match:
+        return match.group(1)
+    return None
+
+
+def main():
+    """Check version consistency across all files."""
+    project_root = Path(__file__).parent.parent
+
+    files = {
+        'CHANGELOG.md': project_root / 'CHANGELOG.md',
+        'README.md': project_root / 'README.md',
+        'pyproject.toml': project_root / 'pyproject.toml',
+        'src/_version.py': project_root / 'src' / '_version.py',
+    }
+
+    # Extract versions
+    versions = {
+        'CHANGELOG.md': extract_changelog_version(files['CHANGELOG.md']),
+        'README.md': extract_readme_version(files['README.md']),
+        'pyproject.toml': extract_pyproject_version(files['pyproject.toml']),
+        'src/_version.py': extract_version_py_version(files['src/_version.py']),
+    }
+
+    # Filter out None values
+    valid_versions = {k: v for k, v in versions.items() if v is not None}
+
+    if not valid_versions:
+        print("Warning: Could not extract version from any file")
+        return 0
+
+    # Check consistency
+    unique_versions = set(valid_versions.values())
+
+    if len(unique_versions) == 1:
+        print(f"✓ Version consistency check passed: {unique_versions.pop()}")
+        return 0
+    else:
+        print("✗ Version inconsistency detected!")
+        print("\nVersions found:")
+        for file, version in sorted(valid_versions.items()):
+            print(f"  {file:20} -> {version}")
+
+        print("\nPlease ensure all version numbers are consistent before committing.")
+        print("Expected version (from CHANGELOG.md): {}".format(
+            versions.get('CHANGELOG.md', 'NOT FOUND')
+        ))
+        return 1
+
+
+if __name__ == '__main__':
+    sys.exit(main())

{pyasdreader-1.2.2 → pyasdreader-1.2.4}/CHANGELOG.md

@@ -13,6 +13,53 @@ This project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.htm
 
 ## [Unreleased]
 
+## [1.2.4] - 2026-09-18
+
+### Added
+- 📚 **Documentation Improvements** - Expanded user and maintainer documentation, including Sphinx/Read the Docs configuration and corrected documentation links.
+
+### Changed
+- 🐍 **Python Version Support** - Updated the minimum supported Python version to 3.9 and synchronized the requirement across documentation and CI workflows.
+
+### Fixed
+- 🚀 **Release Workflow** - Corrected PyPI and TestPyPI publishing workflow configuration and standardized installation verification messages.
+
+## [1.2.3] - 2025-10-07
+
+### Added
+- 📚 **Documentation Section** - Added comprehensive documentation links in README.md
+  - Link to CHANGELOG.md for version history and feature updates
+  - Link to docs/maintainers/VERSION_MANAGEMENT.md for release workflow and branch strategy
+  - Links to GitHub Issues and Discussions for community engagement
+
+### Changed
+- 🏗️ **Branch Strategy Documentation** - Major update to VERSION_MANAGEMENT.md
+  - Added detailed branch strategy section explaining dev/main workflow
+  - Updated release workflow with 4-step process including branch merge requirement
+  - Enhanced publishing scenarios (normal release, hotfix, quick release)
+  - Expanded best practices from 8 to 10 comprehensive guidelines
+  - Updated quick reference with branch-specific commands
+
+- 🔄 **Enhanced CI/CD Workflows** - Intelligent optimization for GitHub Actions
+  - Added TestPyPI test reuse mechanism in PyPI workflow (saves approximately 45 minutes per release)
+  - Implemented 7-day test validity window for TestPyPI results
+  - Added verification summary job with detailed test status reporting
+  - Optimized GitHub Actions minutes usage (approximately 40% savings)
+  - Enhanced workflow comments and documentation
+
+### Fixed
+- 🐛 **Python 3.8 Compatibility** - Resolved f-string syntax issues in CI workflows
+  - Fixed package metadata verification step in publish-to-pypi.yml
+  - Fixed package metadata verification step in publish-to-testpypi.yml
+  - Resolved f-string backslash syntax error (not supported in Python 3.8)
+  - Ensured compatibility across all supported Python versions (3.8-3.12)
+
+### Technical Improvements
+- Better CI/CD resource optimization with intelligent test reuse
+- Clearer release workflow documentation for contributors
+- Improved branch management guidelines
+- Enhanced Python version compatibility in automated workflows
+
 ## [1.2.2] - 2025-10-05
 
 ### Added
@@ -192,7 +239,6 @@ This project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.htm
 - ✨ Automatic version management using setuptools-scm
 - 🤖 Dual GitHub Actions workflows: dev branch → TestPyPI, tag → PyPI
 - 📚 Comprehensive documentation for version management and publishing
-- 📝 CLAUDE.md - Guide for Claude Code integration
 - 📝 VERSION_MANAGEMENT.md - Complete guide for version management with Git tags and setuptools_scm
 - 📝 SECURITY.md - Security policy and vulnerability reporting guidelines
 - 📝 PROJECT_IMPROVEMENT_ANALYSIS.md - Detailed analysis of 26 issues