init-app 0.1.0__py3-none-any.whl

create_app/__init__.py

@@ -0,0 +1,101 @@
+__version__ = "1.0.0"
+
+APP_NAME = "py-create"
+APP_TAGLINE = "Python Backend Project Generator"
+
+# ✅ Supported Frameworks
+FRAMEWORKS = [
+    "Python",
+    "Flask",
+    "FastAPI",
+    "Django",
+    "Bottle",
+    "Falcon",
+    "Tornado",
+    "Pyramid",
+    "Sanic",
+]
+
+# ✅ Project Types for specialized Frameworks (Flask, FastAPI, etc.)
+# We use "Standard" as the default high-quality starting point
+PROJECT_STRUCTURES = ["Standard", "Production"]
+
+STRUCTURE_DESCRIPTIONS = {
+    "Standard": "Clean, modern foundation with essential configurations",
+    "Production": "Enterprise-ready layout with tests, logs, and advanced scaling",
+}
+
+# ✅ Django Specifics
+DJANGO_PROJECT_TYPES = ["Standard", "drf"]
+
+DJANGO_DESCRIPTIONS = {
+    "Standard": "Full Django project with default configuration",
+    "drf": "Django project with REST Framework ready for API development",
+}
+
+# ✅ Python Specifics (The "Swiss Army Knife" category)
+PYTHON_PROJECT_TYPES = [
+    "Standard",               # Basic clean setup
+    "CLI Application",        # Command-line tool structure
+    "Library",                # PyPI-ready package structure
+    "ML Labs",                # Data Science (TF, PyHive, MLflow)
+]
+
+PYTHON_DESCRIPTIONS = {
+    "Standard": "Refined universal foundation with a clean structure",
+    "CLI Application": "Professional CLI tool structure (Click/Rich integrated)",
+    "Library": "Standardized PyPI-ready package structure (PEP 621)",
+    "ML Labs": "Modern Data Science lab (TensorFlow, PyHive, MLflow tracking)",
+}
+
+# ✅ Environment & Database
+VENV_OPTIONS = ["Yes (Recommended)", "No"]
+
+DATABASE_OPTIONS = ["None", "SQLAlchemy", "PostgreSQL", "MySQL", "MongoDB"]
+
+DATABASE_DESCRIPTIONS = {
+    "None": "No database integration",
+    "SQLAlchemy": "Database toolkit / ORM (flexible backend support)",
+    "PostgreSQL": "Powerful production-grade relational database",
+    "MySQL": "Popular relational database",
+    "MongoDB": "NoSQL document database",
+}
+
+# ✅ Technical Configs
+DEFAULT_PORTS = {
+    "Flask": "5000",
+    "FastAPI": "8000",
+    "Django": "8000",
+    "Sanic": "8000",
+    "Tornado": "8888",
+    "Falcon": "8000",
+    "Bottle": "8080",
+    "Pyramid": "6543",
+}
+
+# 🚀 LIFT CORE COMPONENTS (Public API)
+from create_app.ui.loader import Spinner
+from create_app.ui.prompts import ask_project_details
+from create_app.cli.engine import ProjectEngine 
+from create_app.generator.generator import generate_project
+
+# ✅ Public API Contract
+__all__ = [
+    "APP_NAME",
+    "APP_TAGLINE",
+    "FRAMEWORKS",
+    "DJANGO_PROJECT_TYPES",
+    "DJANGO_DESCRIPTIONS",
+    "PROJECT_STRUCTURES",
+    "PYTHON_PROJECT_TYPES",
+    "PYTHON_DESCRIPTIONS",
+    "STRUCTURE_DESCRIPTIONS",
+    "VENV_OPTIONS",
+    "DATABASE_OPTIONS",
+    "DATABASE_DESCRIPTIONS",
+    "DEFAULT_PORTS",
+    "Spinner",
+    "ask_project_details",
+    "ProjectEngine",
+    "generate_project",
+]

create_app/templates/bottle/minimal/structure.py

@@ -0,0 +1,60 @@
+from pathlib import Path
+from create_app.generator.renderer import render_template
+
+
+def generate(project_root: Path, context: dict):
+    """
+    Bottle Minimal Structure Generator
+
+    Creates:
+
+    project/
+     ├── app.py
+     ├── __init__.py
+     ├── requirements.txt
+     ├── .env
+     ├── README.md
+     └── .gitignore
+    """
+
+    # ✅ Ensure project root exists
+    project_root.mkdir(parents=True, exist_ok=True)
+
+    # ✅ Entry Point (Rendered from Template)
+    render_template(
+        "bottle/minimal/entry.py.tpl",
+        project_root / "app.py",
+        context,
+    )
+
+    # ✅ Common Files
+
+    render_template(
+        "common/__init__.py.tpl",
+        project_root / "__init__.py",
+        context,
+    )
+
+    render_template(
+        "common/requirements.txt.tpl",
+        project_root / "requirements.txt",
+        context,
+    )
+
+    render_template(
+        "common/.env.tpl",
+        project_root / ".env",
+        context,
+    )
+
+    render_template(
+        "common/README.md.tpl",
+        project_root / "README.md",
+        context,
+    )
+
+    render_template(
+        "common/gitignore.tpl",
+        project_root / ".gitignore",
+        context,
+    )

create_app/templates/bottle/production/structure.py

@@ -0,0 +1,173 @@
+from pathlib import Path
+import shutil
+
+from create_app.generator.renderer import render_template
+
+
+# ✅ TEMPLATE ROOT 😈🔥
+TEMPLATE_ROOT = Path(__file__).parents[2]
+# → create_app/templates/
+
+TEMPLATES_UI_DIR = TEMPLATE_ROOT / "common"  / "template" / "bottle"
+STATIC_UI_DIR = TEMPLATE_ROOT / "common"  / "static"
+
+
+# ✅ Copy Shared UI 😈🔥
+def copy_ui(project_root: Path):
+
+    shutil.copytree(
+        TEMPLATES_UI_DIR,
+        project_root / "views",   # ✅ Bottle uses views
+        dirs_exist_ok=True,
+    )
+
+    shutil.copytree(
+        STATIC_UI_DIR,
+        project_root / "static",
+        dirs_exist_ok=True,
+    )
+
+
+def generate(project_root: Path, context: dict):
+    """
+    Bottle Production Grade Generator 😈🔥
+    Clean layered architecture + Shared UI
+    """
+
+    project_root.mkdir(parents=True, exist_ok=True)
+
+    # ✅ Core Directory Layout
+    folders = [
+        "config",
+        "routes",
+        "services",
+        "models",
+        "schemas",
+        "middleware",
+        "utils",
+        "logs",
+        "tests",
+        "views",
+        "static",
+    ]
+
+    for folder in folders:
+        (project_root / folder).mkdir(exist_ok=True)
+
+    # ✅ Static Subfolders 👍
+    for folder in ["css", "js", "assets"]:
+        (project_root / "static" / folder).mkdir(parents=True, exist_ok=True)
+
+    # ✅ Python Packages 👍
+    for folder in [
+        "config",
+        "routes",
+        "services",
+        "models",
+        "schemas",
+        "middleware",
+        "utils",
+        "tests",
+    ]:
+        (project_root / folder / "__init__.py").touch()
+
+    # ✅ ENTRYPOINT 😈🔥
+    render_template(
+        "bottle/production/entry.py.tpl",
+        project_root / "app.py",
+        context,
+    )
+
+    # ✅ CONFIG FILE 👍
+    (project_root / "config" / "settings.py").write_text(
+        """
+import os
+
+
+class Settings:
+    debug = os.getenv("DEBUG", "True") == "True"
+    host = os.getenv("HOST", "127.0.0.1")
+    port = int(os.getenv("PORT", 8080))
+
+
+settings = Settings()
+""".strip() + "\n"
+    )
+
+    # ✅ ROUTES REGISTRY 👍
+    (project_root / "routes" / "__init__.py").write_text(
+        """
+from .health import register_health
+from .auth import register_auth
+from .api import register_api
+
+
+def register_routes(app):
+    register_health(app)
+    register_auth(app)
+    register_api(app)
+""".strip() + "\n"
+    )
+
+    # ✅ ROUTES 👍
+
+    (project_root / "routes" / "health.py").write_text(
+        """
+from bottle import response
+
+
+def register_health(app):
+
+    @app.get("/health")
+    def health():
+        response.content_type = "application/json"
+        return {"status": "healthy"}
+""".strip() + "\n"
+    )
+
+    (project_root / "routes" / "auth.py").write_text(
+        """
+def register_auth(app):
+
+    @app.get("/auth")
+    def auth():
+        return {"message": "Auth route ready"}
+""".strip() + "\n"
+    )
+
+    (project_root / "routes" / "api.py").write_text(
+        """
+from bottle import template
+
+
+def register_api(app):
+
+    @app.get("/")
+    def index():
+        return template("index")  # ✅ Loads Shared UI index.tpl
+""".strip() + "\n"
+    )
+
+    # ✅ PLACEHOLDERS 👍
+    (project_root / "services" / "example_service.py").touch()
+    (project_root / "models" / "example_model.py").touch()
+    (project_root / "schemas" / "example_schema.py").touch()
+    (project_root / "middleware" / "example_middleware.py").touch()
+    (project_root / "utils" / "helpers.py").touch()
+
+    # ✅ LOG FILE 👍
+    (project_root / "logs" / "app.log").touch()
+
+    # ✅ TEST FILE 👍
+    (project_root / "tests" / "test_health.py").touch()
+
+    # ✅ ⭐ COPY SHARED UI ⭐ 😈🔥
+    copy_ui(project_root)
+
+    # 🔥 COMMON FILES 🔥
+    render_template("common/requirements.txt.tpl", project_root / "requirements.txt", context)
+    render_template("common/.env.tpl", project_root / ".env", context)
+    render_template("common/README.md.tpl", project_root / "README.md", context)
+    render_template("common/gitignore.tpl", project_root / ".gitignore", context)
+
+    return project_root

create_app/templates/django/drf/structure.py

@@ -0,0 +1,152 @@
+import sys
+import subprocess
+import re
+from pathlib import Path
+
+from create_app.generator.renderer import render_template
+
+# ✅ Ensure Django Installed 😈🔥
+def ensure_django():
+    try:
+        subprocess.run(
+            [sys.executable, "-m", "django", "--version"],
+            stdout=subprocess.DEVNULL,
+            stderr=subprocess.DEVNULL,
+            check=True,
+        )
+    except subprocess.SubprocessError:
+        subprocess.run(
+            [sys.executable, "-m", "pip", "install", "django"],
+            check=True,
+        )
+
+
+# ✅ Patch settings.py 😈🔥
+def patch_settings(settings_path: Path, context: dict):
+    if not settings_path.exists():
+        return
+
+    content = settings_path.read_text()
+
+    # ✅ Ensure import os exists 😈🔥
+    if "import os" not in content:
+        content = re.sub(
+            r"(from pathlib import Path.*\n)",
+            r"\1import os\n",
+            content,
+        )
+
+    # ✅ Replace SECRET KEY / DEBUG / HOSTS
+    secret_block = render_template(
+        "django/drf/secret.tpl",
+        None,
+        context,
+        raw=True,
+    )
+
+    content = re.sub(
+        r"SECRET_KEY\s*=.*",
+        secret_block,
+        content,
+    )
+
+    # ✅ Inject Installed Apps
+    apps_block = render_template(
+        "django/drf/apps.py.tpl",
+        None,
+        context,
+        raw=True,
+    )
+
+    pattern = r"INSTALLED_APPS\s*=\s*\[(.*?)\]"
+    match = re.search(pattern, content, re.DOTALL)
+
+    if not match:
+        raise RuntimeError("INSTALLED_APPS not found")
+
+    existing = match.group(1).strip()
+    updated = existing + "\n" + apps_block
+
+    content = re.sub(
+        pattern,
+        f"INSTALLED_APPS = [\n{updated}\n]",
+        content,
+        flags=re.DOTALL,
+    )
+
+    # ✅ Append DRF Config
+    drf_config = render_template(
+        "django/drf/rf.py.tpl",
+        None,
+        context,
+        raw=True,
+    )
+
+    content += "\n\n" + drf_config
+    settings_path.write_text(content)
+
+
+# ✅ Overwrite urls.py 😈🔥
+def overwrite_urls(urls_path: Path, context: dict):
+    if not urls_path.exists():
+        return
+        
+    urls_content = render_template(
+        "django/drf/urls.tpl",
+        None,
+        context,
+        raw=True,
+    )
+    urls_path.write_text(urls_content)
+
+
+# ✅ MAIN GENERATOR 🚀
+def generate(project_root: Path, context: dict):
+    project_name = context["project_name"]
+    app_name = context["app_name"]
+    base_path = project_root.parent
+
+    base_path.mkdir(parents=True, exist_ok=True)
+
+    ensure_django()
+
+    # ✅ Step 1 — Create Project 😈🔥
+    subprocess.run(
+        [sys.executable, "-m", "django", "startproject", project_name],
+        cwd=base_path,
+        check=True,
+    )
+
+    project_dir = base_path / project_name
+    
+    # 🛡️ GUARD: Create folders if they don't exist (Fixes Pytest Mocks)
+    project_dir.mkdir(parents=True, exist_ok=True)
+    (project_dir / project_name).mkdir(exist_ok=True)
+
+    # ✅ Step 2 — Create App 👍
+    subprocess.run(
+        [sys.executable, "manage.py", "startapp", app_name],
+        cwd=project_dir,
+        check=True,
+    )
+    
+    # 🛡️ GUARD: Ensure app folder exists for tests
+    (project_dir / app_name).mkdir(exist_ok=True)
+
+    # ✅ Step 3 — Patch Settings 😈🔥
+    settings_path = project_dir / project_name / "settings.py"
+    patch_settings(settings_path, context)
+
+    # ✅ Step 4 — Overwrite URLs 😈🔥
+    urls_path = project_dir / project_name / "urls.py"
+    overwrite_urls(urls_path, context)
+
+    # ✅ Step 5 — Common Files 🔥
+    render_template("common/requirements.txt.tpl", project_dir / "requirements.txt", context)
+    render_template("common/.env.tpl", project_dir / ".env", context)
+    render_template("common/README.md.tpl", project_dir / "README.md", context)
+    
+    # Using the dot naming convention for consistency
+    render_template("common/gitignore.tpl", project_dir / ".gitignore", context)
+
+    return project_dir

create_app/templates/django/minimal/structure.py

@@ -0,0 +1,140 @@
+import sys
+import subprocess
+import re
+import shutil
+from pathlib import Path
+
+from create_app.generator.renderer import render_template
+
+TEMPLATE_DIR = Path(__file__).parent
+TEMPLATE_ROOT = Path(__file__).resolve().parents[2]
+
+
+TEMPLATES_UI_DIR = TEMPLATE_ROOT / "common" / "template" / "django"
+STATIC_UI_DIR = TEMPLATE_ROOT / "common" / "static"
+
+
+def load_dependencies():
+    dependency_file = TEMPLATE_DIR / "requirements.txt"
+    return dependency_file.read_text().strip() if dependency_file.exists() else ""
+
+
+# ✅ Copy Shared UI 😈🔥
+def copy_ui(project_dir: Path):
+    """Copies global templates and static files to the Django project root."""
+    templates_dest = project_dir / "templates"
+    static_dest = project_dir / "static"
+
+    if TEMPLATES_UI_DIR.exists():
+        shutil.copytree(TEMPLATES_UI_DIR, templates_dest, dirs_exist_ok=True)
+    else:
+        print(f"⚠ Shared Templates not found → {TEMPLATES_UI_DIR}")
+
+    if STATIC_UI_DIR.exists():
+        shutil.copytree(STATIC_UI_DIR, static_dest, dirs_exist_ok=True)
+
+
+# ✅ Patch Django settings.py 😈🔥
+def patch_settings(settings_path: Path, context: dict):
+    if not settings_path.exists():
+        return
+
+    content = settings_path.read_text()
+    app_name = context["app_name"]
+
+    # ✅ Ensure import os
+    if "import os" not in content:
+        content = content.replace(
+            "from pathlib import Path",
+            "from pathlib import Path\nimport os",
+        )
+
+    # ✅ Configure Templates DIR to look at root/templates
+    content = re.sub(
+        r"'DIRS': \[(.*?)\]",
+        "'DIRS': [BASE_DIR / 'templates'],",
+        content,
+        flags=re.DOTALL,
+    )
+
+    # ✅ Register Installed App
+    apps_pattern = r"INSTALLED_APPS\s*=\s*\[(.*?)\]"
+    match = re.search(apps_pattern, content, re.DOTALL)
+
+    if match:
+        existing_apps = match.group(1)
+        if f"'{app_name}'" not in existing_apps:
+            updated_apps = existing_apps.strip() + f"\n    '{app_name}',\n"
+            content = re.sub(
+                apps_pattern,
+                f"INSTALLED_APPS = [\n    {updated_apps}]",
+                content,
+                flags=re.DOTALL,
+            )
+
+    settings_path.write_text(content)
+
+
+def generate(project_root: Path, context: dict):
+    """
+    Django Standard Generator 😈🔥
+    Now with Shared UI and Test-Safety Guards
+    """
+    project_name = context["project_name"]
+    app_name = context["app_name"]
+    base_path = project_root.parent
+
+    # ✅ Remove empty scaffold folder
+    if project_root.exists() and not any(project_root.iterdir()):
+        project_root.rmdir()
+
+    # ✅ 1. Create Django Project
+    subprocess.run(
+        [sys.executable, "-m", "django", "startproject", project_name],
+        cwd=base_path,
+        check=True,
+    )
+
+    # 🛡️ GUARD: Ensure project_dir exists for the next steps (needed for MOCK tests)
+    project_dir = base_path / project_name
+    project_dir.mkdir(parents=True, exist_ok=True)
+    (project_dir / project_name).mkdir(exist_ok=True)
+
+    # ✅ 2. Create Django App
+    subprocess.run(
+        [sys.executable, "manage.py", "startapp", app_name],
+        cwd=project_dir,
+        check=True,
+    )
+
+    # 🛡️ GUARD: Ensure app folder exists before writing files
+    app_dir = project_dir / app_name
+    app_dir.mkdir(exist_ok=True)
+
+    # ✅ 3. Patch Settings
+    settings_path = project_dir / project_name / "settings.py"
+    if settings_path.exists():
+        patch_settings(settings_path, context)
+
+    # ✅ 4. Setup View logic
+    views_file = app_dir / "views.py"
+    views_file.write_text(f"""from django.shortcuts import render
+
+def index(request):
+    return render(request, 'index.html')
+""")
+
+    # ✅ 5. Copy Shared UI (index.html, CSS, JS) 😈🔥
+    copy_ui(project_dir)
+
+    # ✅ 6. Common Project Files
+    context.update({"dependencies": load_dependencies(), "entrypoint": "manage.py"})
+    
+    render_template("common/requirements.txt.tpl", project_dir / "requirements.txt", context)
+    render_template("common/.env.tpl", project_dir / ".env", context)
+    render_template("common/README.md.tpl", project_dir / "README.md", context)
+    
+    # Ensure this matches your physical file: .gitignore.tpl
+    render_template("common/gitignore.tpl", project_dir / ".gitignore", context)
+
+    return project_dir