monkeybrain-runtime 1.0.0__py3-none-any.whl

services/file/src/routes/cad_conversion.py

@@ -0,0 +1,26 @@
+from fastapi import APIRouter, File, UploadFile
+from fastapi.responses import Response
+
+from ..helpers.cad_conversion import convert_cad_upload_to_svg
+
+router = APIRouter(tags=["CAD Conversion"])
+
+
+async def _convert_to_svg(file: UploadFile) -> Response:
+    svg = await convert_cad_upload_to_svg(file)
+    return Response(
+        content=svg,
+        media_type="image/svg+xml",
+        headers={
+            "Content-Disposition": f'inline; filename="{(file.filename or "drawing").rsplit(".", 1)[0]}.svg"'
+        },
+    )
+
+
+@router.post("/convert/dwg-to-svg")
+@router.post("/convert/cad-to-svg")
+@router.post("/cad/convert-to-svg")
+@router.post("/api/v1/convert/dwg-to-svg")
+@router.post("/api/v1/cad/convert-to-svg")
+async def convert_dwg_or_cad_to_svg(file: UploadFile = File(...)) -> Response:
+    return await _convert_to_svg(file)

services/file/src/routes/files.py

@@ -0,0 +1,136 @@
+import logging
+import os
+from fastapi import APIRouter, File, UploadFile, HTTPException, BackgroundTasks, Query
+from botocore.exceptions import BotoCoreError, ClientError
+
+from ..helpers.helpers import (
+    delete_file_helper,
+    list_files_by_date_helper,
+    read_file_helper,
+    upload_file_helper,
+    delete_folder_helper
+)
+
+S3_BUCKET = os.getenv("AWS_S3_BUCKET") or os.getenv("S3_BUCKET")
+logger = logging.getLogger(__name__)
+
+#--------------------------------------------
+# ROUTER 
+#-------------------------------------------
+
+router = APIRouter(
+    prefix="/files",
+    tags=["Files"],
+    # dependencies=[Depends(require_auth_context)],
+)
+root_router = APIRouter(tags=["Files"])
+
+
+#--------------------------------------------
+# ROUTES
+#-------------------------------------------
+
+@root_router.post("/upload")
+@root_router.post("/upload/")
+@router.post("/upload")
+@router.post("/upload/")
+async def upload_file(
+    file: UploadFile = File(...),
+    notify: bool = True
+):
+    """
+    Upload a document to S3 and optionally forward it to another service via HTTP POST.
+    Folder structure: uploads/YYYY-MM-DD/<uuid>.<ext>
+    """
+    try:
+        return await upload_file_helper(file, notify)
+    except HTTPException:
+        raise
+    except (BotoCoreError, ClientError) as e:
+        logger.error(f"S3 upload error: {e}", exc_info=True)
+        raise HTTPException(status_code=500, detail=f"S3 upload error: {str(e)}")
+    except Exception as e:
+        logger.error(f"Unexpected error during upload: {e}", exc_info=True)
+        raise HTTPException(status_code=500, detail=f"Unexpected error: {str(e)}")
+
+@router.get("/{date}")
+async def list_files_by_date(date: str, create_backup: bool = True):
+    """
+    List all files uploaded on a given date with backup status.
+    Example: GET /files/2025-11-11
+    """
+    try:
+        return await list_files_by_date_helper(date, create_backup)
+    except HTTPException:
+        raise
+    except (BotoCoreError, ClientError) as e:
+        logger.error(f"S3 list error: {e}", exc_info=True)
+        raise HTTPException(status_code=500, detail=f"S3 list error: {str(e)}")
+    except Exception as e:
+        logger.error(f"Unexpected error: {e}", exc_info=True)
+        raise HTTPException(status_code=500, detail=f"Unexpected error: {str(e)}")
+
+@router.get("/{date}/{filename}")
+async def read_file(
+    date: str,
+    filename: str,
+    download: bool = Query(True, description="Return as browser download attachment when true"),
+):
+    """
+    Read or download a file from S3 given its date and filename.
+    URL format: /files/YYYY-MM-DD/<filename>
+    """
+    s3_key = f"uploads/{date}/{filename}"
+    logger.info(f"Reading file: {s3_key}")
+
+    try:
+        return await read_file_helper(date, filename, as_attachment=download)
+
+    except HTTPException:
+        raise
+    except ClientError as e:
+        err_code = e.response.get("Error", {}).get("Code")
+        if err_code in ("404", "NoSuchKey", "NotFound"):
+            logger.error(f"File not found: {s3_key}")
+            raise HTTPException(status_code=404, detail="File not found in S3")
+        logger.error(f"S3 read ClientError: {e}", exc_info=True)
+        raise HTTPException(status_code=500, detail=f"S3 read error: {str(e)}")
+    except (BotoCoreError, Exception) as e:
+        logger.error(f"S3 read error: {e}", exc_info=True)
+        raise HTTPException(status_code=500, detail=f"S3 read error: {str(e)}")
+
+@router.delete("/{date}/{filename}")
+async def delete_file(date: str, filename: str, delete_backup: bool = True):
+    """Delete a file from S3 and optionally its backup."""
+    s3_key = f"uploads/{date}/{filename}"
+    logger.info(f"Deleting file: {s3_key}, delete_backup: {delete_backup}")
+
+    try:
+        return await delete_file_helper(date, filename, delete_backup)
+    except HTTPException:
+        raise
+    except (BotoCoreError, ClientError) as e:
+        logger.error(f"S3 delete error: {e}", exc_info=True)
+        raise HTTPException(status_code=500, detail=f"S3 delete error: {str(e)}")
+    except Exception as e:
+        logger.error(f"Unexpected error: {e}", exc_info=True)
+        raise HTTPException(status_code=500, detail=f"Unexpected error: {str(e)}")
+
+@router.delete("/{date}")
+async def delete_folder(
+    date: str,
+    delete_backup: bool = True,
+    background_tasks: BackgroundTasks = None
+):
+    """Delete all files for a specific date (entire folder)."""
+    try:
+        return await delete_folder_helper(date, delete_backup, background_tasks)
+
+    except HTTPException:
+        raise
+    except (BotoCoreError, ClientError) as e:
+        logger.error(f"S3 delete error: {e}", exc_info=True)
+        raise HTTPException(status_code=500, detail=f"S3 delete error: {str(e)}")
+    except Exception as e:
+        logger.error(f"Unexpected error: {e}", exc_info=True)
+        raise HTTPException(status_code=500, detail=f"Unexpected error: {str(e)}")

services/file/src/routes/presigned.py

@@ -0,0 +1,154 @@
+import logging
+import os
+import boto3
+from fastapi import APIRouter, Query, HTTPException
+from botocore.exceptions import BotoCoreError, ClientError
+
+
+S3_BUCKET = os.getenv("AWS_S3_BUCKET") or os.getenv("S3_BUCKET")
+logger = logging.getLogger(__name__)
+
+
+# ============================
+# ENVIRONMENT VARIABLES
+# ============================
+
+# S3 Configuration
+AWS_ACCESS_KEY_ID = os.getenv("AWS_ACCESS_KEY_ID") or os.getenv("ACCESS_KEY_ID")
+AWS_SECRET_ACCESS_KEY = os.getenv("AWS_SECRET_ACCESS_KEY") or os.getenv("SECRET_ACCESS_KEY")
+AWS_REGION = os.getenv("AWS_REGION", os.getenv("REGION", "ap-south-1"))
+S3_BUCKET = os.getenv("AWS_S3_BUCKET") or os.getenv("S3_BUCKET")
+S3_BACKUP_BUCKET = os.getenv("AWS_S3_BACKUP_BUCKET") or os.getenv("S3_BACKUP_BUCKET")
+
+# WebSocket/Forward Configuration
+FORWARD_URL = os.getenv("WEBSOCKET_URL") or os.getenv("FORWARD_URL") or ""
+FORWARD_TIMEOUT = int(os.getenv("WEBSOCKET_TIMEOUT", "10"))
+FORWARD_ENABLED = bool(FORWARD_URL and FORWARD_URL.strip())
+
+# Validate required config
+if not S3_BUCKET:
+    logger.warning("S3_BUCKET is not set. Set AWS_S3_BUCKET or S3_BUCKET env var.")
+
+# ============================
+# S3 CLIENT INITIALIZATION
+# ============================
+
+s3_client_kwargs = {"region_name": AWS_REGION}
+if AWS_ACCESS_KEY_ID and AWS_SECRET_ACCESS_KEY:
+    s3_client_kwargs.update({
+        "aws_access_key_id": AWS_ACCESS_KEY_ID,
+        "aws_secret_access_key": AWS_SECRET_ACCESS_KEY,
+    })
+
+s3_client = boto3.client("s3", **s3_client_kwargs)
+
+# Log configuration
+logger.info(f"Forward URL: {FORWARD_URL}")
+logger.info(f"Forward Enabled: {FORWARD_ENABLED}")
+logger.info(f"Forward Timeout: {FORWARD_TIMEOUT}s")
+logger.info(f"S3 Bucket: {S3_BUCKET}")
+logger.info(f"S3 Backup Bucket: {S3_BACKUP_BUCKET or (S3_BUCKET + '-backup' if S3_BUCKET else 'N/A')}")
+
+
+router = APIRouter(
+    prefix="/url",
+    tags=["Files"],
+    # dependencies=[Depends(require_auth_context)],
+)
+
+@router.get("/presigned-url/preview")
+async def generate_preview_presigned_url(
+    key: str = Query(..., description="S3 object key (e.g. uploads/2025-11-21/file.pdf)"),
+    expires_in: int = Query(300, ge=1, le=3600, description="Expiry time in seconds (1–3600)")
+):
+    """
+    Generate a presigned URL for **previewing** an S3 object in the browser.
+
+    Example:
+    GET /presigned-url/preview?key=uploads/2025-11-21/file.pdf&expires_in=300
+    """
+    if not S3_BUCKET:
+        raise HTTPException(status_code=500, detail="S3 bucket is not configured")
+
+    logger.info(f"Generating PREVIEW presigned URL for key={key}, expires_in={expires_in}")
+
+    try:
+        params = {
+            "Bucket": S3_BUCKET,
+            "Key": key,
+            # Inline -> browser tries to render (PDF, image, etc.)
+            "ResponseContentDisposition": "inline"
+        }
+
+        url = s3_client.generate_presigned_url(
+            ClientMethod="get_object",
+            Params=params,
+            ExpiresIn=expires_in,
+        )
+
+        return {
+            "mode": "preview",
+            "bucket": S3_BUCKET,
+            "key": key,
+            "url": url,
+            "expires_in": expires_in
+        }
+
+    except (BotoCoreError, ClientError) as e:
+        logger.error(f"Error generating PREVIEW presigned URL for key={key}: {e}", exc_info=True)
+        raise HTTPException(
+            status_code=500,
+            detail=f"Failed to generate preview presigned URL: {str(e)}"
+        )
+
+@router.get("/presigned-url/download")
+async def generate_download_presigned_url(
+    key: str = Query(..., description="S3 object key (e.g. uploads/2025-11-21/file.pdf)"),
+    expires_in: int = Query(300, ge=1, le=3600, description="Expiry time in seconds (1–3600)"),
+    filename: str | None = Query(None, description="Optional filename to suggest in the browser download dialog")
+):
+    """
+    Generate a presigned URL for **downloading** an S3 object.
+
+    Example:
+    GET /presigned-url/download?key=uploads/2025-11-21/file.pdf&filename=invoice-123.pdf
+    """
+    if not S3_BUCKET:
+        raise HTTPException(status_code=500, detail="S3 bucket is not configured")
+
+    logger.info(f"Generating DOWNLOAD presigned URL for key={key}, expires_in={expires_in}, filename={filename}")
+
+    try:
+        # Content-Disposition: attachment; filename="..."
+        if filename:
+            disposition = f'attachment; filename="{filename}"'
+        else:
+            disposition = "attachment"
+
+        params = {
+            "Bucket": S3_BUCKET,
+            "Key": key,
+            "ResponseContentDisposition": disposition
+        }
+
+        url = s3_client.generate_presigned_url(
+            ClientMethod="get_object",
+            Params=params,
+            ExpiresIn=expires_in,
+        )
+
+        return {
+            "mode": "download",
+            "bucket": S3_BUCKET,
+            "key": key,
+            "url": url,
+            "expires_in": expires_in,
+            "filename": filename
+        }
+
+    except (BotoCoreError, ClientError) as e:
+        logger.error(f"Error generating DOWNLOAD presigned URL for key={key}: {e}", exc_info=True)
+        raise HTTPException(
+            status_code=500,
+            detail=f"Failed to generate download presigned URL: {str(e)}"
+        )

services/file/src/services/websocket.py

@@ -0,0 +1,293 @@
+import os
+import json
+import base64
+import logging
+from typing import Optional, Dict, Any
+
+try:
+    import websockets
+except ImportError:
+    raise ImportError(
+        "websockets library not found. Install with: pip install websockets"
+    )
+
+log = logging.getLogger(__name__)
+
+
+async def send_file_to_bridge(
+    file_path: str,
+    ws_uri: Optional[str] = None,
+    timeout: float = 30.0,
+    send_as_binary: bool = False
+) -> Dict[str, Any]:
+    """
+    Send a file to the WebSocket-to-NATS bridge.
+    
+    Args:
+        file_path: Path to the file to send
+        ws_uri: WebSocket URI (default: ws://websocket-server:6789)
+                Use 'ws://localhost:6789' for local testing
+        timeout: Connection and send timeout in seconds
+        send_as_binary: If True, send as binary frame; if False, send as base64 JSON
+        
+    Returns:
+        Dict with server response, e.g.:
+        {
+            "status": "queued",
+            "len": 12345,
+            "saved_file": "invoice.pdf"
+        }
+        
+    Raises:
+        FileNotFoundError: If file doesn't exist
+        websockets.exceptions.WebSocketException: On connection/send errors
+        asyncio.TimeoutError: If operation times out
+        json.JSONDecodeError: If server response is invalid
+    """
+    # Default to Docker service name, not localhost
+    if ws_uri is None:
+        ws_uri = os.getenv("WEBSOCKET_BRIDGE_URI", "ws://websocket-server:6789")
+    
+    # Validate file exists
+    if not os.path.isfile(file_path):
+        raise FileNotFoundError(f"File not found: {file_path}")
+    
+    file_name = os.path.basename(file_path)
+    file_size = os.path.getsize(file_path)
+    
+    log.info("Sending file to WebSocket bridge: %s (%d bytes)", file_name, file_size)
+    log.debug("WebSocket URI: %s", ws_uri)
+    log.debug("Send mode: %s", "binary" if send_as_binary else "base64-JSON")
+    
+    try:
+        # Connect to WebSocket server with timeout
+        async with websockets.connect(ws_uri, open_timeout=timeout) as websocket:
+            log.debug("✓ Connected to WebSocket server")
+            
+            # Read file contents
+            with open(file_path, "rb") as f:
+                file_data = f.read()
+            
+            # Send file based on mode
+            if send_as_binary:
+                # Send as raw binary frame
+                log.debug("Sending binary frame...")
+                await websocket.send(file_data)
+                
+            else:
+                # Send as base64-encoded JSON
+                log.debug("Encoding file as base64...")
+                encoded_data = base64.b64encode(file_data).decode('utf-8')
+                
+                payload = {
+                    "fileName": file_name,
+                    "data": encoded_data
+                }
+                
+                log.debug("Sending JSON payload...")
+                await websocket.send(json.dumps(payload))
+            
+            log.debug("Waiting for server acknowledgment...")
+            
+            # Wait for server acknowledgment
+            try:
+                response = await asyncio.wait_for(
+                    websocket.recv(),
+                    timeout=timeout
+                )
+            except asyncio.TimeoutError:
+                log.error("Timeout waiting for server response")
+                raise
+            
+            # Parse response
+            try:
+                ack = json.loads(response)
+                log.debug("Server response: %s", ack)
+            except json.JSONDecodeError as e:
+                log.error("Invalid JSON response from server: %s", response)
+                raise
+            
+            # Check response status
+            if ack.get("status") == "queued":
+                log.info("✓ File queued successfully: %s", file_name)
+            elif ack.get("status") == "nack":
+                reason = ack.get("reason", "unknown")
+                log.warning("✗ File rejected by server: %s", reason)
+            else:
+                log.warning("⚠ Unexpected server response: %s", ack)
+            
+            return ack
+            
+    except websockets.exceptions.InvalidURI as e:
+        log.error("Invalid WebSocket URI: %s", ws_uri)
+        raise
+        
+    except websockets.exceptions.WebSocketException as e:
+        log.error("WebSocket error: %s", e)
+        raise
+        
+    except Exception as e:
+        log.error("Unexpected error sending file: %s", e)
+        raise
+
+
+async def send_multiple_files(
+    file_paths: list,
+    ws_uri: Optional[str] = None,
+    timeout: float = 30.0,
+    send_as_binary: bool = False
+) -> Dict[str, Any]:
+    """
+    Send multiple files to the WebSocket bridge (reusing connection).
+    
+    Args:
+        file_paths: List of file paths to send
+        ws_uri: WebSocket URI
+        timeout: Timeout per file
+        send_as_binary: Send mode
+        
+    Returns:
+        Dict mapping file paths to their responses:
+        {
+            "file1.pdf": {"status": "queued", ...},
+            "file2.png": {"status": "nack", ...}
+        }
+    """
+    if ws_uri is None:
+        ws_uri = os.getenv("WEBSOCKET_BRIDGE_URI", "ws://websocket-server:6789")
+    
+    results = {}
+    
+    log.info("Sending %d files to WebSocket bridge", len(file_paths))
+    
+    try:
+        async with websockets.connect(ws_uri, open_timeout=timeout) as websocket:
+            log.debug("✓ Connected to WebSocket server")
+            
+            for file_path in file_paths:
+                try:
+                    # Validate file
+                    if not os.path.isfile(file_path):
+                        log.warning("Skipping non-existent file: %s", file_path)
+                        results[file_path] = {
+                            "status": "error",
+                            "reason": "file_not_found"
+                        }
+                        continue
+                    
+                    file_name = os.path.basename(file_path)
+                    
+                    # Read and send file
+                    with open(file_path, "rb") as f:
+                        file_data = f.read()
+                    
+                    if send_as_binary:
+                        await websocket.send(file_data)
+                    else:
+                        payload = {
+                            "fileName": file_name,
+                            "data": base64.b64encode(file_data).decode('utf-8')
+                        }
+                        await websocket.send(json.dumps(payload))
+                    
+                    # Wait for ACK
+                    response = await asyncio.wait_for(
+                        websocket.recv(),
+                        timeout=timeout
+                    )
+                    
+                    ack = json.loads(response)
+                    results[file_path] = ack
+                    
+                    log.info("✓ Sent %s: %s", file_name, ack.get("status"))
+                    
+                except Exception as e:
+                    log.error("Error sending %s: %s", file_path, e)
+                    results[file_path] = {
+                        "status": "error",
+                        "reason": str(e)
+                    }
+            
+            log.info("Sent %d/%d files successfully", 
+                    sum(1 for r in results.values() if r.get("status") == "queued"),
+                    len(file_paths))
+            
+            return results
+            
+    except Exception as e:
+        log.error("Connection error: %s", e)
+        raise
+
+
+# Synchronous wrapper for non-async contexts
+def send_file_sync(
+    file_path: str,
+    ws_uri: Optional[str] = None,
+    timeout: float = 30.0,
+    send_as_binary: bool = False
+) -> Dict[str, Any]:
+    """
+    Synchronous wrapper for send_file_to_bridge.
+    
+    Use this in non-async code (e.g., Flask routes, scripts).
+    """
+    import asyncio
+    
+    try:
+        # Try to get existing event loop
+        loop = asyncio.get_event_loop()
+        if loop.is_running():
+            # We're already in an async context - can't use run()
+            raise RuntimeError(
+                "send_file_sync() cannot be called from async context. "
+                "Use 'await send_file_to_bridge()' instead."
+            )
+    except RuntimeError:
+        pass
+    
+    # Run in new event loop
+    return asyncio.run(send_file_to_bridge(
+        file_path=file_path,
+        ws_uri=ws_uri,
+        timeout=timeout,
+        send_as_binary=send_as_binary
+    ))
+
+
+if __name__ == "__main__":
+    """Example usage and testing."""
+    import sys
+    import asyncio
+    
+    logging.basicConfig(
+        level=logging.INFO,
+        format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
+    )
+    
+    # Example: Send a test file
+    async def test():
+        # For local testing, use localhost
+        # For Docker, use service name
+        test_uri = "ws://localhost:6789"  # Change as needed
+        
+        # Create a test file
+        test_file = "/tmp/test_upload.txt"
+        with open(test_file, "w") as f:
+            f.write("Hello from WebSocket client!\n")
+        
+        print(f"Sending test file: {test_file}")
+        
+        try:
+            # Test base64-JSON mode
+            result = await send_file_to_bridge(
+                test_file,
+                ws_uri=test_uri,
+                send_as_binary=False
+            )
+            print(f"Result: {result}")
+            
+        except Exception as e:
+            print(f"Error: {e}")
+            sys.exit(1)
+    
+    asyncio.run(test())

services/floor_layout/helpers/__init__.py

@@ -0,0 +1,8 @@
+"""floor_layout service helpers package."""
+
+__all__ = [
+    "bays",
+    "buildings",
+    "floors",
+    "rooms",
+]