pkg-deploy 1.0.0__py3-none-any.whl

pkg_deploy/__init__.py

@@ -0,0 +1,3 @@
+__version__ = "1.0.0"
+
+from .deploy import PackageDeploy

pkg_deploy/build.py

@@ -0,0 +1,179 @@
+import os
+import sys
+import copy
+import logging
+import textwrap
+import subprocess
+from pathlib import Path
+from typing import Optional, Dict
+from dataclasses import dataclass
+from abc import ABC, abstractmethod
+from tomlkit.toml_document import TOMLDocument
+
+from .utils import save_config, is_uv_venv, ensure_uv_installed
+
+
+logger = logging.getLogger(__name__)
+
+
+@dataclass
+class DeployConfig:
+    package_name: str
+    project_dir: Path
+    pyproject_path: Path
+    version_type: str
+    new_version: str
+    use_cython: bool
+    is_uv_venv: bool
+    repository_name: str
+    repository_url: Optional[str] = None
+    username: Optional[str] = None
+    password: Optional[str] = None
+    dry_run: bool = False
+
+
+class BuildStrategy(ABC):
+
+    @staticmethod
+    def build_cmd():
+        if is_uv_venv():
+            ensure_uv_installed()
+            cmd = ["uv", "build", "--wheel"]
+        else:
+            cmd = [sys.executable, "-m", "build", "--wheel"]
+        return cmd
+
+    @abstractmethod
+    def build(self, config: DeployConfig, toml_config: TOMLDocument) -> bool:
+        pass
+
+
+class StandardBuildStrategy(BuildStrategy):
+
+    def build(self, config: DeployConfig, toml_config: TOMLDocument) -> bool:
+        cmd = self.build_cmd()
+        logger.info(f"Running: {' '.join(cmd)}")
+        result = subprocess.run(cmd, capture_output=True, text=True, cwd=config.project_dir)
+        if result.returncode != 0:
+           raise ValueError(f"Build failed, \nstdout: {result.stdout}\nstderr: {result.stderr}")
+        logger.info("Standard build completed successfully")
+        return True
+
+class CythonBuildStrategy(BuildStrategy):
+
+    def build(self, config: DeployConfig, toml_config: TOMLDocument) -> bool:
+        try:
+            self.prepare_pyproject_for_cython_build(config.project_dir, toml_config)
+            self.create_setup_py_for_cython(config.project_dir, toml_config)
+            cmd = self.build_cmd()
+            logger.info(f"Running Cython build: {' '.join(cmd)}")
+            env = os.environ.copy()
+            env['CYTHONIZE'] = '1'
+            result = subprocess.run(cmd, capture_output=True, text=True, env=env, cwd=config.project_dir)
+            if result.returncode != 0:
+                raise ValueError(f"Cython build failed, \nstdout: {result.stdout}\nstderr: {result.stderr}")
+            logger.info("Cython build completed successfully")
+            return True
+        except Exception as e:
+            logger.error(f"Cython build error: {e}")
+            return False
+        finally:
+            self.restore_pyproject_toml(project_dir=config.project_dir, original_toml_config=toml_config)
+
+    @staticmethod
+    def prepare_pyproject_for_cython_build(project_dir: Path, toml_config: TOMLDocument):
+        pyproject_path = project_dir / "pyproject.toml"
+        if pyproject_path.exists():
+            new_config = copy.deepcopy(toml_config)
+
+            # Add Cython build dependency
+            if 'build-system' not in new_config:
+                new_config['build-system'] = {}
+
+            if 'requires' not in new_config['build-system']:
+                new_config['build-system']['requires'] = []
+
+            cython_deps = ['setuptools', 'Cython']
+            requires = new_config['build-system']['requires']
+            for dep in cython_deps:
+                if not any(req.startswith(dep) for req in requires):
+                    new_config['build-system']['requires'].append(dep)
+
+            if 'build-backend' not in new_config['build-system'] or new_config['build-system'][
+                'build-backend'] != 'setuptools.build_meta':
+                new_config['build-system']['build-backend'] = 'setuptools.build_meta'
+            save_config(new_config, pyproject_path)
+
+    @staticmethod
+    def restore_pyproject_toml(project_dir: Path, original_toml_config: TOMLDocument):
+        pyproject_path = project_dir / "pyproject.toml"
+        if original_toml_config:
+            save_config(original_toml_config, pyproject_path)
+            logger.info("Restored original pyproject.toml")
+
+    @staticmethod
+    def create_setup_py_for_cython(project_dir: Path, toml_config: TOMLDocument):
+        if "authors" in toml_config["project"]:
+            author_names = ", ".join(p["name"] for p in toml_config["project"]["authors"] if "name" in p)
+            author_emails = ", ".join(p["email"] for p in toml_config["project"]["authors"] if "email" in p)
+        else:
+            author_names = ""
+            author_emails = ""
+        if "scripts" in toml_config["project"]:
+            entry_points = [f"{k}={v}" for k, v in toml_config["project"]["scripts"].items()]
+        else:
+            entry_points = []
+        setup_py_content = textwrap.dedent(f'''
+        import glob
+        from Cython.Build import cythonize
+        from setuptools import setup, find_packages
+        from setuptools.dist import Distribution
+        from setuptools.command.build_py import build_py as _build_py
+    
+        py_files = glob.glob("src/**/**/*.py", recursive=True)
+        py_files = [f for f in py_files if not f.endswith("__init__.py")]
+    
+        class build_py(_build_py):
+            def find_package_modules(self, package, package_dir):
+                modules = super().find_package_modules(package, package_dir)
+                if self.distribution.ext_modules:
+                    # Get the list of compiled module names
+                    compiled_modules = {{ext.name for ext in self.distribution.ext_modules}}
+                    # Filter out the modules that are compiled
+                    modules = [
+                        (pkg, mod, file) for (pkg, mod, file) in modules
+                        if f"{{pkg}}.{{mod}}" not in compiled_modules
+                    ]
+                return modules
+    
+        class BinaryDistribution(Distribution):
+            def has_ext_modules(self):
+                return True
+    
+        setup(
+            name="{toml_config["project"]["name"]}",
+            version="{toml_config["project"]["version"]}",
+            {f"author='{author_names}'," if author_names else ""}
+            {f"author_email='{author_emails}'," if author_emails else ""}
+            {f"description='{toml_config["project"]["description"]}'," if toml_config["project"].get("description", "") else ""}
+            {f"python_requires='{toml_config["project"]["requires-python"]}'," if toml_config["project"].get("requires-python") else ""}
+            {f"install_requires={toml_config["project"]["dependencies"]}," if toml_config["project"].get("dependencies") and len(toml_config["project"]["dependencies"]) > 0 else ""}
+            entry_points={{
+                'console_scripts': {entry_points}
+            }},
+            packages=find_packages(where="src"),
+            package_dir={{"": "src"}},
+            include_package_data=True,
+            ext_modules=cythonize(
+                py_files,
+                compiler_directives={{'language_level': "3"}},
+            ),
+            distclass=BinaryDistribution,
+            setup_requires=["cython>=3.1"],
+            cmdclass={{'build_py': build_py}},
+            zip_safe=False
+        )
+        ''').strip()
+
+        with open(project_dir / "setup.py", 'w') as f:
+            f.write(setup_py_content)

pkg_deploy/deploy.py

@@ -0,0 +1,276 @@
+import os
+import sys
+import glob
+import shutil
+import logging
+import argparse
+import subprocess
+from pathlib import Path
+
+from .upload import Upload, NexusUpload
+from .version_managment import VersionManager
+from .build import DeployConfig, CythonBuildStrategy, StandardBuildStrategy
+from .utils import get_pypirc_info, get_credentials, is_uv_venv, validate_version_arg
+
+
+logging.basicConfig(
+    level=logging.INFO,
+    format="%(asctime)s [%(levelname)-5.5s] [%(name)-30.30s] [%(lineno)-4.4s] [%(processName)-12.12s]: %(message)s"
+)
+logger = logging.getLogger(__name__)
+
+
+def parse_args(args):
+    parser = argparse.ArgumentParser(
+        description="Modern Python Package Deployment Tool",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog="""
+        Examples:
+          # Deploy to PyPI, patch version
+          python deploy.py --package-name my-package --version-type patch
+
+          # Deploy to private Nexus, using cython
+          python deploy.py --package-name my-package --version-type minor
+              --repository-url https://nexus.example.com/repository/pypi-internal/
+              --username admin
+              --password secret
+
+          # Dry run
+          python deploy.py --package-name my-package --version-type patch --dry-run
+          """)
+
+    parser.add_argument(
+        "--project-dir",
+        type=Path,
+        default=Path.cwd(),
+        help="Project directory (default: current directory)"
+    )
+
+    parser.add_argument(
+        "--version-type", "-vt",
+        default="patch",
+        help="Version bump type (default: patch)"
+    )
+
+    parser.add_argument(
+        "--new-version", "-v",
+        type=validate_version_arg,
+        help="New version number, if not specified, a new version will be resolved by version-type"
+    )
+
+    parser.add_argument(
+        "--cython", "-c",
+        action="store_true",
+        help="Use Cython for compilation"
+    )
+
+    parser.add_argument(
+        "--repository-name", "-rn",
+        help="Repository name (.pypirc)"
+    )
+
+    parser.add_argument(
+        "--repository-url", "-rl",
+        help="Repository URL"
+    )
+
+    parser.add_argument(
+        "--username", "-u",
+        help="Username for authentication"
+    )
+
+    parser.add_argument(
+        "--password", "-p",
+        help="Password for authentication"
+    )
+
+    parser.add_argument(
+        "--no-git-push",
+        action="store_true",
+        help="Push local changes to Git repository after build"
+    )
+
+    parser.add_argument(
+        "--interactive", "-i",
+        action="store_true",
+        help="Force interactive credential input (useful for Nexus)"
+    )
+
+    parser.add_argument(
+        "--dry-run",
+        action="store_true",
+        help="Perform a dry run without actual deployment"
+    )
+
+    parser.add_argument(
+        "--verbose", "-V",
+        action="store_true",
+        help="Enable verbose logging"
+    )
+
+    args = parser.parse_args(args)
+    if not args.repository_url and not args.repository_name:
+        parser.error("Either --repository-url or --repository-name must be provided.")
+    return args
+
+
+class PackageDeploy:
+    def __init__(self):
+        args = sys.argv[1:]
+        self.args = parse_args(args)
+        if not (self.args.project_dir / "pyproject.toml").exists():
+            raise ValueError("pyproject.toml not found")
+
+        if self.args.verbose:
+            logging.getLogger().setLevel(logging.DEBUG)
+
+        self.check_require_package(self.args.cython)
+
+        pypirc_info = get_pypirc_info()
+        repos = pypirc_info["repositories"]
+        if self.args.repository_name and self.args.repository_name in repos:
+            repository_info = repos[self.args.repository_name]
+            url = repository_info["repository"]
+            username = repository_info["username"]
+            password = repository_info["password"]
+        elif self.args.repository_name:
+            raise ValueError("Repository name is provided but not found in .pypirc")
+        else:
+            url = self.args.repository_url
+            username, password = get_credentials(self.args)
+
+        pyproject_path = self.args.project_dir / "pyproject.toml"
+
+        self.version_manager = VersionManager(pyproject_path)
+        self.config = DeployConfig(
+            package_name=self.version_manager.toml_config["project"]["name"],
+            project_dir=self.args.project_dir,
+            pyproject_path=pyproject_path,
+            version_type=self.args.version_type,
+            new_version=self.args.new_version,
+            use_cython=self.args.cython,
+            is_uv_venv=is_uv_venv(),
+            repository_name=self.args.repository_name,
+            repository_url=url,
+            username=username,
+            password=password,
+            dry_run=self.args.dry_run
+        )
+        self.setup_file_exist = (self.config.project_dir / "setup.py").exists()
+
+    def deploy(self):
+        logger.info("=== Deployment Configuration ===")
+        for arg_name, arg_value in vars(self.args).items():
+            display_value = arg_value
+            if arg_name in ('username', 'password') and arg_value is not None:
+                display_value = '***MASKED***'
+            logger.info(f"{arg_name}: {display_value}")
+        logger.info("=================================")
+        logger.info(f"Starting deployment")
+        try:
+            self.check_git_status()
+            new_version = self.version_manager.bump_version(version_type=self.config.version_type,
+                                                            new_version=self.config.new_version)
+            logger.info(f"New version: {new_version}")
+
+            if self.config.use_cython:
+                build_strategy = CythonBuildStrategy()
+            else:
+                build_strategy = StandardBuildStrategy()
+
+            uploaded = False
+            if build_strategy.build(self.config, self.version_manager.toml_config):
+                upload_strategy = self.get_upload_strategy(self.config)
+                dist_dir = self.config.project_dir / "dist"
+                uploaded = upload_strategy.upload(self.config, dist_dir)
+
+            self.cleanup_build()
+            if uploaded and not self.args.no_git_push:
+                self.git_push(new_version=new_version)
+            else:
+                self.git_roll_back()
+
+            logger.info('Deploy completed')
+        except Exception as e:
+            logger.error(f"Deployment failed: {e}", exc_info=True)
+            return False
+
+    @staticmethod
+    def check_require_package(cython: bool):
+        required_packages = ["build", "twine", "toml", "tomlkit"]
+        if cython:
+            required_packages.append("Cython")
+
+        missing_packages = []
+        for package in required_packages:
+            try:
+                __import__(package)
+            except ImportError:
+                missing_packages.append(package)
+
+        if missing_packages:
+            logger.error(f"Missing required packages: {', '.join(missing_packages)}")
+            logger.error(f"Install them with: pip install {' '.join(missing_packages)}")
+            raise ValueError("Missing required packages")
+
+    def cleanup_build(self):
+        logger.info('Deleting build, dist and egg-info files after deployment')
+        shutil.rmtree('dist', ignore_errors=True)
+        shutil.rmtree('build', ignore_errors=True)
+        shutil.rmtree(f'src/{self.config.package_name}.egg-info', ignore_errors=True)
+        egg_info_name = self.config.package_name.replace("-", "_")
+        shutil.rmtree(f'src/{egg_info_name}.egg-info', ignore_errors=True)
+        launcher_dir = os.path.dirname(os.path.abspath(sys.argv[0]))
+        directory = os.path.join(launcher_dir, 'src', self.config.package_name.replace("-", "_"))
+        c_files = glob.glob(os.path.join(directory, '**', '*.c'), recursive=True)
+        if not self.setup_file_exist:
+            Path("setup.py").unlink(missing_ok=True)
+        for file_path in c_files:
+            Path(file_path).unlink(missing_ok=True)
+
+    def check_git_status(self):
+        logger.info("Checking git status, --porcelain to make sure git repo is clean")
+        result = subprocess.run(
+            ["git", "status", "--porcelain"],
+            cwd=self.config.project_dir,
+            capture_output=True,
+            text=True
+        )
+        if result.returncode != 0:
+            raise IOError(f"Git command failed: {result.stderr.strip()}")
+        if result.stdout.strip():
+            raise IOError(f"Git repo is NOT clean: \n{result.stdout}")
+
+    @staticmethod
+    def git_push(new_version: str):
+        try:
+            subprocess.check_output(['git', 'add', '.'], stderr=subprocess.STDOUT)
+            subprocess.check_output(['git', 'commit', '-m', f'Bump version to {new_version}'], stderr=subprocess.STDOUT)
+            tag_name = f"v{new_version}"
+            subprocess.check_output(['git', 'tag', '-a', tag_name, '-m', f'Release {tag_name}'], stderr=subprocess.STDOUT)
+            logger.info(f"Created Git tag: {tag_name}")
+            subprocess.check_output(['git', 'push', '--follow-tags'], stderr=subprocess.STDOUT)
+            logger.info('Pushing to github')
+        except subprocess.CalledProcessError as ex:
+            logger.error(f"Git command failed: {ex.output.decode()}")
+            logger.warning('Failed to push bump version commit. Please push manually.')
+        except Exception as ex:
+            logger.error(f"Unexpected error: {ex}")
+            logger.warning('Failed to push bump version commit. Please push manually.')
+
+    @staticmethod
+    def git_roll_back():
+        try:
+            subprocess.check_output(['git', 'restore', '.'], stderr=subprocess.STDOUT)
+            logger.info('Restored changes')
+        except subprocess.CalledProcessError as ex:
+            logger.error(f"Git command failed: {ex.output.decode()}")
+        except Exception as ex:
+            logger.error(f"Unexpected error: {ex}")
+            logger.warning('Failed to roll back changes. Please roll back manually.')
+
+    @staticmethod
+    def get_upload_strategy(config) -> Upload:
+        return NexusUpload()
+
+

pkg_deploy/upload.py

@@ -0,0 +1,70 @@
+#!/usr/bin/env python3
+import sys
+import logging
+import subprocess
+from pathlib import Path
+from abc import ABC, abstractmethod
+
+from .build import DeployConfig
+
+
+logger = logging.getLogger(__name__)
+
+
+class Upload(ABC):
+    """Deploy Base class"""
+
+    @abstractmethod
+    def upload(self, config: DeployConfig, dist_dir: Path) -> bool:
+        pass
+
+
+class NexusUpload(Upload):
+    """Nexus Deploy"""
+
+    @staticmethod
+    def get_wheel_files(config: DeployConfig):
+        wheel_files = []
+        for binary in (config.project_dir / 'dist').iterdir():
+            if config.package_name.replace("-", "_") in binary.name and binary.suffix == '.whl':
+                wheel_files.append(binary.name)
+        if len(wheel_files) != 1:
+            raise ValueError(f"Unable to determine wheel, candidates are: {wheel_files}")
+        wheel_file = wheel_files[0]
+        logger.info(f"Built {wheel_file}")
+        return wheel_file
+
+    def upload(self, config: DeployConfig, dist_dir: Path) -> bool:
+        try:
+            if not config.repository_url:
+                raise ValueError("Repository URL is required for Nexus deployment")
+
+            wheel_file = self.get_wheel_files(config)
+
+            if config.dry_run:
+                cmd = [sys.executable, "-m", "twine", "check",
+                       f"dist/{wheel_file}"
+                       ]
+            else:
+                cmd = [sys.executable, "-m", "twine", "upload",
+                       "--repository-url", config.repository_url,
+                       f"dist/{wheel_file}",
+                       "--disable-progress-bar"
+                       ]
+                if config.username:
+                    cmd.extend(["--username", config.username])
+                if config.password:
+                    cmd.extend(["--password", config.password])
+
+            logger.info(f"Running: {' '.join(cmd)}")
+            result = subprocess.run(cmd, capture_output=True, text=True)
+
+            if result.returncode != 0:
+                raise ValueError(f"Nexus build failed, \nstdout: {result.stdout}\nstderr: {result.stderr}")
+
+            logger.info("Package deployed to Nexus successfully")
+            return True
+
+        except Exception as e:
+            logger.error(f"Nexus deploy error: {e}")
+            return False

pkg_deploy/utils.py

@@ -0,0 +1,238 @@
+import os
+import re
+import sys
+import shutil
+import tomlkit
+import logging
+import getpass
+import argparse
+import subprocess
+import configparser
+from pathlib import Path
+from typing import Optional
+from tomlkit.toml_document import TOMLDocument
+
+
+logger = logging.getLogger(__name__)
+
+
+def is_uv_venv() -> bool:
+    """Detect if the current virtual environment was created by uv (supports versioned marker)."""
+    if not hasattr(sys, 'prefix') or not sys.prefix:
+        return False
+    pyvenv_cfg = Path(sys.prefix) / "pyvenv.cfg"
+    if not pyvenv_cfg.exists():
+        return False
+    try:
+        with open(pyvenv_cfg, "r", encoding="utf-8") as f:
+            for line in f:
+                line = line.strip()
+                if line.lower().startswith("uv ="):
+                    logger.info("Detected uv-managed Python.")
+                    return True
+    except Exception:
+        pass
+    return False
+
+def setup_uv_compatibility():
+    if is_uv_venv():
+        logger.info("Setting PIP_USE_VIRTUALENV=1 for build compatibility.")
+        os.environ["PIP_USE_VIRTUALENV"] = "1"
+        return True
+    else:
+        return False
+
+
+def get_credentials(args) -> tuple[Optional[str], Optional[str]]:
+    username = args.username
+    password = args.password
+    is_pypi = args.repository_name and "pypi" in args.repository_name.lower()
+    force_interactive = args.interactive
+
+    if is_pypi:
+        logger.info(" Detected PyPI repository - API tokens are recommended over passwords")
+
+    if not args.dry_run and (force_interactive or (not username and not password)):
+        logger.info(f"\n Repository Authentication Required")
+        if is_pypi:
+            logger.info(f"PyPI Repository: https://pypi.org/")
+            logger.info(" Tip: Use API tokens instead of passwords for better security")
+        else:
+            logger.info(f"Repository: {args.repository_url}")
+        logger.info("-" * 60)
+
+    if is_pypi:
+        logger.info("For PyPI API tokens, use '__token__' as username")
+        username_input = input("Username (default: __token__): ").strip()
+        username = username_input if username_input else "__token__"
+    else:
+        username_input = input("Username (default: admin): ").strip()
+        username = username_input if username_input else "admin"
+
+    if username:
+        logger.info(f"Using username: {username}")
+
+    if username == "__token__":
+        password = getpass.getpass("API Token (pypi-...): ")
+    else:
+        password = getpass.getpass("Password: ")
+
+    if not password:
+        logger.info(f"Password/Token cannot be empty")
+        raise ValueError("Password/Token cannot be empty")
+
+    return username, password
+
+
+def parse_prerelease(version: str):
+    # Match the pattern: numbers.numbers.numbers + optional prerelease type + optional version
+    pattern = r'^(\d+)\.(\d+)\.(\d+)([abc]|rc)?(\d*)$'
+    match = re.match(pattern, version)
+
+    if match:
+        major = int(match.group(1))
+        minor = int(match.group(2))
+        patch = int(match.group(3))
+        prerelease_type = match.group(4)  # None if no prerelease
+
+        if prerelease_type and match.group(5):
+            prerelease_version = int(match.group(5))
+        elif prerelease_type:
+            prerelease_version = 1
+        else:
+            prerelease_version = None
+
+        return {
+            'major': major,
+            'minor': minor,
+            'patch': patch,
+            'prerelease_type': prerelease_type,
+            'prerelease_version': prerelease_version,
+            'has_prerelease': prerelease_type is not None
+        }
+    else:
+        raise ValueError(f"Invalid version format: {version}")
+
+
+def get_pypirc_info():
+    """
+    Read and parse .pypirc file from user's home directory.
+    Returns a dictionary with repository configurations.
+    """
+    # Get the path to .pypirc file
+    home_dir = Path.home()
+    pypirc_path = home_dir / '.pypirc'
+
+    if not pypirc_path.exists():
+        raise FileNotFoundError(f"No .pypirc file found at {pypirc_path}")
+
+    # Parse the configuration file
+    config = configparser.ConfigParser()
+
+    try:
+        config.read(pypirc_path)
+
+        # Extract information
+        pypirc_info = {}
+
+        # Get index servers if available
+        if config.has_section('distutils') and config.has_option('distutils', 'index-servers'):
+            index_servers = config.get('distutils', 'index-servers').split()
+            pypirc_info['index_servers'] = index_servers
+
+        # Get repository configurations
+        repositories = {}
+        for section_name in config.sections():
+            if section_name != 'distutils':
+                repo_config = {}
+                for option in config.options(section_name):
+                    repo_config[option] = config.get(section_name, option)
+                repositories[section_name] = repo_config
+        if not repositories:
+            raise ValueError(f"No repositories configuration found in {pypirc_path}")
+
+        pypirc_info['repositories'] = repositories
+        return pypirc_info
+    except Exception as e:
+        logger.error(f"Error reading .pypirc file: {e}")
+        return None
+
+def ensure_uv_installed():
+    """Check if 'uv' is available, and install it if not."""
+    if shutil.which("uv"):
+        logger.info("uv is already installed and available in PATH.")
+        return
+
+    try:
+        result = subprocess.run(
+            [sys.executable, "-m", "uv", "--version"],
+            capture_output=True,
+            text=True,
+            check=True
+        )
+        logger.info(f"uv is installed as a module: {result.stdout.strip()}")
+        return
+    except (subprocess.CalledProcessError, FileNotFoundError):
+        pass  # uv not available as module either
+
+    logger.info("uv not found. Installing uv via pip...")
+    try:
+        subprocess.run(
+            [sys.executable, "-m", "pip", "install", "uv"],
+            check=True,
+            capture_output=True,
+            text=True
+        )
+        logger.info("uv installed successfully.")
+    except subprocess.CalledProcessError as e:
+        logger.error("Failed to install uv:", e.stderr)
+        raise RuntimeError(
+            "Failed to install uv automatically. Please install it manually:\n"
+            "  pip install uv\n"
+            "Or download from: https://github.com/astral-sh/uv/releases"
+        ) from e
+
+    try:
+        result = subprocess.run(
+            [sys.executable, "-m", "uv", "--version"],
+            capture_output=True,
+            text=True,
+            check=True
+        )
+        logger.info(f"uv version: {result.stdout.strip()}")
+    except subprocess.CalledProcessError as e:
+        raise RuntimeError("uv installed but failed to run.") from e
+
+
+def load_config(pyproject_path: Path) -> TOMLDocument:
+    """load pyproject.toml"""
+    if not pyproject_path.exists():
+        raise FileNotFoundError(f"pyproject.toml not found at {pyproject_path}")
+
+    with open(pyproject_path, "r", encoding="utf-8") as f:
+        content = f.read()
+    config = tomlkit.parse(content)
+    return config
+
+
+def save_config(config, pyproject_path: Path):
+    with open(pyproject_path, 'w', encoding='utf-8') as f:
+        f.write(tomlkit.dumps(config))
+
+
+def validate_version_arg(value: str) -> str:
+    """
+    Custom argparse validator that checks if a version string conforms to SemVer.
+    Returns the value if valid, raises an error otherwise.
+    """
+    version_pattern = re.compile(r"^\d+\.\d+\.\d+(a\d+|b\d+|rc\d+)?$")
+
+    if not version_pattern.match(value):
+        raise argparse.ArgumentTypeError(
+            f"Invalid version format: '{value}'. Valid examples:\n"
+            "  Final release: 1.2.0\n"
+            "  Alpha release: 1.2.0a1\n"
+            "  Beta release: 1.2.0b1\n"
+            "  Release candidate: 1.2.0rc1"
+        )
+    return value

pkg_deploy/version_managment.py

@@ -0,0 +1,143 @@
+import logging
+from pathlib import Path
+from typing import Optional
+
+from .utils import parse_prerelease, load_config, save_config
+
+
+logger = logging.getLogger(__name__)
+
+
+class VersionManager:
+    """Version Manager"""
+
+    def __init__(self, pyproject_path: Path):
+        self.pyproject_path = pyproject_path
+        self.toml_config = load_config(pyproject_path)
+
+    def get_current_version(self) -> str:
+        return str(self.toml_config['project']['version'])
+
+    @staticmethod
+    def resolve_new_version(current_version: str, version_type: str) -> str:
+        version_info = parse_prerelease(current_version)
+        major = version_info['major']
+        minor = version_info['minor']
+        patch = version_info['patch']
+        prerelease_type = version_info['prerelease_type']
+        prerelease_version = version_info['prerelease_version']
+        has_prerelease = version_info['has_prerelease']
+
+        # Handle version bumping
+        if version_type == 'patch':
+            prerelease_type = None
+            patch += 1
+        elif version_type == 'minor':
+            minor += 1
+            patch = 0
+            prerelease_type = None
+        elif version_type == 'major':
+            major += 1
+            minor = 0
+            patch = 0
+            prerelease_type = None
+        elif version_type == 'alpha':
+            if has_prerelease:
+                if prerelease_type == 'a':
+                    prerelease_version += 1
+                else:
+                    prerelease_type = 'a'
+                    prerelease_version = 1
+            else:
+                prerelease_type = 'a'
+                prerelease_version = 1
+        elif version_type == 'beta':
+            if has_prerelease:
+                if prerelease_type == 'a':
+                    prerelease_type = 'b'
+                    prerelease_version = 1
+                elif prerelease_type == 'b':
+                    prerelease_version += 1
+                else:
+                    prerelease_type = 'b'
+                    prerelease_version = 1
+            else:
+                prerelease_type = 'b'
+                prerelease_version = 1
+        elif version_type == 'rc':
+            if has_prerelease:
+                if prerelease_type in ['a', 'b']:
+                    prerelease_type = 'rc'
+                    prerelease_version = 1
+                elif prerelease_type == 'rc':
+                    prerelease_version += 1
+            else:
+                prerelease_type = 'rc'
+                prerelease_version = 1
+        else:
+            raise ValueError(f"Invalid version type: {version_type}")
+
+        if prerelease_type:
+            new_version = f"{major}.{minor}.{patch}{prerelease_type}{prerelease_version}"
+        else:
+            new_version = f"{major}.{minor}.{patch}"
+        return new_version
+
+    def bump_version(self, version_type: str, new_version: Optional[str]=None) -> str:
+        current_version = self.get_current_version()
+        if new_version is None:
+            new_version = self.resolve_new_version(current_version, version_type)
+        # Update pyproject.toml
+        self.toml_config['project']['version'] = new_version
+        save_config(self.toml_config, self.pyproject_path)
+        # Update files configured under [tool.bumpversion.file]
+        self.update_bumpversion_files(current_version, new_version)
+
+        logger.info(f"Version bumped from {current_version} to {new_version}")
+        return new_version
+
+    def update_bumpversion_files(self, current_version: str, new_version: str) -> None:
+        """Update files configured in [tool.bumpversion.file] section."""
+        bumpversion_config = self.toml_config.get('tool', {}).get('bumpversion', {})
+        files = bumpversion_config.get('file', [])
+
+        # If 'file' is a single dict, make it a list
+        if isinstance(files, dict):
+            files = [files]
+
+        for file_config in files:
+            filename = file_config.get('filename')
+            if filename == "pyproject.toml":
+                continue
+            search = file_config.get('search', '{current_version}')
+            replace = file_config.get('replace', '{new_version}')
+
+            if not filename:
+                logger.warning("Skipping bumpversion file entry with no 'filename'")
+                continue
+
+            file_path = Path(filename)
+            if not file_path.exists():
+                logger.warning(f"File {filename} not found, skipping.")
+                continue
+
+            # Read file content
+            content = file_path.read_text(encoding='utf-8')
+
+            # Replace placeholders
+            old_str = search.format(current_version=current_version)
+            new_str = replace.format(new_version=new_version)
+
+            # Escape for literal string replacement (not regex)
+            if old_str not in content:
+                logger.warning(f"Search pattern '{old_str}' not found in {filename}, skipping.")
+                continue
+
+            new_content = content.replace(old_str, new_str)
+
+            # Write back only if changed
+            if new_content != content:
+                file_path.write_text(new_content, encoding='utf-8')
+                logger.info(f"Updated {filename}: '{old_str}' → '{new_str}'")
+            else:
+                logger.debug(f"No changes needed in {filename}")

pkg_deploy-1.0.0.dist-info/METADATA

@@ -0,0 +1,15 @@
+Metadata-Version: 2.4
+Name: pkg-deploy
+Version: 1.0.0
+Summary: Modern Python Package Deployment Tool
+Author: cw
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: toml
+Requires-Dist: tomlkit
+Requires-Dist: build
+Requires-Dist: twine
+Requires-Dist: Cython
+Requires-Dist: setuptools>=70
+
+# Description

pkg_deploy-1.0.0.dist-info/RECORD

@@ -0,0 +1,10 @@
+pkg_deploy/__init__.py,sha256=AMFvImM9PajO30Tl53kK6lhL-tZCIq5xTCkWZPrbwUw,58
+pkg_deploy/build.py,sha256=zRg_Hfz_7XRaVvp17N1WEs7dhC77Fao2cvnuh_H5PbA,7450
+pkg_deploy/deploy.py,sha256=lmABig0rerySTPklcK-koBZLXhaYS5UAZ22fGgaXHns,10438
+pkg_deploy/upload.py,sha256=XcB-lArBvNsijoJmrgIHkXodJh4ziUNP5xMJ2wbW7O4,2370
+pkg_deploy/utils.py,sha256=pYfbeii4nvX9Adpkm_XCStKhn1fHQR5LKiMacCRAo2o,8094
+pkg_deploy/version_managment.py,sha256=qLqeNlOTvwP7shnAJYwE5hzTXaCYiyUvtVJ8xsI_ivk,5499
+pkg_deploy-1.0.0.dist-info/METADATA,sha256=VudheNT551T2RyLiu5KfamaWgRsdHx-eL6lp_13nXoo,343
+pkg_deploy-1.0.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+pkg_deploy-1.0.0.dist-info/top_level.txt,sha256=-yi8c2TJ5e9J3QATUf7_dRfmJp2gzHR_VvnEc7QgFM0,11
+pkg_deploy-1.0.0.dist-info/RECORD,,

pkg_deploy-1.0.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.9.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

pkg_deploy-1.0.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+pkg_deploy