xenfra-sdk 0.2.5__py3-none-any.whl → 0.2.7__py3-none-any.whl

xenfra_sdk/dockerizer.py

@@ -9,8 +9,6 @@ from pathlib import Path
 from typing import Dict, Optional
 import re
 
-from jinja2 import Environment, FileSystemLoader
-
 
 def detect_python_version(file_manifest: list = None) -> str:
     """
@@ -65,131 +63,89 @@ def detect_python_version(file_manifest: list = None) -> str:
     return default_version
 
 
-def render_deployment_assets(context: dict) -> Dict[str, str]:
+def detect_entrypoint(file_manifest: list = None, framework: str = "fastapi") -> str:
     """
-    Renders deployment assets (Dockerfile, docker-compose.yml) using Jinja2 templates.
-    
-    IMPORTANT: This function returns strings, NOT files. The caller is responsible
-    for writing these to the correct location (e.g., via SSH to a remote droplet).
+    Detect the correct uvicorn/gunicorn entrypoint from project structure.
+
+    Checks common patterns:
+    - main.py in root → main:app
+    - app.py in root → app:app
+    - src/main.py → src.main:app
+    - app/main.py → app.main:app
 
     Args:
-        context: A dictionary containing information for rendering templates.
-                 Required keys:
-                   - framework: str (fastapi, flask, django)
-                   - port: int (default 8000)
-                 Optional keys:
-                   - command: str (start command, auto-generated if not provided)
-                   - database: str (postgres, mysql, etc.)
-                   - package_manager: str (pip, uv)
-                   - dependency_file: str (requirements.txt, pyproject.toml)
-                   - python_version: str (default python:3.11-slim)
+        file_manifest: List of file info dicts with 'path' key
+        framework: The framework being used (fastapi, flask, django)
 
     Returns:
-        Dict with keys "Dockerfile" and "docker-compose.yml", values are rendered content strings.
-        Returns empty dict if no framework is provided.
+        Entrypoint string (e.g., "main:app", "src.main:app")
     """
-    # Path to the templates directory
-    template_dir = Path(__file__).parent / "templates"
-    env = Environment(loader=FileSystemLoader(template_dir))
-
-    # Get framework from context (MUST be provided by caller, no auto-detection)
-    framework = context.get("framework")
-    if not framework:
-        # Framework is required - caller should have validated this
-        return {}
-
-    # Get port with default
-    port = context.get("port") or 8000
-
-    # Generate default command based on framework if not provided
-    command = context.get("command")
-    if not command:
-        if framework == "fastapi":
-            command = f"uvicorn main:app --host 0.0.0.0 --port {port}"
-        elif framework == "flask":
-            command = f"gunicorn app:app -b 0.0.0.0:{port}"
-        elif framework == "django":
-            command = f"gunicorn app.wsgi:application --bind 0.0.0.0:{port}"
-        else:
-            command = f"uvicorn main:app --host 0.0.0.0 --port {port}"
-
-    # Build render context with all values
-    render_context = {
-        "framework": framework,
-        "port": port,
-        "command": command,
-        "database": context.get("database"),
-        "package_manager": context.get("package_manager", "pip"),
-        "dependency_file": context.get("dependency_file", "requirements.txt"),
-        "python_version": context.get("python_version", "python:3.11-slim"),
-        "missing_deps": context.get("missing_deps", []),
-        # Pass through any additional context
-        **context,
+    if not file_manifest:
+        return "main:app"  # Default fallback
+
+    # Build set of paths for fast lookup
+    paths = {f.get('path', '') for f in file_manifest}
+
+    # Check common entrypoint patterns in priority order
+    entrypoint_patterns = [
+        ("main.py", "main:app"),
+        ("app.py", "app:app"),
+        ("src/main.py", "src.main:app"),
+        ("src/app.py", "src.app:app"),
+        ("app/main.py", "app.main:app"),
+        ("api/main.py", "api.main:app"),
+    ]
+
+    for file_path, entrypoint in entrypoint_patterns:
+        if file_path in paths:
+            return entrypoint
+
+    # === PROTOCOL COMPLIANT: Framework Recipe Pattern ===
+    # Instead of if-else chains, use a dictionary of patterns
+    FRAMEWORK_PATTERNS = {
+        "django": {
+            "file_suffix": "wsgi.py",
+            "instance": "application",
+            "class_pattern": None,  # Django uses wsgi discovery
+        },
+        "fastapi": {
+            "file_suffix": None,
+            "instance": "app",
+            "class_pattern": r'([a-zA-Z0-9_]+)\s*=\s*FastAPI\(',
+        },
+        "flask": {
+            "file_suffix": None,
+            "instance": "app",
+            "class_pattern": r'([a-zA-Z0-9_]+)\s*=\s*Flask\(',
+        },
     }
 
-    result = {}
-
-    # --- 1. Render Dockerfile ---
-    dockerfile_template = env.get_template("Dockerfile.j2")
-    result["Dockerfile"] = dockerfile_template.render(render_context)
-
-    # --- 2. Render docker-compose.yml ---
-    compose_template = env.get_template("docker-compose.yml.j2")
-    result["docker-compose.yml"] = compose_template.render(render_context)
-
-    return result
-
-
-# Keep detect_framework for potential local CLI use (not used in remote deployment)
-def detect_framework(path: str = ".") -> tuple:
-    """
-    Scans common Python project structures to guess the framework and entrypoint.
-    
-    NOTE: This is only useful when running LOCALLY on the user's machine.
-    It should NOT be called when the engine runs on a remote server.
-    
-    Returns: (framework_name, default_port, start_command) or (None, None, None)
-    """
-    project_root = Path(path).resolve()
+    # Django special case: Look for wsgi.py
+    recipe = FRAMEWORK_PATTERNS.get(framework, {})
+    if recipe.get("file_suffix"):
+        for path in paths:
+            if path.endswith(recipe["file_suffix"]):
+                module = path.replace("/", ".").replace(".py", "")
+                return f"{module}:{recipe['instance']}"
+
+    # === SEARCH & RESCUE: Deep Content Scan ===
+    # If filename scan fails, look inside .py files for instantiation
+    class_pattern = recipe.get("class_pattern")
+    if class_pattern:
+        for file_info in file_manifest:
+            path = file_info.get('path', '')
+            if not path.endswith(".py") or path.startswith("tests/"):
+                continue
+                
+            content = file_info.get('content', '')
+            if not content:
+                continue
+
+            match = re.search(class_pattern, content)
+            if match:
+                instance = match.group(1)
+                module = path.replace("/", ".").replace(".py", "").replace("src.", "").replace("app.", "")
+                return f"{module}:{instance}"
 
-    # Check for Django first (common pattern: manage.py in root)
-    if (project_root / "manage.py").is_file():
-        project_name = project_root.name
-        return "django", 8000, f"gunicorn {project_name}.wsgi:application --bind 0.0.0.0:8000"
+    return "main:app"  # Default fallback
 
-    candidate_files = []
-    
-    # Check directly in project root
-    for name in ["main.py", "app.py"]:
-        if (project_root / name).is_file():
-            candidate_files.append(project_root / name)
-
-    # Check in src/*/ (standard package layout)
-    for src_dir in project_root.glob("src/*"):
-        if src_dir.is_dir():
-            for name in ["main.py", "app.py"]:
-                if (src_dir / name).is_file():
-                    candidate_files.append(src_dir / name)
-
-    import os
-    for file_path in candidate_files:
-        try:
-            with open(file_path, "r") as f:
-                content = f.read()
-        except Exception:
-            continue
-            
-        try:
-            module_name = str(file_path.relative_to(project_root)).replace(os.sep, '.')[:-3]
-            if module_name.startswith("src."):
-                module_name = module_name[4:]
-        except ValueError:
-            module_name = file_path.stem
-
-        if "FastAPI" in content:
-            return "fastapi", 8000, f"uvicorn {module_name}:app --host 0.0.0.0 --port 8000"
-        
-        if "Flask" in content:
-            return "flask", 5000, f"gunicorn {module_name}:app -b 0.0.0.0:5000"
-    
-    return None, None, None