deployfilegen 0.1.21__tar.gz

deployfilegen-0.1.21/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Shankarsan Sahoo
+
+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.

deployfilegen-0.1.21/PKG-INFO

@@ -0,0 +1,153 @@
+Metadata-Version: 2.4
+Name: deployfilegen
+Version: 0.1.21
+Summary: A production-grade CLI tool to generate deployment configuration files for Django/React projects.
+Author-email: Shankarsan Sahoo <shankarsansahoo2001@gmail.com>
+License: MIT License
+        
+        Copyright (c) 2026 Shankarsan Sahoo
+        
+        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.
+        
+Project-URL: Homepage, https://github.com/Shankarsan-Sahoo/deployfilegen
+Project-URL: Repository, https://github.com/Shankarsan-Sahoo/deployfilegen.git
+Project-URL: Issues, https://github.com/Shankarsan-Sahoo/deployfilegen/issues
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: typer[all]
+Requires-Dist: python-dotenv
+Requires-Dist: pytest
+Dynamic: license-file
+
+# deployfilegen
+
+**deployfilegen** is a production-grade Python CLI library designed to automatically generate production-ready deployment configuration files for full-stack applications (Django + React).
+
+Writing Dockerfiles, Compose configs, and CI pipelines repeatedly is slow and error-prone. **deployfilegen** automates this process using secure, battle-tested defaults.
+
+## Quick Start
+
+```bash
+# 1. Install the tool
+pip install deployfilegen
+
+# 2. Initialize your project
+deployfilegen init
+
+# 3. Deploy locally
+docker compose -f docker-compose.prod.yml up --build
+```
+
+---
+
+## Why deployfilegen?
+
+Standardizing deployment is hard. This tool ensures your project follows industry best practices out of the box:
+- **Security**: All containers run as non-root users.
+- **Reliability**: Automated healthchecks and dependency waiting.
+- **CI/CD**: Complete GitHub Actions workflow with Docker layer caching.
+- **Zero Hardcoding**: All configuration is derived from your `.env` files.
+
+---
+
+## Example Project Structure
+
+The tool expects a standard full-stack layout:
+
+```text
+my-cool-project/
+├── backend/            # Django project
+│   └── manage.py
+├── frontend/           # React project
+│   └── package.json
+└── .env                # Required environment variables
+```
+
+---
+
+## CLI Output Example
+
+```text
+$ deployfilegen init
+INFO: Initializing deployfilegen in /path/to/project (Mode: prod)
+INFO: Detected Django backend.
+INFO: Detected React frontend.
+INFO: Loaded environment from: .env
+INFO: Generating Backend Dockerfile...
+INFO: Generated backend/Dockerfile
+INFO: Generating Frontend Dockerfile...
+INFO: Generated frontend/Dockerfile
+INFO: Generating Docker Compose...
+INFO: Generated docker-compose.prod.yml
+INFO: Generating GitHub Actions workflow...
+INFO: Generated .github/workflows/deploy.yml
+INFO: Deployment configuration generated successfully!
+```
+
+---
+
+## Usage
+
+Navigate to your project root and run:
+
+```bash
+# Generate a boilerplate .env template
+deployfilegen template
+
+# Initialize your project
+deployfilegen init [OPTIONS]
+```
+
+### Commands
+
+*   `init`: Initialize deployment configuration.
+*   `template`: Generate a boilerplate `.env` file.
+
+### Global Options
+- `--version`, `-v`: Show the version and exit.
+- `--help`: Show this message and exit.
+
+### `init` Command Options
+
+| Option | Description |
+| :--- | :--- |
+| `--mode prod` | Generates `docker-compose.prod.yml` (Default). Optimized for servers. |
+| `--mode dev` | Generates `docker-compose.dev.yml`. Optimized for local coding. |
+| `--force`, `-f` | Overwrite existing files. (Default: skips existing files). |
+| `--docker-only` | Generate only the Dockerfiles. |
+| `--compose-only` | Generate only the Docker Compose files. |
+| `--github-only` | Generate only the GitHub Actions workflow. |
+| `--backend-only` | Filter generation to only Backend components. |
+| `--frontend-only` | Filter generation to only Frontend components. |
+
+---
+
+## Requirements
+
+- Python 3.9+
+- A project structure with a Django-based `backend` and a React-based `frontend`.
+- A `.env` file containing: `DOCKER_USERNAME`, `BACKEND_IMAGE_NAME`, `FRONTEND_IMAGE_NAME`, `DEPLOY_HOST`, and `DEPLOY_USER`.
+
+## License
+
+MIT

deployfilegen-0.1.21/README.md

@@ -0,0 +1,112 @@
+# deployfilegen
+
+**deployfilegen** is a production-grade Python CLI library designed to automatically generate production-ready deployment configuration files for full-stack applications (Django + React).
+
+Writing Dockerfiles, Compose configs, and CI pipelines repeatedly is slow and error-prone. **deployfilegen** automates this process using secure, battle-tested defaults.
+
+## Quick Start
+
+```bash
+# 1. Install the tool
+pip install deployfilegen
+
+# 2. Initialize your project
+deployfilegen init
+
+# 3. Deploy locally
+docker compose -f docker-compose.prod.yml up --build
+```
+
+---
+
+## Why deployfilegen?
+
+Standardizing deployment is hard. This tool ensures your project follows industry best practices out of the box:
+- **Security**: All containers run as non-root users.
+- **Reliability**: Automated healthchecks and dependency waiting.
+- **CI/CD**: Complete GitHub Actions workflow with Docker layer caching.
+- **Zero Hardcoding**: All configuration is derived from your `.env` files.
+
+---
+
+## Example Project Structure
+
+The tool expects a standard full-stack layout:
+
+```text
+my-cool-project/
+├── backend/            # Django project
+│   └── manage.py
+├── frontend/           # React project
+│   └── package.json
+└── .env                # Required environment variables
+```
+
+---
+
+## CLI Output Example
+
+```text
+$ deployfilegen init
+INFO: Initializing deployfilegen in /path/to/project (Mode: prod)
+INFO: Detected Django backend.
+INFO: Detected React frontend.
+INFO: Loaded environment from: .env
+INFO: Generating Backend Dockerfile...
+INFO: Generated backend/Dockerfile
+INFO: Generating Frontend Dockerfile...
+INFO: Generated frontend/Dockerfile
+INFO: Generating Docker Compose...
+INFO: Generated docker-compose.prod.yml
+INFO: Generating GitHub Actions workflow...
+INFO: Generated .github/workflows/deploy.yml
+INFO: Deployment configuration generated successfully!
+```
+
+---
+
+## Usage
+
+Navigate to your project root and run:
+
+```bash
+# Generate a boilerplate .env template
+deployfilegen template
+
+# Initialize your project
+deployfilegen init [OPTIONS]
+```
+
+### Commands
+
+*   `init`: Initialize deployment configuration.
+*   `template`: Generate a boilerplate `.env` file.
+
+### Global Options
+- `--version`, `-v`: Show the version and exit.
+- `--help`: Show this message and exit.
+
+### `init` Command Options
+
+| Option | Description |
+| :--- | :--- |
+| `--mode prod` | Generates `docker-compose.prod.yml` (Default). Optimized for servers. |
+| `--mode dev` | Generates `docker-compose.dev.yml`. Optimized for local coding. |
+| `--force`, `-f` | Overwrite existing files. (Default: skips existing files). |
+| `--docker-only` | Generate only the Dockerfiles. |
+| `--compose-only` | Generate only the Docker Compose files. |
+| `--github-only` | Generate only the GitHub Actions workflow. |
+| `--backend-only` | Filter generation to only Backend components. |
+| `--frontend-only` | Filter generation to only Frontend components. |
+
+---
+
+## Requirements
+
+- Python 3.9+
+- A project structure with a Django-based `backend` and a React-based `frontend`.
+- A `.env` file containing: `DOCKER_USERNAME`, `BACKEND_IMAGE_NAME`, `FRONTEND_IMAGE_NAME`, `DEPLOY_HOST`, and `DEPLOY_USER`.
+
+## License
+
+MIT

deployfilegen-0.1.21/deployfilegen/__init__.py

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

deployfilegen-0.1.21/deployfilegen/analyzer/detector.py

@@ -0,0 +1,37 @@
+from pathlib import Path
+from deployfilegen.exceptions import DetectionError, ProjectStructureError
+from deployfilegen.utils.logger import logger
+
+def detect_django_backend(project_root: Path) -> Path:
+    """
+    Detects Django backend by checking for manage.py.
+    Returns path to backend directory.
+    """
+    backend_path = project_root / "backend"
+    manage_py = backend_path / "manage.py"
+    
+    if not backend_path.exists():
+        raise ProjectStructureError(f"Backend directory not found at: {backend_path}")
+        
+    if not manage_py.exists():
+        raise DetectionError(f"Django not detected: {manage_py} is missing.")
+        
+    logger.info("Detected Django backend.")
+    return backend_path
+
+def detect_react_frontend(project_root: Path) -> Path:
+    """
+    Detects React frontend by checking for package.json.
+    Returns path to frontend directory.
+    """
+    frontend_path = project_root / "frontend"
+    package_json = frontend_path / "package.json"
+    
+    if not frontend_path.exists():
+        raise ProjectStructureError(f"Frontend directory not found at: {frontend_path}")
+        
+    if not package_json.exists():
+        raise DetectionError(f"React not detected: {package_json} is missing.")
+        
+    logger.info("Detected React frontend.")
+    return frontend_path

deployfilegen-0.1.21/deployfilegen/cli.py

@@ -0,0 +1,185 @@
+import typer
+from pathlib import Path
+from typing import Optional
+
+from deployfilegen.utils.logger import logger
+from deployfilegen.utils.writer import FileWriter
+from deployfilegen.config.env_loader import load_environment, validate_environment
+from deployfilegen.analyzer.detector import detect_django_backend, detect_react_frontend
+from deployfilegen.generators.backend import generate_backend_dockerfile, generate_entrypoint_script
+from deployfilegen.generators.frontend import generate_frontend_dockerfile
+from deployfilegen.generators.compose import generate_docker_compose
+from deployfilegen.generators.github import generate_github_workflow
+from deployfilegen.exceptions import DeployFileGenError, EnvConfigError
+from deployfilegen import __version__
+
+app = typer.Typer(no_args_is_help=True)
+
+def version_callback(value: bool):
+    if value:
+        typer.echo(__version__)
+        raise typer.Exit()
+
+@app.callback()
+def main_callback(
+    version: Optional[bool] = typer.Option(
+        None, "--version", "-v", callback=version_callback, is_eager=True, help="Show the version and exit."
+    ),
+):
+    """
+    A production-grade CLI tool to generate deployment configuration files.
+    """
+    pass
+
+@app.command(name="init")
+def init(
+    mode: str = typer.Option("prod", help="Generation mode: 'prod' or 'dev'"),
+    force: bool = typer.Option(False, "--force", "-f", help="Overwrite existing files"),
+    docker_only: bool = typer.Option(False, "--docker-only", help="Generate only Dockerfiles"),
+    compose_only: bool = typer.Option(False, "--compose-only", help="Generate only Docker Compose"),
+    github_only: bool = typer.Option(False, "--github-only", help="Generate only GitHub Actions"),
+    backend_only: bool = typer.Option(False, "--backend-only", help="Generate only for Backend"),
+    frontend_only: bool = typer.Option(False, "--frontend-only", help="Generate only for Frontend"),
+    with_db: bool = typer.Option(False, "--with-db", help="Include a Postgres database service in Docker Compose"),
+):
+    """
+    Initialize deployment configuration for the current project.
+    """
+    try:
+        project_root = Path.cwd()
+        # 1. Config & Validation
+        load_environment(project_root)
+        config = validate_environment()
+
+        # 2. Detection
+        try:
+            backend_path = detect_django_backend(project_root)
+            backend_detected = True
+        except DeployFileGenError:
+            backend_path = None
+            backend_detected = False
+
+        try:
+            frontend_path = detect_react_frontend(project_root)
+            frontend_detected = True
+        except DeployFileGenError:
+            frontend_path = None
+            frontend_detected = False
+
+        # 3. Initialization
+        writer = FileWriter(force=force)
+
+        # Targeted Logic
+        any_type_flag = docker_only or compose_only or github_only
+        do_docker = docker_only or not any_type_flag
+        do_compose = compose_only or not any_type_flag
+        do_github = github_only or not any_type_flag
+
+        any_comp_flag = backend_only or frontend_only
+        do_backend = backend_only or not any_comp_flag
+        do_frontend = frontend_only or not any_comp_flag
+
+        # 4. Generate Backend Dockerfile
+        if do_docker and do_backend and backend_detected:
+            typer.echo("Generating Backend Dockerfile...")
+            backend_docker = generate_backend_dockerfile(mode, backend_path)
+            if writer.write(backend_path / "Dockerfile", backend_docker):
+                typer.echo("Generated backend/Dockerfile")
+            writer.write(backend_path / ".dockerignore", "venv/\n__pycache__/\n*.pyc\n.git/\n.env\nstatic/\ntests/\n")
+
+            # Generate entrypoint.sh for production
+            if mode == "prod":
+                entrypoint_content = generate_entrypoint_script()
+                if writer.write(backend_path / "entrypoint.sh", entrypoint_content):
+                    typer.echo("Generated backend/entrypoint.sh")
+
+        # 5. Generate Frontend Dockerfile
+        if do_docker and do_frontend and frontend_detected:
+            typer.echo("Generating Frontend Dockerfile...")
+            frontend_docker = generate_frontend_dockerfile(mode)
+            if writer.write(frontend_path / "Dockerfile", frontend_docker):
+                typer.echo("Generated frontend/Dockerfile")
+            writer.write(frontend_path / ".dockerignore", "node_modules/\nbuild/\ncoverage/\n.git/\n.env\n")
+
+        # 6. Generate docker-compose.yml
+        if do_compose:
+            typer.echo("Generating Docker Compose...")
+            compose_content = generate_docker_compose(mode, config, with_db=with_db)
+            compose_filename = "docker-compose.prod.yml" if mode == "prod" else "docker-compose.dev.yml"
+            if writer.write(project_root / compose_filename, compose_content):
+                typer.echo(f"Generated {compose_filename}")
+
+        # 7. Generate GitHub Actions
+        if do_github:
+            typer.echo("Generating GitHub Actions workflow...")
+            github_workflow = generate_github_workflow(config)
+            github_dir = project_root / ".github" / "workflows"
+            if writer.write(github_dir / "deploy.yml", github_workflow):
+                typer.echo("Generated .github/workflows/deploy.yml")
+
+        typer.echo("Deployment configuration generated successfully!")
+        
+        # Runtime Success Checklist
+        typer.echo("\n--- 🏁 Deployment Success Checklist ---")
+        typer.echo("1. Connection: Ensure your server can reach the internet and your Container Registry.")
+        if with_db:
+             typer.echo("2. Database: Configured for INTERNAL Postgres service.")
+        else:
+             typer.echo("2. Database: Configured for EXTERNAL database. Ensure DATABASE_URL is set.")
+
+        typer.echo(f"3. Environment: Confirm your server's .env matches the generated template.")
+        typer.echo("4. Images: Ensure build images are pushed to your Registry before deploying.")
+        typer.echo("--------------------------------------")
+
+    except EnvConfigError as e:
+        typer.echo(f"Error: {e}")
+        typer.echo("Tip: Run 'deployfilegen template' to generate a boilerplate .env file.")
+        raise typer.Exit(code=1)
+    except DeployFileGenError as e:
+        logger.info("Error: {e}")
+        raise typer.Exit(code=1)
+    except Exception as e:
+        logger.exception(f"Unexpected Error: {e}")
+        raise typer.Exit(code=1)
+
+@app.command(name="template")
+def generate_template(
+    force: bool = typer.Option(False, "--force", "-f", help="Overwrite existing .env file")
+):
+    """
+    Generate a boilerplate .env file with required placeholders.
+    """
+    try:
+        project_root = Path.cwd()
+        env_path = project_root / ".env"
+        
+        template_content = """# deployfilegen Environment Template
+# Fill in these values for production deployment
+
+# Container Registry Credentials (e.g. Docker Hub, GHCR)
+DOCKER_USERNAME=your_username
+
+# Image Names (e.g. username/repo)
+BACKEND_IMAGE_NAME=your_docker_username/backend_image
+FRONTEND_IMAGE_NAME=your_docker_username/frontend_image
+
+# Deployment Server
+DEPLOY_HOST=your_server_ip
+DEPLOY_USER=your_ssh_user
+"""
+        writer = FileWriter(force=force)
+        writer.write(env_path, template_content)
+        typer.echo("Generated boilerplate .env file. Please fill in the values.")
+        
+    except DeployFileGenError as e:
+        logger.info(f"Error: {e}")
+        raise typer.Exit(code=1)
+    except Exception as e:
+        logger.exception(f"Unexpected Error: {e}")
+        raise typer.Exit(code=1)
+
+def main():
+    app()
+
+if __name__ == "__main__":
+    main()

deployfilegen-0.1.21/deployfilegen/config/env_loader.py

@@ -0,0 +1,60 @@
+import os
+from pathlib import Path
+from dotenv import load_dotenv
+from typing import List, Dict
+
+from deployfilegen.exceptions import EnvConfigError
+from deployfilegen.utils.logger import logger
+
+REQUIRED_ENV_VARS = [
+    "DOCKER_USERNAME",
+    "BACKEND_IMAGE_NAME",
+    "FRONTEND_IMAGE_NAME",
+    "DEPLOY_HOST",
+    "DEPLOY_USER",
+]
+
+def load_environment(project_root: Path) -> None:
+    """
+    Loads .env files in layered order:
+    1. project-root/.env
+    2. backend/.env
+    3. frontend/.env
+    
+    Later files override earlier ones.
+    """
+    env_files = [
+        project_root / ".env",
+        project_root / "backend" / ".env",
+        project_root / "frontend" / ".env",
+    ]
+    
+    loaded = False
+    for env_file in env_files:
+        if env_file.exists():
+            load_dotenv(env_file, override=True)
+            logger.info(f"Loaded environment from: {env_file}")
+            loaded = True
+            
+    if not loaded:
+        raise EnvConfigError("No .env files found in likely locations.")
+
+def validate_environment() -> Dict[str, str]:
+    """
+    Validates that all required environment variables are set.
+    Returns a dictionary of the variables.
+    """
+    missing = []
+    config = {}
+    
+    for var in REQUIRED_ENV_VARS:
+        value = os.getenv(var)
+        if not value:
+            missing.append(var)
+        else:
+            config[var] = value
+            
+    if missing:
+        raise EnvConfigError(f"Missing required environment variables: {', '.join(missing)}")
+        
+    return config

deployfilegen-0.1.21/deployfilegen/exceptions.py

@@ -0,0 +1,19 @@
+class DeployFileGenError(Exception):
+    """Base exception for deployfilegen."""
+    pass
+
+class ProjectStructureError(DeployFileGenError):
+    """Raised when project structure is invalid (missing backend/frontend)."""
+    pass
+
+class DetectionError(DeployFileGenError):
+    """Raised when framework detection fails."""
+    pass
+
+class EnvConfigError(DeployFileGenError):
+    """Raised when .env configuration is missing or invalid."""
+    pass
+
+class GenerationError(DeployFileGenError):
+    """Raised when file generation fails."""
+    pass