pkg-deploy 1.0.12__py3-none-any.whl

pkg_deploy/upload.py

@@ -0,0 +1,81 @@
+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 = []
+        dist_dir = config.project_dir / 'dist'
+        for binary in dist_dir.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"No wheel files found under {config.project_dir / 'dist'}")
+        else:
+            logger.info(f"Built {len(wheel_files)} wheel files: {wheel_files}")
+            for file in wheel_files:
+                file_path = dist_dir / file
+                size_bytes = file_path.stat().st_size
+                size_mb = size_bytes / (1024 * 1024)
+                logger.info(f"Found valid package wheel: {file} ({size_mb:.2f} MB)")
+        return wheel_files
+
+    def upload(self, config: DeployConfig, dist_dir: Path) -> bool:
+        try:
+            cmd = [sys.executable, "-m", "twine", "upload",
+                   "--disable-progress-bar",
+                   "--verbose"
+                   ]
+
+            wheel_files = self.get_wheel_files(config)
+            wheel_paths = [str(dist_dir / wheel_file) for wheel_file in wheel_files]
+            cmd.extend(wheel_paths)
+
+            if config.repository_name != "pypi":
+                cmd.extend(["--repository-url", config.repository_url])
+
+            cmd.extend(["--username", config.username])
+            cmd.extend(["--password", config.password])
+
+            # Create masked command for logging
+            masked_cmd = []
+            for i, arg in enumerate(cmd):
+                if i > 0 and cmd[i - 1] == "--password":
+                    masked_cmd.append("******")
+                else:
+                    masked_cmd.append(arg)
+
+            logger.info(f"Running: {' '.join(masked_cmd)}")
+
+            if config.dry_run:
+                logger.info(f"DRY RUN: wheel files from dist directory: {wheel_files}")
+                logger.info(f"DRY RUN: cmd: {cmd}")
+            else:
+                result = subprocess.run(cmd, capture_output=True, text=True)
+                if result.returncode != 0:
+                    raise ValueError(f"Upload failed, \nstdout: {result.stdout}\nstderr: {result.stderr}")
+                logger.info(f"Package uploaded to {config.repository_url} successfully")
+            return True
+        except Exception as e:
+            logger.error(f"Package upload error: {e}")
+            return False

pkg_deploy/utils.py

@@ -0,0 +1,227 @@
+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, Tuple
+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(username: Optional[str] = None,
+                    password: Optional[str] = None,
+                    url: str = "",
+                    is_pypi: bool = False
+                    ) -> Tuple[Optional[str], Optional[str]]:
+    is_pypi = "upload.pypi.org" in url or is_pypi
+    if not username:
+        if is_pypi:
+            logger.info("For PyPI API tokens, use '__token__' as username")
+            username = "__token__"
+        else:
+            username = input(f"Please enter username for {url}:").strip()
+
+    if not username:
+        raise ValueError("Username cannot be empty")
+
+    logger.info(f"Using username: {username}")
+
+    if not password:
+        if is_pypi:
+            password = getpass.getpass("PyPI API token: ")
+        else:
+            password = getpass.getpass(f"Please enter password for {url}:")
+
+    if not password:
+        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,147 @@
+import logging
+from pathlib import Path
+from typing import Optional
+
+from tomlkit import TOMLDocument
+
+from .utils import parse_prerelease, load_config, save_config
+
+
+logger = logging.getLogger(__name__)
+
+
+class VersionManager:
+    """Version Manager"""
+
+    def __init__(self, pyproject_path: Path, toml_config: TOMLDocument):
+        self.pyproject_path = pyproject_path
+        self.toml_config = toml_config
+
+    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, dry_run: bool = False) -> str:
+        current_version = self.get_current_version()
+        if new_version is None:
+            new_version = self.resolve_new_version(current_version, version_type)
+        
+        if not dry_run:
+            # 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}")