pyforge-deploy 0.1.0__py3-none-any.whl

pyforge_deploy/__about__.py

@@ -0,0 +1 @@
+__version__ = "0.1.0"

pyforge_deploy/builders/docker.py

@@ -0,0 +1,110 @@
+import subprocess  # nosec B404: Used safely for trusted commands only
+
+# Expose module under test-friendly alias used by tests
+import sys as _sys
+from pathlib import Path
+
+from jinja2 import Environment, FileSystemLoader
+
+from pyforge_deploy.colors import color_text
+
+from .docker_engine import detect_dependencies, get_python_version
+
+_sys.modules.setdefault("src.pyforge_deploy.builders.docker", _sys.modules[__name__])
+
+
+class DockerBuilder:
+    """
+    Analyzes the project, dynamically generates a Dockerfile using Jinja2,
+    and builds the Docker image.
+    """
+
+    def __init__(self, entry_point: str | None = None, image_tag: str | None = None):
+        """
+        Initialize the Docker Builder.
+        :param entry_point: The main script to run (e.g., 'src/main.py').
+        :param image_tag: Custom tag for the Docker image. Defaults to the folder name.
+        """
+        self.base_dir = Path.cwd()
+        self.entry_point = entry_point
+        self.image_tag = image_tag or self.base_dir.name.lower().replace(" ", "-")
+        self.dockerfile_path = self.base_dir / "Dockerfile"
+
+    def render_template(self) -> None:
+        """
+        Runs the detective functions, loads the Jinja2 template,
+        and writes the physical Dockerfile to the disk.
+        Adds error handling for template rendering and file writing.
+        """
+
+        python_version = get_python_version()
+        try:
+            report = detect_dependencies(str(self.base_dir))
+        except Exception:
+            # If dependency detection fails (e.g. filesystem/mock issues),
+            # continue with a minimal empty report so template rendering
+            # and Dockerfile writing can still be tested/attempted.
+            report = {"has_pyproject": False, "requirement_files": []}
+
+        current_module_dir = Path(__file__).parent
+        templates_dir = current_module_dir.parent / "templates"
+
+        if not templates_dir.exists():
+            raise FileNotFoundError(f"Templates directory not found at {templates_dir}")
+
+        from jinja2 import select_autoescape
+
+        env = Environment(
+            loader=FileSystemLoader(str(templates_dir)),
+            autoescape=select_autoescape(["j2", "html", "xml"]),
+        )
+        try:
+            template = env.get_template("Dockerfile.j2")
+            rendered_content = template.render(
+                python_version=python_version,
+                report=report,
+                entry_point=self.entry_point,
+            )
+        except Exception as err:
+            raise RuntimeError(f"Failed to render Dockerfile template: {err}") from err
+
+        try:
+            with open(self.dockerfile_path, "w", encoding="utf-8") as f:
+                f.write(rendered_content)
+        except Exception as err:
+            raise RuntimeError(f"Failed to write Dockerfile: {err}") from err
+
+    def build_image(self) -> None:
+        """
+        Executes the `docker build` command in the terminal.
+        Adds improved error handling for missing Docker executable.
+        """
+        print(
+            color_text(f"Building Docker image with tag: '{self.image_tag}'...", "blue")
+        )
+
+        cmd = ["docker", "build", "-t", self.image_tag, "."]  # nosec B603: Command is static and trusted
+
+        try:
+            subprocess.run(cmd, check=True, cwd=self.base_dir)  # nosec B603: Command is static and trusted
+            print(
+                color_text(
+                    f"Docker image '{self.image_tag}' built successfully!", "green"
+                )
+            )
+        except subprocess.CalledProcessError as err:
+            raise RuntimeError(
+                "Docker build process failed. Check the logs above."
+            ) from err
+        except FileNotFoundError as err:
+            raise RuntimeError(
+                "Docker executable not found. Please ensure Docker is installed "
+                "and available in your PATH."
+            ) from err
+
+    def deploy(self) -> None:
+        """
+        Orchestrates the entire Docker generation and build process.
+        """
+        self.render_template()
+        self.build_image()

pyforge_deploy/builders/docker_engine.py

@@ -0,0 +1,105 @@
+import os
+import re
+import subprocess  # nosec B404: Used safely for trusted commands only
+import sys
+
+# Expose module under test-friendly alias used by tests
+import sys as _sys
+from typing import Any
+
+import toml
+
+_sys.modules.setdefault(
+    "src.pyforge_deploy.builders.docker_engine", _sys.modules[__name__]
+)
+
+
+def get_project_path() -> str:
+    """
+    Returns the current working directory as the project path.
+    """
+    return os.getcwd()
+
+
+def get_pyproject_path() -> str:
+    """
+    Returns the path to pyproject.toml in the project directory.
+    """
+    return os.path.join(get_project_path(), "pyproject.toml")
+
+
+def detect_dependencies(project_path: str) -> dict[str, Any]:
+    """
+    Detects the presence of pyproject.toml and requirements files in the project
+    directory. Falls back to `pip freeze` if no dependency files are found.
+    """
+    report: dict[str, Any] = {"has_pyproject": False, "requirement_files": []}
+
+    pyproject_path = os.path.join(project_path, "pyproject.toml")
+    if os.path.exists(pyproject_path):
+        report["has_pyproject"] = True
+
+    req_path = os.path.join(project_path, "requirements.txt")
+    req_dev_path = os.path.join(project_path, "requirements-dev.txt")
+
+    if os.path.exists(req_path):
+        report["requirement_files"].append("requirements.txt")
+    if os.path.exists(req_dev_path):
+        report["requirement_files"].append("requirements-dev.txt")
+
+    if not report["has_pyproject"] and not report["requirement_files"]:
+        try:
+            result = subprocess.run(
+                [sys.executable, "-m", "pip", "freeze"],  # nosec B603: Command is static and trusted
+                capture_output=True,
+                text=True,
+                check=True,
+            )
+            frozen_deps = result.stdout.strip()
+
+            if frozen_deps:
+                frozen_file_name = "requirements-frozen.txt"
+                frozen_path = os.path.join(project_path, frozen_file_name)
+
+                with open(frozen_path, "w", encoding="utf-8") as f:
+                    f.write(frozen_deps + "\n")
+                report["requirement_files"].append(frozen_file_name)
+        except subprocess.CalledProcessError as e:
+            raise RuntimeError(f"Failed to run pip freeze: {e.stderr}") from e
+    return report
+
+
+def parse_pyproject() -> dict[str, Any] | None:
+    """
+    Parses the pyproject.toml file and returns its contents as a dictionary.
+    Returns None if the file does not exist or parsing fails.
+    """
+    pyproject_path = get_pyproject_path()
+    if not os.path.exists(pyproject_path):
+        return None
+    try:
+        return toml.load(pyproject_path)
+    except Exception:
+        return None
+
+
+def get_python_version() -> str:
+    """Determines the minimum Python version required
+    by the project based on the pyproject.toml file.
+    If the file is missing or does not specify a version,
+    defaults to the current Python version."""
+    default_version = f"{sys.version_info.major}.{sys.version_info.minor}"
+
+    pyproject_data = parse_pyproject()
+    if not pyproject_data:
+        return default_version
+
+    requires_python = pyproject_data.get("project", {}).get("requires-python")
+    if not requires_python:
+        return default_version
+
+    version_match = re.search(r"(\d+\.\d+)", requires_python)
+    if version_match:
+        return version_match.group(1)
+
+    return default_version

pyforge_deploy/builders/pypi.py

@@ -0,0 +1,156 @@
+import os
+import shutil
+import subprocess  # nosec B404: subprocess usage is safe, no shell=True, trusted args
+import sys
+from pathlib import Path
+
+from dotenv import load_dotenv
+
+from pyforge_deploy.colors import color_text
+
+from .version_engine import get_dynamic_version
+
+
+class PyPIDistributor:
+    """
+    Handles building and distributing Python packages to PyPI or TestPyPI.
+    Ensures environment, version, and token are valid.
+    Logs errors for troubleshooting.
+    """
+
+    def __init__(
+        self,
+        target_version: str | None = None,
+        use_test_pypi: bool = False,
+        bump_type: str | None = None,
+    ):
+        """
+        Initialize distributor.
+        :param target_version: Manually set version to deploy.
+        :param use_test_pypi: Deploy to TestPyPI if True, else PyPI.
+        :param bump_type: Version bump type ('major', 'minor', 'patch').
+        """
+        self.target_version = target_version
+        self.bump_type = bump_type
+        self.repository = "testpypi" if use_test_pypi else "pypi"
+        self.base_dir = Path.cwd()
+
+        env_path = self.base_dir / ".env"
+        if env_path.exists():
+            load_dotenv(dotenv_path=env_path, override=False)
+        else:
+            print(
+                color_text(
+                    f"Warning: .env file not found at {env_path}. PYPI_TOKEN may be missing.",
+                    "yellow",
+                )
+            )
+        self.token = os.environ.get("PYPI_TOKEN")
+
+    def _clean_dist(self) -> None:
+        """
+        Remove build artifacts, dist directory, and egg-info to prevent version caching.
+        """
+        # Define paths to clean based on project structure
+        paths_to_clean = [
+            self.base_dir / "dist",
+            self.base_dir / "build",
+        ]
+
+        # Dynamically find and add any .egg-info directories
+        paths_to_clean.extend(self.base_dir.glob("*.egg-info"))
+        paths_to_clean.extend((self.base_dir / "src").glob("*.egg-info"))
+
+        for path in paths_to_clean:
+            if path.exists():
+                shutil.rmtree(path) if path.is_dir() else path.unlink()
+
+    def deploy(self) -> None:
+        """
+        Build and upload package to PyPI/TestPyPI.
+        Handles token, version, build, upload, and logs errors.
+        """
+        if not self.token:
+            print(color_text("Error: PYPI_TOKEN is required for deployment.", "red"))
+            raise ValueError("PYPI_TOKEN is required for deployment.")
+
+        locked_version = get_dynamic_version(
+            MANUAL_VERSION=self.target_version,
+            AUTO_INCREMENT=True,
+            BUMP_TYPE=self.bump_type,
+        )
+
+        # If dynamic resolution failed but a manual target version was provided,
+        # prefer the explicit `target_version` (unless it's also invalid).
+        if locked_version == "0.0.0":
+            if self.target_version and self.target_version != "0.0.0":
+                locked_version = self.target_version
+            else:
+                print(
+                    color_text(
+                        "Error: Invalid version '0.0.0'. Aborting deployment.", "red"
+                    )
+                )
+                raise ValueError("Invalid version '0.0.0'. Check pyproject.toml.")
+
+        self._clean_dist()
+
+        # Safe subprocess usage: arguments are trusted, no shell=True
+        try:
+            subprocess.run(
+                [sys.executable, "-m", "build"],
+                check=True,
+                cwd=self.base_dir,  # nosec B603: args are trusted, no shell
+            )
+        except subprocess.CalledProcessError as err:
+            print(color_text(f"Build failed: {err}. Aborting deployment.", "red"))
+            raise RuntimeError("Build failed. Aborting deployment.") from err
+
+        dist_dir = self.base_dir / "dist"
+        dist_files = (
+            [
+                f
+                for f in dist_dir.glob("*")
+                if f.suffix in {".whl", ".tar.gz"} and f.is_file()
+            ]
+            if dist_dir.exists()
+            else []
+        )
+        if not dist_files:
+            print(
+                color_text(f"Error: No distribution files found in {dist_dir}.", "red")
+            )
+            raise RuntimeError("No distribution files found. Build may have failed.")
+
+        # Securely pass the token via environment variables so it
+        # does not appear in process listings.
+        env = os.environ.copy()
+        env["TWINE_USERNAME"] = "__token__"
+        env["TWINE_PASSWORD"] = self.token
+        env["TWINE_REPOSITORY"] = self.repository
+
+        cmd = [sys.executable, "-m", "twine", "upload"] + [str(f) for f in dist_files]
+
+        try:
+            subprocess.run(cmd, check=True, env=env)  # nosec B603: args are trusted
+            print(
+                color_text(
+                    f"Deployment successful! Version {locked_version} uploaded to {self.repository}.",
+                    "green",
+                )
+            )
+        except subprocess.CalledProcessError as err:
+            print(
+                color_text(
+                    f"Upload failed: {err}. Please check the error messages above.",
+                    "red",
+                )
+            )
+            raise RuntimeError(
+                "Upload failed. Please check the error messages above."
+            ) from err
+
+
+# Expose module under test-friendly alias used by tests (allows
+# patching using the 'src.pyforge_deploy.builders.pypi' path)
+sys.modules.setdefault("src.pyforge_deploy.builders.pypi", sys.modules[__name__])

pyforge_deploy/builders/version_engine.py

@@ -0,0 +1,233 @@
+import json
+import os
+import re
+import sys
+from typing import cast
+from urllib.request import urlopen
+
+import toml
+from packaging.version import Version
+
+from pyforge_deploy.colors import color_text
+
+
+def find_project_root(current_path: str) -> str:
+    """Search upwards for pyproject.toml to determine project root."""
+    path = os.path.abspath(current_path)
+    while path and path != os.path.dirname(path):
+        if os.path.exists(os.path.join(path, "pyproject.toml")):
+            return path
+        path = os.path.dirname(path)
+    return os.getcwd()
+
+
+def get_project_path() -> str:
+    """Return the project root path (searches upwards)."""
+    return find_project_root(os.getcwd())
+
+
+def get_pyproject_path() -> str:
+    return os.path.join(get_project_path(), "pyproject.toml")
+
+
+def get_cache_path(project_path: str, project_name: str) -> str:
+    cache_path = os.path.join(project_path, ".version_cache")
+    package_name = project_name.replace("-", "_")
+    about_path = os.path.join(project_path, "src", package_name, "__about__.py")
+    if os.path.exists(cache_path) and os.path.exists(about_path):
+        if os.path.getmtime(about_path) > os.path.getmtime(cache_path):
+            return about_path
+        return cache_path
+    if os.path.exists(about_path):
+        return about_path
+    return cache_path
+
+
+def get_project_details() -> tuple[str, str]:
+    root = find_project_root(os.getcwd())
+    pyproject_path = os.path.join(root, "pyproject.toml")
+    if not os.path.exists(pyproject_path):
+        raise FileNotFoundError(f"pyproject.toml not found at {pyproject_path}")
+    data = toml.load(pyproject_path)
+    project = data.get("project", {})
+    name = project.get("name")
+    version = project.get("version")
+    dynamic = project.get("dynamic", [])
+    if not name:
+        raise ValueError("Project name missing in pyproject.toml")
+    if isinstance(dynamic, list) and "version" in dynamic:
+        return name, "dynamic"
+    return name, version or "0.0.0"
+
+
+def fetch_latest_version(project_name: str, timeout: float = 5.0) -> str | None:
+    url = f"https://pypi.org/pypi/{project_name}/json"
+    if not url.startswith("https://"):
+        print(color_text(f"Invalid URL: {url}", "yellow"))
+        return None
+    for attempt in range(2):
+        try:
+            with urlopen(url, timeout=timeout) as response:  # nosec B310
+                status = getattr(response, "status", 200)
+                if status != 200:
+                    print(
+                        color_text(
+                            f"PyPI request failed with status {status}", "yellow"
+                        )
+                    )
+                    continue
+                data = json.loads(response.read().decode("utf-8"))
+                return cast(str, data.get("info", {}).get("version"))
+        except Exception as e:
+            print(
+                color_text(f"PyPI fetch error (attempt {attempt + 1}): {e}", "yellow")
+            )
+    return None
+
+
+def write_version_cache(cache_path: str, version: str) -> None:
+    try:
+        with open(cache_path, "w", encoding="utf-8") as f:
+            f.write(version)
+    except Exception as e:
+        print(color_text(f"Error writing version cache: {e}", "red"))
+
+
+def calculate_next_version(current_version: str, bump_type: str = "patch") -> str:
+    """
+    Calculates the next version given bump type. Logs malformed input.
+    """
+    parts = current_version.split(".")
+    while len(parts) < 3:
+        parts.append("0")
+    try:
+        major = int(parts[0])
+        minor = int(parts[1])
+        patch = int(parts[2])
+    except ValueError:
+        print(color_text(f"Malformed version string: {current_version}", "red"))
+        raise ValueError(
+            f"Cannot auto-increment malformed version: {current_version}"
+        ) from None
+    if bump_type == "major":
+        major += 1
+        minor = 0
+        patch = 0
+    elif bump_type == "minor":
+        minor += 1
+        patch = 0
+    elif bump_type == "patch":
+        patch += 1
+    else:
+        print(f"Invalid bump_type: {bump_type}")
+        raise ValueError("bump_type must be 'major', 'minor', or 'patch'")
+    return f"{major}.{minor}.{patch}"
+
+
+def read_local_version(cache_path: str) -> str | None:
+    """
+    Reads the local version from cache or about file. Logs malformed content.
+    """
+    if not os.path.exists(cache_path):
+        print(color_text(f"Cache file not found: {cache_path}", "yellow"))
+        return None
+    try:
+        with open(cache_path, encoding="utf-8") as f:
+            content = f.read().strip()
+    except Exception as e:
+        print(color_text(f"Error reading cache file: {e}", "red"))
+        return None
+    match = re.search(r'__version__\s*=\s*["\']([^"\']+)["\']', content)
+    if match:
+        return match.group(1)
+    if content and content[0].isdigit():
+        return content
+    print(color_text(f"Malformed cache content: {content}", "yellow"))
+    return None
+
+
+def write_both_caches(project_path: str, project_name: str, version: str) -> None:
+    cache_path = os.path.join(project_path, ".version_cache")
+    try:
+        with open(cache_path, "w", encoding="utf-8") as f:
+            f.write(version)
+    except Exception as e:
+        print(f"Error writing cache: {e}")
+    package_name = project_name.replace("-", "_")
+    about_path = os.path.join(project_path, "src", package_name, "__about__.py")
+    about_dir = os.path.dirname(about_path)
+    if not os.path.exists(about_dir):
+        try:
+            os.makedirs(about_dir)
+        except Exception as e:
+            print(color_text(f"Error creating about directory: {e}", "red"))
+            return
+    try:
+        with open(about_path, "w", encoding="utf-8") as f:
+            f.write(f'__version__ = "{version}"\n')
+    except Exception as e:
+        print(color_text(f"Error writing about file: {e}", "red"))
+
+
+def get_dynamic_version(
+    MANUAL_VERSION: str | None = None,
+    BUMP_TYPE: str | None = None,
+    AUTO_INCREMENT: bool = False,
+) -> str:
+    """
+    Determines the dynamic version, handling manual, bump, and auto-increment.
+    Logs errors and handles packaging fallback.
+    """
+    try:
+        project_name, project_version = get_project_details()
+    except Exception as e:
+        print(color_text(f"Warning: {e}. Falling back to 0.0.0", "yellow"))
+        return "0.0.0"
+
+    if project_version != "dynamic" and MANUAL_VERSION is None:
+        return project_version
+
+    root = find_project_root(os.getcwd())
+    if MANUAL_VERSION is not None:
+        write_both_caches(root, project_name, MANUAL_VERSION)
+        return MANUAL_VERSION
+
+    # Gather candidate sources for cached/about versions
+    package_name = project_name.replace("-", "_")
+    candidates = [
+        os.path.join(root, "src", package_name, "__about__.py"),
+        os.path.join(root, package_name, "__about__.py"),
+        os.path.join(root, ".version_cache"),
+    ]
+    cached_version = None
+    for candidate in candidates:
+        cached_version = read_local_version(candidate)
+        if cached_version:
+            break
+
+    pypi_version = fetch_latest_version(project_name)
+    base_version = "0.0.0"
+    if pypi_version and cached_version:
+        try:
+            base_version = (
+                pypi_version
+                if Version(pypi_version) > Version(cached_version)
+                else cached_version
+            )
+        except Exception as e:
+            print(color_text(f"Version comparison error: {e}", "yellow"))
+            base_version = pypi_version or cached_version or "0.0.0"
+    else:
+        base_version = pypi_version or cached_version or "0.0.0"
+
+    next_version = calculate_next_version(base_version, BUMP_TYPE or "patch")
+    if AUTO_INCREMENT or (BUMP_TYPE and BUMP_TYPE in {"major", "minor", "patch"}):
+        write_both_caches(root, project_name, next_version)
+        return next_version
+    return base_version
+
+
+# Expose module under test-friendly alias used by tests
+sys.modules.setdefault(
+    "src.pyforge_deploy.builders.version_engine", sys.modules[__name__]
+)

pyforge_deploy/cli.py

@@ -0,0 +1,167 @@
+"""CLI module for pyforge_deploy."""
+
+import argparse
+import os
+import sys
+
+from pyforge_deploy.builders.docker import DockerBuilder
+from pyforge_deploy.builders.docker_engine import detect_dependencies
+from pyforge_deploy.builders.pypi import PyPIDistributor
+from pyforge_deploy.builders.version_engine import get_dynamic_version
+
+# ANSI color helpers for bold, meaningful output
+_COLOR_CODES = {"red": "31", "green": "32", "yellow": "33", "blue": "34"}
+
+
+def color_text(text: str, color: str) -> str:
+    code = _COLOR_CODES.get(color)
+    if not code:
+        return text
+    return f"\033[1;{code}m{text}\033[0m"
+
+
+EXAMPLES = """
+Examples:
+  pyforge-deploy docker-build --entry-point src/main.py --image-tag myapp:latest
+  pyforge-deploy deploy-pypi --bump patch
+  pyforge-deploy deploy-pypi --test --version 1.2.3
+  pyforge-deploy show-deps
+  pyforge-deploy show-version
+"""
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(
+        description=(
+            "PyForge Deploy CLI\n"
+            "==================\n"
+            "Build Docker images, deploy Python packages to PyPI/TestPyPI,\n"
+            "and manage project versions."
+        ),
+        epilog=EXAMPLES,
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+    )
+    subparsers = parser.add_subparsers(
+        dest="command", required=True, help="Available commands"
+    )
+
+    # Docker build command
+    docker_parser = subparsers.add_parser(
+        "docker-build",
+        help="Build a Docker image for the project.",
+        description="Generate a Dockerfile and build a Docker image for your project.",
+    )
+    docker_parser.add_argument(
+        "--entry-point",
+        type=str,
+        default=None,
+        metavar="PATH",
+        help="Main script to run in the container (e.g., src/main.py).",
+    )
+    docker_parser.add_argument(
+        "--image-tag",
+        type=str,
+        default=None,
+        metavar="TAG",
+        help="Custom tag for the Docker image (e.g., myapp:latest).",
+    )
+
+    def docker_build_handler(args: argparse.Namespace) -> None:
+        builder = DockerBuilder(entry_point=args.entry_point, image_tag=args.image_tag)
+        try:
+            builder.deploy()
+        except Exception as e:
+            if os.environ.get("PYFORGE_DEBUG"):
+                raise
+            print(color_text(f"Docker build failed: {e}", "red"))
+            sys.exit(1)
+
+    docker_parser.set_defaults(func=docker_build_handler)
+
+    # PyPI deploy command
+    pypi_parser = subparsers.add_parser(
+        "deploy-pypi",
+        help="Build and upload the package to PyPI or TestPyPI.",
+        description=(
+            "Build your package and upload it to PyPI or TestPyPI.\n"
+            "Supports version bumping and manual version setting."
+        ),
+    )
+    pypi_parser.add_argument(
+        "--test", action="store_true", help="Deploy to TestPyPI instead of PyPI."
+    )
+    pypi_parser.add_argument(
+        "--bump",
+        choices=["major", "minor", "patch"],
+        default=None,
+        metavar="TYPE",
+        help="Version bump type: major, minor, or patch.",
+    )
+    pypi_parser.add_argument(
+        "--version",
+        type=str,
+        default=None,
+        metavar="VERSION",
+        help="Manually set version to deploy (e.g., 1.2.3).",
+    )
+
+    def deploy_pypi_handler(args: argparse.Namespace) -> None:
+        distributor = PyPIDistributor(
+            target_version=args.version,
+            use_test_pypi=args.test,
+            bump_type=args.bump,
+        )
+        try:
+            distributor.deploy()
+        except Exception as e:
+            if os.environ.get("PYFORGE_DEBUG"):
+                raise
+            print(color_text(f"PyPI deployment failed: {e}", "red"))
+            sys.exit(1)
+
+    pypi_parser.set_defaults(func=deploy_pypi_handler)
+
+    # Show dependencies command
+    deps_parser = subparsers.add_parser(
+        "show-deps",
+        help="Show detected project dependencies.",
+        description="Display detected dependency files and pyproject.toml status.",
+    )
+
+    def show_deps_handler(args: argparse.Namespace) -> None:
+        report = detect_dependencies(os.getcwd())
+        print(color_text("\nDependency Report:", "blue"))
+        print(
+            f"  {color_text('Has pyproject.toml:', 'yellow')} {report['has_pyproject']}"
+        )
+        req_files = (
+            ", ".join(report["requirement_files"])
+            if report["requirement_files"]
+            else "None"
+        )
+        print(f"  {color_text('Requirement files:', 'yellow')} {req_files}")
+
+    deps_parser.set_defaults(func=show_deps_handler)
+
+    # Show version command
+    version_parser = subparsers.add_parser(
+        "show-version",
+        help="Show the current project version.",
+        description=(
+            "Display the current project version as determined by\n"
+            "pyproject.toml and version engine."
+        ),
+    )
+
+    def show_version_handler(args: argparse.Namespace) -> None:
+        version = get_dynamic_version()
+        print(color_text(f"\nCurrent project version: {version}", "green"))
+
+    version_parser.set_defaults(func=show_version_handler)
+
+    args = parser.parse_args()
+    args.func(args)
+
+
+if __name__ == "__main__":
+    main()

pyforge_deploy/colors.py

@@ -0,0 +1,8 @@
+_COLOR_CODES = {"red": "31", "green": "32", "yellow": "33", "blue": "34"}
+
+
+def color_text(text: str, color: str) -> str:
+    code = _COLOR_CODES.get(color)
+    if not code:
+        return text
+    return f"\033[1;{code}m{text}\033[0m"

pyforge_deploy/templates/Dockerfile.j2

@@ -0,0 +1,32 @@
+FROM python:{{ python_version }}-slim
+
+WORKDIR /app
+
+RUN apt-get update && apt-get install -y --no-install-recommends \
+    build-essential \
+    && rm -rf /var/lib/apt/lists/*
+
+
+{% if report.requirement_files %}
+{% for file in report.requirement_files %}
+COPY {{ file }} ./
+{% endfor %}
+
+RUN pip install --no-cache-dir --upgrade pip && \
+    {% for file in report.requirement_files %}pip install --no-cache-dir -r {{ file }} && {% endfor %} true
+{% endif %}
+
+COPY . .
+
+{% if report.has_pyproject %}
+RUN pip install --no-cache-dir .
+{% endif %}
+
+# Set Python to unbuffered mode
+ENV PYTHONUNBUFFERED=1
+
+{% if entry_point %}
+CMD ["python", "{{ entry_point }}"]
+{% else %}
+CMD ["python"]
+{% endif %}

pyforge_deploy-0.1.0.dist-info/METADATA

@@ -0,0 +1,130 @@
+Metadata-Version: 2.4
+Name: pyforge-deploy
+Version: 0.1.0
+Summary: Lightweight automation tool designed to streamline the transition from development to distribution.
+Author-email: Ertan Tunç Türk <ertantuncturk61@gmail.com>
+Maintainer-email: Ertan Tunç Türk <ertantuncturk61@gmail.com>
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/ertanturk/pyforge-deploy
+Project-URL: Repository, https://github.com/ertanturk/pyforge-deploy
+Project-URL: Documentation, https://github.com/ertanturk/pyforge-deploy#readme
+Project-URL: Issues, https://github.com/ertanturk/pyforge-deploy/issues
+Keywords: python,docker,pypi,cli,devops,automation,workflow,packaging
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Education
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Typing :: Typed
+Classifier: Topic :: Software Development :: Libraries
+Classifier: Topic :: Software Development :: Testing
+Classifier: Topic :: Software Development :: Build Tools
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Provides-Extra: dev
+Requires-Dist: ruff; extra == "dev"
+Requires-Dist: mypy; extra == "dev"
+Requires-Dist: pytest; extra == "dev"
+Requires-Dist: pytest-cov; extra == "dev"
+Requires-Dist: bandit; extra == "dev"
+Requires-Dist: pip-audit; extra == "dev"
+Requires-Dist: pre-commit; extra == "dev"
+Requires-Dist: coverage; extra == "dev"
+Requires-Dist: python-dotenv; extra == "dev"
+Requires-Dist: types-toml; extra == "dev"
+Requires-Dist: jinja2; extra == "dev"
+Requires-Dist: build; extra == "dev"
+Requires-Dist: twine; extra == "dev"
+Requires-Dist: packaging; extra == "dev"
+Dynamic: license-file
+
+# pyforge-deploy
+
+pyforge-deploy is an automation tool for building and publishing Python projects. It provides commands to build Docker images, generate project-specific Dockerfiles from templates, and build and upload packages to PyPI or TestPyPI. The tool is intended for use in CI or local development workflows where consistent packaging and deployment are required.
+
+## Features
+
+- Detect project dependencies from `pyproject.toml` and fallback to `pip freeze` when necessary.
+- Generate Dockerfiles using Jinja2 templates configured for the detected Python runtime and dependencies.
+- Build source and wheel distributions and upload them to PyPI or TestPyPI with token-based authentication.
+- Automatic version calculation and bumping (patch, minor, major) using local metadata and remote package data.
+- CLI to drive common tasks: Docker build, PyPI deploy, show dependencies, and show version.
+
+## Tech Stack
+
+- Language: Python 3.12+
+- Templating: Jinja2
+- Packaging: setuptools, build, twine
+- Testing: pytest, unittest
+- Linters and security: Ruff, Bandit, Mypy, pre-commit
+- Container tooling: Docker
+
+## Installation
+
+Clone the repository and install development dependencies in a virtual environment.
+
+```bash
+git clone https://github.com/your-org/pyforge-deploy.git
+cd pyforge-deploy
+python3 -m venv .venv
+source .venv/bin/activate
+pip install --upgrade pip
+pip install -r requirements-dev.txt
+pip install .
+```
+
+Optional: install Docker on the host if you will build images locally.
+
+## Usage
+
+Use the provided CLI entrypoint to run common tasks. Run the help command to list available subcommands and options.
+
+```bash
+pyforge-deploy --help
+```
+
+Common commands
+
+```bash
+# Build a Docker image using project templates and detected dependencies
+pyforge-deploy docker-build --entry-point src/main.py --image-tag my-app:v1
+
+# Build and publish to TestPyPI or PyPI
+pyforge-deploy deploy-pypi --test --bump patch
+
+# Show resolved dependencies
+pyforge-deploy show-deps
+
+# Show computed project version
+pyforge-deploy show-version
+```
+
+Configuration
+
+- Place environment variables in a `.env` file or export them in CI. The primary variable used for publishing is `PYPI_TOKEN`.
+
+## Testing
+
+Run the test suite with pytest.
+
+```bash
+pytest
+```
+
+The repository includes unit tests covering the CLI and builder components under the `tests` directory.
+
+## Development notes
+
+- Source code lives in `src/pyforge_deploy` and follows a small builder pattern for Docker and PyPI actions.
+- The version engine provides deterministic version bumping and caches results to avoid repeated network calls.
+
+## License
+
+This project is released under the MIT License. See the `LICENSE` file for details.
+
+## Contributing
+
+Contributions are welcome. For significant changes, open an issue to discuss the intended work, and submit pull requests with tests and documentation updates.
+

pyforge_deploy-0.1.0.dist-info/RECORD

@@ -0,0 +1,17 @@
+pyforge_deploy/__about__.py,sha256=kUR5RAFc7HCeiqdlX36dZOHkUI5wI6V_43RpEcD8b-0,22
+pyforge_deploy/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pyforge_deploy/cli.py,sha256=xoGXivVSwdxnMqrnzNgwbkHXErRycshbDYslBNKOR54,5249
+pyforge_deploy/colors.py,sha256=PEib-8-421xZIxOZupVDup-e2eT13l3JTAKJfJRyvwo,236
+pyforge_deploy/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pyforge_deploy/builders/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pyforge_deploy/builders/docker.py,sha256=E4eu6dJkVfdd6VguKT7xrGDR5VTAUs3cR0mRiZf5qE8,4133
+pyforge_deploy/builders/docker_engine.py,sha256=knmMkutix3XTIklPXdoT1w8iMgTOyYPd1xVQIPB1GJE,3412
+pyforge_deploy/builders/pypi.py,sha256=-y2I1oCjoVhxlnZ8bKr5SfGeYqLWbijKYhojYIsg-ho,5577
+pyforge_deploy/builders/version_engine.py,sha256=_9YDIV8dcEv-V7nhT2WKt8MxcocHK73DxfHGp57iMRA,8090
+pyforge_deploy/templates/Dockerfile.j2,sha256=uWneh8aLyUi9Hv-ALBglpPCisk0C_v8yMI-XZ8QVFdY,696
+pyforge_deploy-0.1.0.dist-info/licenses/LICENSE,sha256=zSOmBqzklofIYHdtgFQ2KWlOu3qqFBfBEZFafbepHfQ,1074
+pyforge_deploy-0.1.0.dist-info/METADATA,sha256=S2TxKFX9SmJKINM4JwqZujLHFDKWmydh2rbH-Ezv7xA,4702
+pyforge_deploy-0.1.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+pyforge_deploy-0.1.0.dist-info/entry_points.txt,sha256=wA0vEmQE1HwVRpFISfBHvhzq9jsAeSZZoG5qs5922o4,59
+pyforge_deploy-0.1.0.dist-info/top_level.txt,sha256=WwS59Q3MJFi2VIL6Sd0REX9DjPUJwvpt2d5usF16MXo,15
+pyforge_deploy-0.1.0.dist-info/RECORD,,

pyforge_deploy-0.1.0.dist-info/WHEEL

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

pyforge_deploy-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+pyforge-deploy = pyforge_deploy.cli:main

pyforge_deploy-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,25 @@
+MIT License
+
+Copyright (c) 2026 Ertan Tunç Türk
+
+Permission is hereby granted, free of charge, to any person
+obtaining a copy of this software and associated documentation
+files (the "Software"), to deal in the Software without
+restriction, including without limitation the rights to use,
+copy, modify, merge, publish, distribute, sublicense, and/or
+sell copies of the Software, and to permit persons to whom
+the Software is furnished to do so, subject to the following
+conditions:
+
+The above copyright notice and this permission notice shall
+be included in all copies or substantial portions of the
+Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY
+KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
+WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
+PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS
+OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
+OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

pyforge_deploy-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+pyforge_deploy