pysfi 0.1.0__py3-none-any.whl → 0.1.2__py3-none-any.whl

pysfi-0.1.2.dist-info/METADATA

@@ -0,0 +1,107 @@
+Metadata-Version: 2.4
+Name: pysfi
+Version: 0.1.2
+Summary: Single File commands for Interactive python.
+Requires-Python: >=3.8
+Requires-Dist: tomli>=2.4.0; python_version < '3.11'
+Description-Content-Type: text/markdown
+
+# pysfi
+
+Single File commands for Interactive python.
+
+## Overview
+
+pysfi is a Python project that provides single-file command-line utilities, designed to be lightweight and easy-to-use.
+
+## Available Commands
+
+- **alarmclk**: Alarm clock functionality
+- **[bumpversion](sfi/bumpversion/README.md)**: Automated version number management tool
+- **embedinstall**: Embed installation utilities
+- **[filedate](sfi/filedate/README.md)**: A file date management tool that normalizes date prefixes in filenames
+- **mkp**: Make Python project utilities
+- **projectparse**: Project parsing and analysis tools
+- **pyloadergen**: Python loader code generation
+- **pypacker**: Python packaging utilities
+
+## Installation
+
+```bash
+# Install using uv (recommended)
+uv add pysfi
+
+# Or using pip
+pip install pysfi
+```
+
+## Development
+
+### Requirements
+
+- Python >= 3.8
+- [uv](https://github.com/astral-sh/uv) (recommended) or pip
+
+### Development Dependencies
+
+```bash
+uv pip install -e ".[dev]"
+```
+
+### Code Standards
+
+The project uses Ruff for code linting and formatting:
+
+```bash
+# Check code
+ruff check .
+
+# Format code
+ruff format .
+```
+
+## Project Structure
+
+```bash
+pysfi/
+├── pyproject.toml          # Main project configuration
+├── README.md
+└── sfi/
+    ├── __init__.py
+    ├── alarmclock/         # alarmclk command module
+    │   ├── alarmclock.py
+    │   ├── pyproject.toml
+    │   └── __init__.py
+    ├── embedinstall/       # embedinstall command module
+    │   ├── embedinstall.py
+    │   ├── pyproject.toml
+    │   └── __init__.py
+    ├── filedate/           # filedate command module
+    │   ├── filedate.py
+    │   ├── pyproject.toml
+    │   ├── README.md       # Detailed documentation
+    │   └── __init__.py
+    ├── makepython/         # mkp command module
+    │   ├── makepython.py
+    │   ├── pyproject.toml
+    │   └── __init__.py
+    ├── projectparse/       # projectparse command module
+    │   ├── projectparse.py
+    │   ├── pyproject.toml
+    │   └── __init__.py
+    ├── pyloadergen/        # pyloadergen command module
+    │   ├── pyloadergen.py
+    │   ├── pyproject.toml
+    │   └── __init__.py
+    └── pypacker/           # pypacker command module
+        ├── fspacker.py
+        └── pyproject.toml
+```
+
+## License
+
+MIT License
+
+## Contributing
+
+Issues and Pull Requests are welcome!

{pysfi-0.1.0.dist-info → pysfi-0.1.2.dist-info}/RECORD

@@ -1,6 +1,8 @@
-sfi/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+sfi/__init__.py,sha256=4WjI73hj6c4ccpxA7aVaFsqoetgCa4pYSANxvSTwPpk,74
 sfi/alarmclock/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 sfi/alarmclock/alarmclock.py,sha256=65G8OyTGpe4oQ2SFerQG1N9PVJ4KxO7WzgsTxpGm4O0,12509
+sfi/bumpversion/__init__.py,sha256=vyfByThaLhG1WtroKYrG2iKJdaNXjXvxGcyAq4FYZ2E,85
+sfi/bumpversion/bumpversion.py,sha256=eneJt0znwQs4D6wm1H2TfECPu3Ut3h-eHzbxbbQiS2I,19024
 sfi/embedinstall/embedinstall.py,sha256=N5EbTDdX4bE3W0qHGAwAUuepqFr0sbdZuPI3KWrtuUY,14936
 sfi/filedate/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 sfi/filedate/filedate.py,sha256=DpVp26lumE_Lz_4TgqUEX8IxtK3Y6yHSEFV8qJyegyk,3645
@@ -8,10 +10,8 @@ sfi/makepython/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 sfi/makepython/makepython.py,sha256=9-PPKlxAnaHm9NPhfpn1jcnEYix84rAM77tkHGQeWtA,2244
 sfi/projectparse/projectparse.py,sha256=Ojg-z4lZEtjEBpJYWyznTgL307N45AxlQKnRkEH0P70,5525
 sfi/pyloadergen/pyloadergen.py,sha256=yfMOeusAXm89gM02h21zQVoaSt6dkA2khXxfuU6Ognk,34182
-sfi/pyloadergen/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-sfi/pyloadergen/tests/test_pyloadergen.py,sha256=rprkF2Flhg23S875ZWgaJYvwAHdHHh4K4mm5zetYx2I,12817
 sfi/pypacker/fspacker.py,sha256=3tlS7qiWoH_kOzsp9eSWsQ-SY7-bSTugwfB-HIL69iE,3238
-pysfi-0.1.0.dist-info/METADATA,sha256=S3mdC8SfZ4sl3pU9MneCAwu3Qf5c4r07x-bcN4ACJOw,1402
-pysfi-0.1.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-pysfi-0.1.0.dist-info/entry_points.txt,sha256=aV9Do3TJC0HT-QMorLRmj-KYeCvRYqkdNgE5HeYj98w,320
-pysfi-0.1.0.dist-info/RECORD,,
+pysfi-0.1.2.dist-info/METADATA,sha256=9pvadB42FHgTD-QmxdiRSQ2Nf7wa6AuIqJdFNz5Afgs,2755
+pysfi-0.1.2.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+pysfi-0.1.2.dist-info/entry_points.txt,sha256=6XalkBAzJXRaYaPydlk_Q6Sr6aPOAv8v_5ZBdvg63Lk,367
+pysfi-0.1.2.dist-info/RECORD,,

{pysfi-0.1.0.dist-info → pysfi-0.1.2.dist-info}/entry_points.txt

@@ -1,5 +1,6 @@
 [console_scripts]
 alarmclk = sfi.alarmclock.alarmclock:main
+bumpversion = sfi.bumpversion.bumpversion:main
 embedinstall = sfi.embedinstall.embedinstall:main
 filedate = sfi.filedate.filedate:main
 mkp = sfi.makepython.makepython:main

sfi/__init__.py

@@ -0,0 +1,3 @@
+"""Single File commands for Interactive python."""
+
+__version__ = "0.1.2"

sfi/bumpversion/__init__.py

@@ -0,0 +1,3 @@
+"""Bumpversion - Automated version number management tool."""
+
+__version__ = "0.1.2"

sfi/bumpversion/bumpversion.py

@@ -0,0 +1,509 @@
+"""Automated version number management tool."""
+
+from __future__ import annotations
+
+import argparse
+import json
+import logging
+import re
+import subprocess
+import sys
+from dataclasses import dataclass
+from enum import Enum
+from pathlib import Path
+from typing import Final
+
+try:
+    import tomli
+except ImportError:
+    import tomllib as tomli  # pyright: ignore[reportMissingImports]
+
+logging.basicConfig(level=logging.INFO, format="%(message)s")
+logger = logging.getLogger(__name__)
+
+VERSION_PATTERN: Final = re.compile(
+    r"(?P<major>0|[1-9]\d*)\.(?P<minor>0|[1-9]\d*)\.(?P<patch>0|[1-9]\d*)(?:-(?P<prerelease>(?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*)(?:\.(?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*))*))?(?:\+(?P<buildmetadata>[0-9a-zA-Z-]+(?:\.[0-9a-zA-Z-]+)*))?"
+)
+
+
+class VersionPart(Enum):
+    """Version parts that can be bumped."""
+
+    MAJOR = "major"
+    MINOR = "minor"
+    PATCH = "patch"
+
+
+@dataclass
+class Version:
+    """Represents a semantic version number."""
+
+    major: int
+    minor: int
+    patch: int
+    prerelease: str | None = None
+    buildmetadata: str | None = None
+
+    def __str__(self) -> str:
+        """Return version string representation."""
+        version = f"{self.major}.{self.minor}.{self.patch}"
+        if self.prerelease:
+            version += f"-{self.prerelease}"
+        if self.buildmetadata:
+            version += f"+{self.buildmetadata}"
+        return version
+
+    @classmethod
+    def parse(cls, version_string: str) -> Version:
+        """Parse version string into Version object."""
+        match = VERSION_PATTERN.match(version_string)
+        if not match:
+            msg = f"Invalid version format: {version_string}"
+            raise ValueError(msg)
+
+        return cls(
+            major=int(match.group("major")),
+            minor=int(match.group("minor")),
+            patch=int(match.group("patch")),
+            prerelease=match.group("prerelease"),
+            buildmetadata=match.group("buildmetadata"),
+        )
+
+    def bump(self, part: VersionPart, reset_prerelease: bool = True) -> Version:
+        """Return a new version with specified part bumped."""
+        if part == VersionPart.MAJOR:
+            return Version(
+                major=self.major + 1,
+                minor=0,
+                patch=0,
+                prerelease=self.prerelease if not reset_prerelease else None,
+                buildmetadata=None,  # Always reset build metadata
+            )
+        if part == VersionPart.MINOR:
+            return Version(
+                major=self.major,
+                minor=self.minor + 1,
+                patch=0,
+                prerelease=self.prerelease if not reset_prerelease else None,
+                buildmetadata=None,
+            )
+        if part == VersionPart.PATCH:
+            return Version(
+                major=self.major,
+                minor=self.minor,
+                patch=self.patch + 1,
+                prerelease=self.prerelease if not reset_prerelease else None,
+                buildmetadata=None,
+            )
+
+        msg = f"Unsupported version part: {part}"
+        raise ValueError(msg)
+
+    def set_prerelease(self, prerelease: str) -> Version:
+        """Return a new version with prerelease tag set."""
+        return Version(
+            major=self.major,
+            minor=self.minor,
+            patch=self.patch,
+            prerelease=prerelease,
+            buildmetadata=None,
+        )
+
+
+class FileParser:
+    """Parser for different file formats to extract and update version numbers."""
+
+    @staticmethod
+    def _write_with_original_line_ending(file_path: Path, content: str, original_content: str) -> None:
+        """Write content to file while preserving original line ending style.
+
+        Args:
+            file_path: Path to the file to write
+            content: New content to write
+            original_content: Original content to detect line ending style from
+        """
+        # Detect original line ending style
+        newline = "\r\n" if "\r\n" in original_content else "\n"
+
+        # Write with specified line ending to preserve original style
+        with file_path.open("w", encoding="utf-8", newline=newline) as f:
+            f.write(content)
+
+    @staticmethod
+    def parse_pyproject(file_path: Path) -> tuple[Version, list[str]]:
+        """Parse version from pyproject.toml file."""
+        logger.debug(f"Parsing pyproject.toml: {file_path}")
+        with file_path.open("rb") as f:
+            data = tomli.load(f)
+        version_str = data.get("project", {}).get("version")
+        if not version_str:
+            msg = "Version not found in pyproject.toml"
+            raise ValueError(msg)
+
+        return Version.parse(version_str), ["project.version"]
+
+    @staticmethod
+    def update_pyproject(file_path: Path, new_version: Version) -> None:
+        """Update version in pyproject.toml file."""
+        logger.debug(f"Updating pyproject.toml: {file_path}")
+        # Read file with original line endings preserved
+        content = file_path.read_text()
+
+        # Find and replace version - use word boundary to avoid partial matches
+        # Match "version = "..."" as a standalone key, not part of other keys
+        pattern = r'(?<![\w-])version\s*=\s*"[^"]+"'
+        new_version_str = f'version = "{new_version}"'
+        new_content = re.sub(pattern, new_version_str, content)
+
+        # Write back preserving original line endings
+        FileParser._write_with_original_line_ending(file_path, new_content, content)
+
+    @staticmethod
+    def parse_init_py(file_path: Path) -> tuple[Version, list[str]]:
+        """Parse version from __init__.py file."""
+        logger.debug(f"Parsing __init__.py: {file_path}")
+        content = file_path.read_text()
+
+        match = re.search(r'__version__\s*=\s*["\']([^"\']+)["\']', content)
+        if not match:
+            msg = "Version not found in __init__.py"
+            raise ValueError(msg)
+
+        return Version.parse(match.group(1)), []
+
+    @staticmethod
+    def update_init_py(file_path: Path, new_version: Version) -> None:
+        """Update version in __init__.py file."""
+        logger.debug(f"Updating __init__.py: {file_path}")
+        content = file_path.read_text()
+
+        pattern = r'__version__\s*=\s*["\'][^"\']+["\']'
+        new_version_str = f'__version__ = "{new_version}"'
+        new_content = re.sub(pattern, new_version_str, content)
+
+        FileParser._write_with_original_line_ending(file_path, new_content, content)
+
+    @staticmethod
+    def parse_setup_py(file_path: Path) -> tuple[Version, list[str]]:
+        """Parse version from setup.py file."""
+        logger.debug(f"Parsing setup.py: {file_path}")
+        content = file_path.read_text()
+
+        match = re.search(r'version\s*=\s*["\']([^"\']+)["\']', content)
+        if not match:
+            msg = "Version not found in setup.py"
+            raise ValueError(msg)
+
+        return Version.parse(match.group(1)), []
+
+    @staticmethod
+    def update_setup_py(file_path: Path, new_version: Version) -> None:
+        """Update version in setup.py file."""
+        logger.debug(f"Updating setup.py: {file_path}")
+        content = file_path.read_text()
+
+        pattern = r'version\s*=\s*["\'][^"\']+["\']'
+        new_version_str = f'version = "{new_version}"'
+        new_content = re.sub(pattern, new_version_str, content)
+
+        FileParser._write_with_original_line_ending(file_path, new_content, content)
+
+    @staticmethod
+    def parse_package_json(file_path: Path) -> tuple[Version, list[str]]:
+        """Parse version from package.json file."""
+        logger.debug(f"Parsing package.json: {file_path}")
+        content = file_path.read_text()
+
+        match = re.search(r'"version"\s*:\s*"([^"]+)"', content)
+        if not match:
+            msg = "Version not found in package.json"
+            raise ValueError(msg)
+
+        return Version.parse(match.group(1)), []
+
+    @staticmethod
+    def update_package_json(file_path: Path, new_version: Version) -> None:
+        """Update version in package.json file."""
+        logger.debug(f"Updating package.json: {file_path}")
+        content = file_path.read_text()
+
+        pattern = r'"version"\s*:\s*"[^"]+"'
+        new_version_str = f'"version": "{new_version}"'
+        new_content = re.sub(pattern, new_version_str, content)
+
+        FileParser._write_with_original_line_ending(file_path, new_content, content)
+
+    @staticmethod
+    def parse_cargo_toml(file_path: Path) -> tuple[Version, list[str]]:
+        """Parse version from Cargo.toml file."""
+        logger.debug(f"Parsing Cargo.toml: {file_path}")
+        content = file_path.read_text()
+
+        match = re.search(r'^version\s*=\s*"([^"]+)"', content, re.MULTILINE)
+        if not match:
+            msg = "Version not found in Cargo.toml"
+            raise ValueError(msg)
+
+        return Version.parse(match.group(1)), []
+
+    @staticmethod
+    def update_cargo_toml(file_path: Path, new_version: Version) -> None:
+        """Update version in Cargo.toml file."""
+        logger.debug(f"Updating Cargo.toml: {file_path}")
+        content = file_path.read_text()
+
+        pattern = r'^version\s*=\s*"[^"]+"'
+        new_version_str = f'version = "{new_version}"'
+        new_content = re.sub(pattern, new_version_str, content, flags=re.MULTILINE)
+
+        FileParser._write_with_original_line_ending(file_path, new_content, content)
+
+
+class BumpversionManager:
+    """Main manager for version bumping operations."""
+
+    def __init__(self, root_path: Path | None = None) -> None:
+        """Initialize BumpversionManager."""
+        self.root_path = root_path or Path.cwd()
+        self.files: dict[str, Path] = {}
+        self.current_version: Version | None = None
+        # Load subprojects from projects.json to exclude them from version detection
+        self.subproject_paths: set[Path] = set()
+        try:
+            projects_file = self.root_path / "projects.json"
+            if projects_file.exists():
+                with projects_file.open("r", encoding="utf-8") as f:
+                    projects_data = json.load(f)
+                self.subproject_paths = {self.root_path / p for p in projects_data.get("subprojects", [])}
+        except Exception:
+            pass
+
+    def detect_files(self) -> list[Path]:
+        """Detect version files in the project."""
+        logger.info("Detecting version files...")
+        detected_files: list[Path] = []
+
+        # Check common version files
+        common_files = [
+            "pyproject.toml",
+            "setup.py",
+            "package.json",
+            "Cargo.toml",
+        ]
+
+        for file_name in common_files:
+            file_path = self.root_path / file_name
+            if file_path.exists():
+                detected_files.append(file_path)
+                logger.info(f"Found: {file_path}")
+
+        # Check for __init__.py files in all packages (excluding __pycache__ and virtual environments)
+        init_files = list(self.root_path.rglob("__init__.py"))
+        # Filter out unwanted directories
+        excluded_dirs = {"__pycache__", ".venv", "venv", "env", ".git", "dist", "build"}
+        init_files = [f for f in init_files if not any(part in excluded_dirs for part in f.parts)]
+        # Exclude files inside subprojects defined in projects.json
+        init_files = [f for f in init_files if not any(str(f).startswith(str(sp)) for sp in self.subproject_paths)]
+        detected_files.extend(init_files)
+        for f in init_files:
+            logger.info(f"Found: {f}")
+
+        if not detected_files:
+            logger.warning("No version files detected in current directory.")
+
+        return detected_files
+
+    def parse_version_from_file(self, file_path: Path) -> Version:
+        """Parse version from a file based on its type."""
+        if file_path.name == "pyproject.toml":
+            return FileParser.parse_pyproject(file_path)[0]
+        if file_path.name == "__init__.py":
+            return FileParser.parse_init_py(file_path)[0]
+        if file_path.name == "setup.py":
+            return FileParser.parse_setup_py(file_path)[0]
+        if file_path.name == "package.json":
+            return FileParser.parse_package_json(file_path)[0]
+        if file_path.name == "Cargo.toml":
+            return FileParser.parse_cargo_toml(file_path)[0]
+
+        msg = f"Unsupported file type: {file_path.name}"
+        raise ValueError(msg)
+
+    def update_version_in_file(self, file_path: Path, new_version: Version) -> None:
+        """Update version in a file based on its type."""
+        if file_path.name == "pyproject.toml":
+            FileParser.update_pyproject(file_path, new_version)
+        elif file_path.name == "__init__.py":
+            FileParser.update_init_py(file_path, new_version)
+        elif file_path.name == "setup.py":
+            FileParser.update_setup_py(file_path, new_version)
+        elif file_path.name == "package.json":
+            FileParser.update_package_json(file_path, new_version)
+        elif file_path.name == "Cargo.toml":
+            FileParser.update_cargo_toml(file_path, new_version)
+        else:
+            msg = f"Unsupported file type: {file_path.name}"
+            raise ValueError(msg)
+
+    def bump(
+        self,
+        part: VersionPart,
+        files: list[Path] | None = None,
+        prerelease: str | None = None,
+        commit: bool = False,
+        tag: bool = False,
+        message: str | None = None,
+    ) -> Version:
+        """Bump version number in specified files."""
+        if not files:
+            files = self.detect_files()
+
+        if not files:
+            msg = "No files to update"
+            raise ValueError(msg)
+
+        # Parse current version from first file
+        self.current_version = self.parse_version_from_file(files[0])
+        logger.info(f"Current version: {self.current_version}")
+
+        # Calculate new version
+        new_version = self.current_version.set_prerelease(prerelease) if prerelease else self.current_version.bump(part)
+
+        logger.info(f"New version: {new_version}")
+
+        # Update all files
+        for file_path in files:
+            try:
+                self.update_version_in_file(file_path, new_version)
+                logger.info(f"Updated: {file_path}")
+            except Exception as e:
+                logger.error(f"Failed to update {file_path}: {e}")
+
+        # Git operations
+        if commit or tag:
+            self._git_operations(new_version, commit, tag, message, files)
+
+        return new_version
+
+    def _git_operations(
+        self,
+        version: Version,
+        commit: bool,
+        tag: bool,
+        message: str | None,
+        files: list[Path],
+    ) -> None:
+        """Perform git commit and/or tag operations."""
+        if not self._is_git_repo():
+            logger.warning("Not a git repository, skipping git operations")
+            return
+
+        if commit:
+            self._git_commit(version, message, files)
+
+        if tag:
+            self._git_tag(version)
+
+    def _is_git_repo(self) -> bool:
+        """Check if current directory is a git repository."""
+        try:
+            subprocess.run(
+                ["git", "rev-parse", "--git-dir"],
+                check=True,
+                capture_output=True,
+            )
+            return True
+        except (subprocess.CalledProcessError, FileNotFoundError):
+            return False
+
+    def _git_commit(self, version: Version, message: str | None, files: list[Path]) -> None:
+        """Commit version changes to git."""
+        commit_message = message or f"chore: bump version to {version}"
+
+        try:
+            subprocess.run(["git", "add"] + [str(f) for f in files], check=True)
+            subprocess.run(["git", "commit", "-m", commit_message], check=True)
+            logger.info(f"Git commit successful: {commit_message}")
+        except subprocess.CalledProcessError as e:
+            logger.error(f"Git commit failed: {e}")
+
+    def _git_tag(self, version: Version) -> None:
+        """Create git tag for the new version."""
+        tag_name = f"v{version}"
+
+        try:
+            subprocess.run(["git", "tag", "-a", tag_name, "-m", f"Version {version}"], check=True)
+            logger.info(f"Git tag created: {tag_name}")
+        except subprocess.CalledProcessError as e:
+            logger.error(f"Git tag failed: {e}")
+
+
+def main() -> None:
+    """Main entry point for bumpversion command."""
+    parser = argparse.ArgumentParser(prog="bumpversion", description="Automated version number management tool")
+    parser.add_argument("part", type=str, choices=["major", "minor", "patch"], help="Version part to bump")
+    parser.add_argument("--files", "-f", type=str, nargs="*", help="Specific files to update (default: auto-detect)")
+    parser.add_argument("--prerelease", "-p", type=str, help="Set prerelease tag (e.g., alpha, beta, rc1)")
+    parser.add_argument("--commit", "-c", action="store_true", help="Commit changes to git")
+    parser.add_argument("--tag", "-t", action="store_true", help="Create git tag")
+    parser.add_argument("--message", "-m", type=str, help="Custom commit message")
+    parser.add_argument("--dry-run", "-n", action="store_true", help="Show what would be done without making changes")
+    parser.add_argument("--debug", "-d", action="store_true", help="Enable debug mode")
+    args = parser.parse_args()
+
+    if args.debug:
+        logger.setLevel(logging.DEBUG)
+
+    # Parse version part
+    try:
+        part = VersionPart(args.part.lower())
+    except ValueError as e:
+        logger.error(f"Invalid version part: {e}")
+        sys.exit(1)
+
+    # Parse files
+    files: list[Path] | None = None
+    if args.files:
+        files = [Path(f) for f in args.files]
+        # Validate files exist
+        for f in files:
+            if not f.exists():
+                logger.error(f"File not found: {f}")
+                sys.exit(1)
+
+    # Dry run mode
+    if args.dry_run:
+        logger.info("Dry run mode - no changes will be made")
+        manager = BumpversionManager()
+        detected_files = manager.detect_files()
+        if not files:
+            files = detected_files
+        if files:
+            current_version = manager.parse_version_from_file(files[0])
+            logger.info(f"Current version: {current_version}")
+            new_version = current_version.bump(part)
+            logger.info(f"New version: {new_version}")
+            logger.info(f"Files to update: {files}")
+        else:
+            logger.info("No files to update")
+        return
+
+    # Perform bump
+    try:
+        manager = BumpversionManager()
+        new_version = manager.bump(
+            part=part,
+            files=files,
+            prerelease=args.prerelease,
+            commit=args.commit,
+            tag=args.tag,
+            message=args.message,
+        )
+        logger.info(f"Successfully bumped version to: {new_version}")
+    except Exception as e:
+        logger.error(f"Failed to bump version: {e}")
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()

pysfi-0.1.0.dist-info/METADATA

@@ -1,78 +0,0 @@
-Metadata-Version: 2.4
-Name: pysfi
-Version: 0.1.0
-Summary: Single File commands for Interactive python.
-Requires-Python: >=3.8
-Description-Content-Type: text/markdown
-
-# sfi
-
-Single File commands for Interactive python.
-
-## Overview
-
-sfi is a Python project that provides single-file command-line utilities, designed to be lightweight and easy-to-use.
-
-## Available Commands
-
-### [filedate](sfi/filedate/README.md)
-
-A file date management tool that normalizes date prefixes in filenames.
-
-## Installation
-
-```bash
-# Install using uv (recommended)
-uv add sfi
-
-# Or using pip
-pip install sfi
-```
-
-## Development
-
-### Requirements
-
-- Python >= 3.8
-- [uv](https://github.com/astral-sh/uv) (recommended) or pip
-
-### Development Dependencies
-
-```bash
-uv pip install -e ".[dev]"
-```
-
-### Code Standards
-
-The project uses Ruff for code linting and formatting:
-
-```bash
-# Check code
-ruff check .
-
-# Format code
-ruff format .
-```
-
-## Project Structure
-
-```bash
-sfi/
-├── pyproject.toml          # Main project configuration
-├── README.md
-└── sfi/
-    ├── __init__.py
-    └── filedate/           # filedate command module
-        ├── __init__.py
-        ├── filedate.py     # Main implementation
-        ├── pyproject.toml
-        └── README.md       # Detailed documentation
-```
-
-## License
-
-MIT License
-
-## Contributing
-
-Issues and Pull Requests are welcome!

sfi/pyloadergen/tests/test_pyloadergen.py

@@ -1,290 +0,0 @@
-"""Test suite for pyloadergen module."""
-
-from __future__ import annotations
-
-import tempfile
-from pathlib import Path
-from unittest import mock
-
-from sfi.pyloadergen import pyloadergen
-
-
-class TestSelectTemplate:
-    """Test template selection logic."""
-
-    def test_windows_gui_template_non_debug(self):
-        """Test Windows GUI template selection in non-debug mode."""
-        with mock.patch("sfi.pyloadergen.pyloadergen.is_windows", True):  # noqa: SIM117
-            with mock.patch("sfi.pyloadergen.pyloadergen.is_macos", False):
-                result = pyloadergen.select_template("gui", False)
-                assert result == pyloadergen._WINDOWS_GUI_TEMPLATE
-
-    def test_windows_console_template_non_debug(self):
-        """Test Windows console template selection in non-debug mode."""
-        with mock.patch("sfi.pyloadergen.pyloadergen.is_windows", True):  # noqa: SIM117
-            with mock.patch("sfi.pyloadergen.pyloadergen.is_macos", False):
-                result = pyloadergen.select_template("console", False)
-                assert result == pyloadergen._WINDOWS_CONSOLE_TEMPLATE
-
-    def test_windows_gui_template_debug(self):
-        """Test that debug mode forces console template on Windows."""
-        with mock.patch("sfi.pyloadergen.pyloadergen.is_windows", True):  # noqa: SIM117
-            with mock.patch("sfi.pyloadergen.pyloadergen.is_macos", False):
-                result = pyloadergen.select_template("gui", True)
-                assert result == pyloadergen._WINDOWS_CONSOLE_TEMPLATE
-
-    def test_macos_gui_template_non_debug(self):
-        """Test macOS GUI template selection in non-debug mode."""
-        with mock.patch("sfi.pyloadergen.pyloadergen.is_windows", False):  # noqa: SIM117
-            with mock.patch("sfi.pyloadergen.pyloadergen.is_macos", True):
-                result = pyloadergen.select_template("gui", False)
-                assert result == pyloadergen._MACOS_GUI_TEMPLATE
-
-    def test_macos_console_template_debug(self):
-        """Test that debug mode forces console template on macOS."""
-        with mock.patch("sfi.pyloadergen.pyloadergen.is_windows", False):  # noqa: SIM117
-            with mock.patch("sfi.pyloadergen.pyloadergen.is_macos", True):
-                result = pyloadergen.select_template("gui", True)
-                assert result == pyloadergen._MACOS_CONSOLE_TEMPLATE
-
-    def test_unix_gui_template_non_debug(self):
-        """Test Unix GUI template selection in non-debug mode."""
-        with mock.patch("sfi.pyloadergen.pyloadergen.is_windows", False):  # noqa: SIM117
-            with mock.patch("sfi.pyloadergen.pyloadergen.is_macos", False):
-                result = pyloadergen.select_template("gui", False)
-                assert result == pyloadergen._UNIX_GUI_TEMPLATE
-
-    def test_unix_console_template_debug(self):
-        """Test that debug mode forces console template on Unix."""
-        with mock.patch("sfi.pyloadergen.pyloadergen.is_windows", False):  # noqa: SIM117
-            with mock.patch("sfi.pyloadergen.pyloadergen.is_macos", False):
-                result = pyloadergen.select_template("gui", True)
-                assert result == pyloadergen._UNIX_CONSOLE_TEMPLATE
-
-
-class TestGenerateCSource:
-    """Test C source code generation."""
-
-    def test_replace_entry_file_placeholder(self):
-        """Test that ENTRY_FILE placeholder is replaced."""
-        template = "script: ${ENTRY_FILE}"
-        result = pyloadergen.generate_c_source(template, "my_script.py", False)
-        assert "my_script.py" in result
-        assert "${ENTRY_FILE}" not in result
-
-    def test_replace_debug_mode_placeholder_true(self):
-        """Test that DEBUG_MODE placeholder is replaced with 1."""
-        template = "debug: ${DEBUG_MODE}"
-        result = pyloadergen.generate_c_source(template, "test.py", True)
-        assert "debug: 1" in result
-        assert "${DEBUG_MODE}" not in result
-
-    def test_replace_debug_mode_placeholder_false(self):
-        """Test that DEBUG_MODE placeholder is replaced with 0."""
-        template = "debug: ${DEBUG_MODE}"
-        result = pyloadergen.generate_c_source(template, "test.py", False)
-        assert "debug: 0" in result
-        assert "${DEBUG_MODE}" not in result
-
-    def test_replace_both_placeholders(self):
-        """Test that both placeholders are replaced correctly."""
-        template = "file: ${ENTRY_FILE}, debug: ${DEBUG_MODE}"
-        result = pyloadergen.generate_c_source(template, "main.py", True)
-        assert "file: main.py" in result
-        assert "debug: 1" in result
-        assert "${ENTRY_FILE}" not in result
-        assert "${DEBUG_MODE}" not in result
-
-
-class TestGetCompilerArgs:
-    """Test compiler argument retrieval."""
-
-    def test_gcc_compiler_args(self):
-        """Test GCC compiler arguments."""
-        args = pyloadergen.get_compiler_args("gcc")
-        assert "-std=c99" in args
-        assert "-Wall" in args
-        assert "-pedantic" in args
-        assert "-Werror" in args
-
-    def test_clang_compiler_args(self):
-        """Test Clang compiler arguments."""
-        args = pyloadergen.get_compiler_args("clang")
-        assert "-std=c99" in args
-        assert "-Wall" in args
-        assert "-pedantic" in args
-        assert "-Werror" in args
-
-    def test_cl_compiler_args(self):
-        """Test MSVC (cl) compiler arguments."""
-        args = pyloadergen.get_compiler_args("cl")
-        assert "/std:c99" in args
-        assert "/Wall" in args
-        assert "/WX" in args
-        assert "/Werror" in args
-
-    def test_cl_exe_compiler_args(self):
-        """Test cl.exe compiler arguments (full path)."""
-        args = pyloadergen.get_compiler_args("C:\\vc\\bin\\cl.exe")
-        assert "/std:c99" in args
-        assert "/Wall" in args
-        assert "/WX" in args
-        assert "/Werror" in args
-
-    def test_unknown_compiler_args(self):
-        """Test unknown compiler returns empty list."""
-        args = pyloadergen.get_compiler_args("unknown_compiler")
-        assert args == []
-
-
-class TestFindCompiler:
-    """Test compiler detection."""
-
-    def test_find_compiler_gcc(self):
-        """Test finding gcc compiler."""
-        with mock.patch("shutil.which") as mock_which:
-            mock_which.return_value = "/usr/bin/gcc"
-            with mock.patch("sfi.pyloadergen.pyloadergen.is_windows", False):
-                result = pyloadergen.find_compiler()
-                assert result == "gcc"
-
-    def test_find_compiler_clang(self):
-        """Test finding clang compiler."""
-        # Mock shutil.which to return clang for clang but not for gcc
-        with mock.patch("shutil.which") as mock_which:
-
-            def which_side_effect(cmd):
-                # Return gcc None, clang first
-                if cmd == "gcc":
-                    return None
-                elif cmd == "clang":
-                    return "/usr/bin/clang"
-                return None
-
-            mock_which.side_effect = which_side_effect
-
-            with mock.patch("sfi.pyloadergen.pyloadergen.is_windows", False):
-                result = pyloadergen.find_compiler()
-                assert result == "clang"
-
-    def test_no_compiler_found(self):
-        """Test when no compiler is found."""
-        with mock.patch("shutil.which") as mock_which:
-            mock_which.return_value = None
-            result = pyloadergen.find_compiler()
-            assert result is None
-
-
-class TestCompilerOptions:
-    """Test compiler options dictionary."""
-
-    def test_compiler_options_has_gcc(self):
-        """Test GCC options are defined."""
-        assert "gcc" in pyloadergen._COMPILER_OPTIONS
-        assert "-std=c99" in pyloadergen._COMPILER_OPTIONS["gcc"]
-
-    def test_compiler_options_has_clang(self):
-        """Test Clang options are defined."""
-        assert "clang" in pyloadergen._COMPILER_OPTIONS
-        assert "-std=c99" in pyloadergen._COMPILER_OPTIONS["clang"]
-
-    def test_compiler_options_has_cl(self):
-        """Test MSVC options are defined."""
-        assert "cl" in pyloadergen._COMPILER_OPTIONS
-        assert "/std:c99" in pyloadergen._COMPILER_OPTIONS["cl"]
-
-
-class TestTemplateContent:
-    """Test template content validation."""
-
-    def test_windows_gui_template_has_winmain(self):
-        """Test Windows GUI template has WinMain entry point."""
-        assert "int APIENTRY WinMain" in pyloadergen._WINDOWS_GUI_TEMPLATE
-
-    def test_windows_console_template_has_main(self):
-        """Test Windows console template has main entry point."""
-        assert "int main(" in pyloadergen._WINDOWS_CONSOLE_TEMPLATE
-
-    def test_unix_gui_template_has_main(self):
-        """Test Unix GUI template has main entry point."""
-        assert "int main(" in pyloadergen._UNIX_GUI_TEMPLATE
-
-    def test_unix_console_template_has_main(self):
-        """Test Unix console template has main entry point."""
-        assert "int main(" in pyloadergen._UNIX_CONSOLE_TEMPLATE
-
-    def test_macos_gui_template_has_main(self):
-        """Test macOS GUI template has main entry point."""
-        assert "int main(" in pyloadergen._MACOS_GUI_TEMPLATE
-
-    def test_macos_console_template_has_main(self):
-        """Test macOS console template has main entry point."""
-        assert "int main(" in pyloadergen._MACOS_CONSOLE_TEMPLATE
-
-    def test_windows_templates_have_placeholder(self):
-        """Test Windows templates contain placeholders."""
-        assert "${ENTRY_FILE}" in pyloadergen._WINDOWS_GUI_TEMPLATE
-        assert "${DEBUG_MODE}" in pyloadergen._WINDOWS_GUI_TEMPLATE
-        assert "${ENTRY_FILE}" in pyloadergen._WINDOWS_CONSOLE_TEMPLATE
-
-    def test_unix_templates_have_placeholder(self):
-        """Test Unix templates contain placeholder."""
-        assert "${ENTRY_FILE}" in pyloadergen._UNIX_GUI_TEMPLATE
-        assert "${ENTRY_FILE}" in pyloadergen._UNIX_CONSOLE_TEMPLATE
-
-    def test_macos_templates_have_placeholder(self):
-        """Test macOS templates contain placeholder."""
-        assert "${ENTRY_FILE}" in pyloadergen._MACOS_GUI_TEMPLATE
-        assert "${ENTRY_FILE}" in pyloadergen._MACOS_CONSOLE_TEMPLATE
-
-
-class TestCompileCSource:
-    """Test C source compilation."""
-
-    def test_compile_creates_executable(self):
-        """Test compilation creates executable file."""
-        with tempfile.TemporaryDirectory() as temp_dir:
-            c_source = Path(temp_dir) / "test.c"
-            c_source.write_text("#include <stdio.h>\nint main() { return 0; }")
-            output = Path(temp_dir) / "test.exe"
-
-            with mock.patch("subprocess.run") as mock_run:
-                mock_run.return_value = mock.Mock(returncode=0, stdout="", stderr="")
-                result = pyloadergen.compile_c_source(str(c_source), str(output), "gcc")
-                assert result is True
-
-    def test_compile_failure(self):
-        """Test compilation failure."""
-        with tempfile.TemporaryDirectory() as temp_dir:
-            c_source = Path(temp_dir) / "test.c"
-            c_source.write_text("invalid C code")
-            output = Path(temp_dir) / "test.exe"
-
-            with mock.patch("subprocess.run") as mock_run:
-                mock_run.return_value = mock.Mock(returncode=1, stdout="", stderr="error")
-                result = pyloadergen.compile_c_source(str(c_source), str(output), "gcc")
-                assert result is False
-
-    def test_compiler_not_found(self):
-        """Test when compiler is not found."""
-        with tempfile.TemporaryDirectory() as temp_dir:
-            c_source = Path(temp_dir) / "test.c"
-            c_source.write_text("int main() { return 0; }")
-            output = Path(temp_dir) / "test.exe"
-
-            with mock.patch("subprocess.run", side_effect=FileNotFoundError):
-                result = pyloadergen.compile_c_source(str(c_source), str(output), "gcc")
-                assert result is False
-
-    def test_no_compiler_specified_finds_one(self):
-        """Test auto-detection of compiler when none specified."""
-        with tempfile.TemporaryDirectory() as temp_dir:
-            c_source = Path(temp_dir) / "test.c"
-            c_source.write_text("int main() { return 0; }")
-            output = Path(temp_dir) / "test.exe"
-
-            with mock.patch("subprocess.run") as mock_run:
-                mock_run.return_value = mock.Mock(returncode=0, stdout="", stderr="")
-                with mock.patch("sfi.pyloadergen.pyloadergen.find_compiler", return_value="gcc"):
-                    result = pyloadergen.compile_c_source(str(c_source), str(output), None)
-                    assert result is True