Initial commit

main.py

@@ -1,3 +1,324 @@
+# import os
+# import sys
+# import uuid
+# import time
+# import logging
+# import shutil
+# import tempfile
+# from typing import Optional, List
+# from enum import Enum
+# from pathlib import Path
+
+# # Third-party imports
+# import uvicorn
+# import pytesseract
+# from fastapi import (
+#     FastAPI, File, UploadFile, Depends, 
+#     HTTPException, Request, status
+# )
+# from fastapi.middleware.cors import CORSMiddleware
+# from fastapi.security import HTTPBearer, HTTPAuthorizationCredentials
+# from fastapi.responses import JSONResponse
+# from fastapi.concurrency import run_in_threadpool
+# from pydantic import BaseModel
+# from dotenv import load_dotenv
+# from PIL import Image
+# from pdf2image import convert_from_path
+
+# # ==========================================
+# # 1. CONFIGURATION & ENV LOADING
+# # ==========================================
+# load_dotenv()
+
+# class Config:
+#     APP_NAME = os.getenv("APP_NAME", "OCR API")
+#     API_TOKEN = os.getenv("API_BEARER_TOKEN")
+#     MAX_SIZE = int(os.getenv("MAX_FILE_SIZE", 52428800))
+    
+#     allowed_origins_raw = os.getenv("ALLOWED_ORIGINS")
+#     ALLOWED_ORIGINS = [origin.strip() for origin in allowed_origins_raw.split(",") if origin.strip()] if allowed_origins_raw else []
+#     ALLOWED_TYPES = ["image/jpeg", "image/png", "image/bmp", "image/webp", "application/pdf"]
+
+# if not Config.API_TOKEN:
+#     print("CRITICAL WARNING: API_BEARER_TOKEN is not set in .env")
+
+# # ==========================================
+# # 2. LOGGING SETUP
+# # ==========================================
+# class RequestIdFilter(logging.Filter):
+#     def filter(self, record):
+#         if not hasattr(record, 'request_id'):
+#             record.request_id = 'system'
+#         return True
+
+# logging.basicConfig(
+#     level=logging.INFO,
+#     format='%(asctime)s | %(levelname)s | ReqID:%(request_id)s | %(message)s',
+#     datefmt='%Y-%m-%d %H:%M:%S'
+# )
+# logger = logging.getLogger("ocr_api")
+# logger.addFilter(RequestIdFilter())
+
+# # ==========================================
+# # 3. PYDANTIC MODELS (UPDATED)
+# # ==========================================
+# class StatusEnum(str, Enum):
+#     SUCCESS = "success"
+#     ERROR = "error"
+
+# class BaseResponse(BaseModel):
+#     request_id: str
+#     process_time_ms: float
+#     status: StatusEnum
+#     message: Optional[str] = None
+
+# # New model for individual page details
+# class PageResult(BaseModel):
+#     index: int
+#     page_number: int
+#     text: str
+
+# # Updated Result model to return a list of pages
+# class OCRResult(BaseModel):
+#     filename: str
+#     content_type: str
+#     total_pages: int
+#     pages_content: List[PageResult]
+
+# class APIResponse(BaseResponse):
+#     data: Optional[OCRResult] = None
+#     error_message: Optional[str] = None
+
+# # ==========================================
+# # 4. BUSINESS LOGIC SERVICES
+# # ==========================================
+
+# class SecurityService:
+#     security_scheme = HTTPBearer()
+
+#     @staticmethod
+#     async def validate_token(credentials: HTTPAuthorizationCredentials = Depends(security_scheme)):
+#         if credentials.credentials != Config.API_TOKEN:
+#             logger.warning(f"Auth Failed. Token used: {credentials.credentials[:5]}...")
+#             raise HTTPException(
+#                 status_code=status.HTTP_401_UNAUTHORIZED,
+#                 detail="Invalid Bearer Token",
+#                 headers={"WWW-Authenticate": "Bearer"},
+#             )
+#         return credentials.credentials
+
+# class FileValidator:
+#     @staticmethod
+#     def validate(file: UploadFile):
+#         if file.content_type not in Config.ALLOWED_TYPES:
+#             raise HTTPException(
+#                 status_code=status.HTTP_400_BAD_REQUEST, 
+#                 detail=f"Invalid file type. Allowed: {Config.ALLOWED_TYPES}"
+#             )
+
+#     @staticmethod
+#     def check_size_and_save(file: UploadFile) -> str:
+#         try:
+#             suffix = Path(file.filename).suffix
+#             with tempfile.NamedTemporaryFile(delete=False, suffix=suffix) as buffer:
+#                 shutil.copyfileobj(file.file, buffer)
+#                 tmp_path = buffer.name
+            
+#             file_size = os.path.getsize(tmp_path)
+#             if file_size > Config.MAX_SIZE:
+#                 os.remove(tmp_path)
+#                 raise HTTPException(
+#                     status_code=status.HTTP_413_REQUEST_ENTITY_TOO_LARGE,
+#                     detail=f"File size exceeds limit of {Config.MAX_SIZE / (1024*1024)}MB"
+#                 )
+            
+#             return tmp_path
+#         except HTTPException:
+#             raise
+#         except Exception as e:
+#             logger.error(f"File save error: {e}")
+#             raise HTTPException(status.HTTP_500_INTERNAL_SERVER_ERROR, "File upload failed")
+
+# class OCRProcessor:
+#     @classmethod
+#     def process_file(cls, file_path: str, content_type: str, request_id: str) -> dict:
+#         """
+#         Extracts text per page and logs every step.
+#         """
+#         start = time.perf_counter()
+#         pages_content = []
+        
+#         # Helper to inject request_id into logs inside the thread
+#         def log_op(msg):
+#             logger.info(f"[Thread-Op] {msg}", extra={'request_id': request_id})
+
+#         try:
+#             log_op(f"Starting processing for file type: {content_type}")
+
+#             if content_type == "application/pdf":
+#                 log_op("Initiating PDF to Image conversion...")
+                
+#                 # Convert PDF to images
+#                 images = convert_from_path(file_path)
+#                 total_pages = len(images)
+                
+#                 log_op(f"PDF converted successfully. Total pages found: {total_pages}")
+
+#                 # Iterate through pages
+#                 for idx, img in enumerate(images):
+#                     page_num = idx + 1
+#                     log_op(f"Processing Page {page_num}/{total_pages} - extracting text...")
+                    
+#                     extracted_text = pytesseract.image_to_string(img).strip()
+                    
+#                     log_op(f"Completed Page {page_num}/{total_pages} - Text length: {len(extracted_text)} chars")
+                    
+#                     pages_content.append({
+#                         "index": idx,
+#                         "page_number": page_num,
+#                         "text": extracted_text
+#                     })
+#             else:
+#                 # Standard Image
+#                 log_op("Processing single image file...")
+#                 img = Image.open(file_path)
+#                 text = pytesseract.image_to_string(img).strip()
+#                 log_op("Image text extraction complete.")
+                
+#                 pages_content.append({
+#                     "index": 0,
+#                     "page_number": 1,
+#                     "text": text
+#                 })
+
+#             duration = (time.perf_counter() - start) * 1000
+#             log_op(f"OCR Engine finished all tasks in {duration:.2f}ms")
+            
+#             return {
+#                 "total_pages": len(pages_content), 
+#                 "pages_content": pages_content
+#             }
+
+#         except Exception as e:
+#             log_op(f"OCR Extraction Error: {str(e)}")
+#             raise ValueError("Failed to extract text from document")
+
+# # ==========================================
+# # 5. FASTAPI APP INIT
+# # ==========================================
+
+# app = FastAPI(title=Config.APP_NAME)
+
+# app.add_middleware(
+#     CORSMiddleware,
+#     allow_origins=Config.ALLOWED_ORIGINS,
+#     allow_credentials=True,
+#     allow_methods=["GET", "POST"],
+#     allow_headers=["Authorization", "Content-Type", "X-Request-ID"],
+# )
+
+# @app.middleware("http")
+# async def request_context_middleware(request: Request, call_next):
+#     req_id = str(uuid.uuid4())
+#     request.state.request_id = req_id
+    
+#     old_factory = logging.getLogRecordFactory()
+#     def record_factory(*args, **kwargs):
+#         record = old_factory(*args, **kwargs)
+#         record.request_id = req_id
+#         return record
+#     logging.setLogRecordFactory(record_factory)
+
+#     start_time = time.perf_counter()
+#     logger.info(f"Incoming Request: {request.method} {request.url.path}")
+
+#     try:
+#         response = await call_next(request)
+#         process_time = (time.perf_counter() - start_time) * 1000
+#         response.headers["X-Request-ID"] = req_id
+#         response.headers["X-Process-Time"] = f"{process_time:.2f}ms"
+#         return response
+#     except Exception as e:
+#         logger.exception("Unhandled Exception in Middleware")
+#         return JSONResponse(
+#             status_code=500,
+#             content={"status": "error", "message": "Internal Server Error", "request_id": req_id}
+#         )
+
+# # ==========================================
+# # 6. ENDPOINTS
+# # ==========================================
+
+# @app.get("/", response_model=BaseResponse)
+# async def root(request: Request):
+#     return {
+#         "request_id": request.state.request_id,
+#         "process_time_ms": 0,
+#         "status": StatusEnum.SUCCESS,
+#         "message": "OCR API is running."
+#     }
+
+# @app.post("/api/v1/get_data", response_model=APIResponse)
+# async def extract_data(
+#     request: Request,
+#     file: UploadFile = File(...),
+#     token: str = Depends(SecurityService.validate_token)
+# ):
+#     start_ts = time.perf_counter()
+#     tmp_file_path = None
+#     req_id = request.state.request_id
+
+#     try:
+#         # 1. Log Upload
+#         logger.info(f"Received file: {file.filename}, Content-Type: {file.content_type}")
+        
+#         FileValidator.validate(file)
+        
+#         # 2. Save File
+#         logger.info("Saving temporary file to disk...")
+#         tmp_file_path = FileValidator.check_size_and_save(file)
+#         logger.info(f"File saved at {tmp_file_path}. Sending to OCR thread.")
+
+#         # 3. Process
+#         result = await run_in_threadpool(
+#             OCRProcessor.process_file,
+#             tmp_file_path,
+#             file.content_type,
+#             req_id # Pass ID explicitly for thread logging
+#         )
+
+#         return {
+#             "request_id": req_id,
+#             "process_time_ms": (time.perf_counter() - start_ts) * 1000,
+#             "status": StatusEnum.SUCCESS,
+#             "message": "OCR Extraction Successful",
+#             "data": {
+#                 "filename": file.filename,
+#                 "content_type": file.content_type,
+#                 "total_pages": result["total_pages"],
+#                 "pages_content": result["pages_content"]
+#             }
+#         }
+
+#     except Exception as e:
+#         logger.error(f"Processing failed: {str(e)}")
+#         status_code = getattr(e, "status_code", 500)
+#         return JSONResponse(
+#             status_code=status_code,
+#             content={
+#                 "request_id": req_id,
+#                 "process_time_ms": (time.perf_counter() - start_ts) * 1000,
+#                 "status": StatusEnum.ERROR,
+#                 "error_message": getattr(e, "detail", str(e))
+#             }
+#         )
+#     finally:
+#         if tmp_file_path and os.path.exists(tmp_file_path):
+#             os.remove(tmp_file_path)
+#             logger.info("Temporary file cleaned up.")
+
+
+
 import os
 import sys
 import uuid
@@ -33,17 +354,12 @@ load_dotenv()
 class Config:
     APP_NAME = os.getenv("APP_NAME", "OCR API")
     API_TOKEN = os.getenv("API_BEARER_TOKEN")
-    MAX_SIZE = int(os.getenv("MAX_FILE_SIZE", 52428800))
+    MAX_SIZE = int(os.getenv("MAX_FILE_SIZE", 52428800)) # 50MB
     
-    # Parse allowed origins from comma-separated string
     allowed_origins_raw = os.getenv("ALLOWED_ORIGINS")
     ALLOWED_ORIGINS = [origin.strip() for origin in allowed_origins_raw.split(",") if origin.strip()] if allowed_origins_raw else []
     ALLOWED_TYPES = ["image/jpeg", "image/png", "image/bmp", "image/webp", "application/pdf"]
 
-# Validation check on startup
-if not Config.API_TOKEN:
-    print("CRITICAL WARNING: API_BEARER_TOKEN is not set in .env")
-
 # ==========================================
 # 2. LOGGING SETUP
 # ==========================================
@@ -74,11 +390,17 @@ class BaseResponse(BaseModel):
     status: StatusEnum
     message: Optional[str] = None
 
+class PageResult(BaseModel):
+    index: int
+    page_number: int
+    text: str
+
 class OCRResult(BaseModel):
     filename: str
     content_type: str
-    pages: int
-    text: str
+    saved_file_path: str  # <--- NEW FIELD
+    total_pages: int
+    pages_content: List[PageResult]
 
 class APIResponse(BaseResponse):
     data: Optional[OCRResult] = None
@@ -93,9 +415,6 @@ class SecurityService:
 
     @staticmethod
     async def validate_token(credentials: HTTPAuthorizationCredentials = Depends(security_scheme)):
-        """
-        Validates the Bearer token.
-        """
         if credentials.credentials != Config.API_TOKEN:
             logger.warning(f"Auth Failed. Token used: {credentials.credentials[:5]}...")
             raise HTTPException(
@@ -116,27 +435,26 @@ class FileValidator:
 
     @staticmethod
     def check_size_and_save(file: UploadFile) -> str:
-        """
-        Stream file to disk to check size without loading entire file into RAM.
-        Returns path to temp file.
-        """
         try:
             suffix = Path(file.filename).suffix
-            # Create a named temp file that persists so Tesseract can read it
-            with tempfile.NamedTemporaryFile(delete=False, suffix=suffix) as buffer:
+            # Create a named temp file that persists (delete=False)
+            with tempfile.NamedTemporaryFile(delete=False, suffix=suffix, dir=tempfile.gettempdir()) as buffer:
                 shutil.copyfileobj(file.file, buffer)
                 tmp_path = buffer.name
             
+            # Return absolute path
+            abs_path = os.path.abspath(tmp_path)
+            
             # Check size
-            file_size = os.path.getsize(tmp_path)
+            file_size = os.path.getsize(abs_path)
             if file_size > Config.MAX_SIZE:
-                os.remove(tmp_path)
+                os.remove(abs_path)
                 raise HTTPException(
                     status_code=status.HTTP_413_REQUEST_ENTITY_TOO_LARGE,
                     detail=f"File size exceeds limit of {Config.MAX_SIZE / (1024*1024)}MB"
                 )
             
-            return tmp_path
+            return abs_path
         except HTTPException:
             raise
         except Exception as e:
@@ -145,63 +463,83 @@ class FileValidator:
 
 class OCRProcessor:
     @classmethod
-    def process_file(cls, file_path: str, content_type: str) -> dict:
-        """
-        Heavy CPU Logic.
-        """
+    def process_file(cls, file_path: str, content_type: str, request_id: str) -> dict:
         start = time.perf_counter()
-        text = ""
-        pages = 1
+        pages_content = []
+        
+        # Helper for threaded logging
+        def log_op(msg):
+            logger.info(f"[Thread-Op] {msg}", extra={'request_id': request_id})
 
         try:
+            log_op(f"Starting OCR processing. File located at: {file_path}")
+
             if content_type == "application/pdf":
+                log_op("Reading PDF file and converting to images...")
+                
                 # Convert PDF to images
                 images = convert_from_path(file_path)
-                pages = len(images)
-                # Extract text from each page
-                page_texts = []
+                total_pages = len(images)
+                
+                log_op(f"PDF Conversion Success. Total Pages: {total_pages}")
+
                 for idx, img in enumerate(images):
-                    page_texts.append(f"--- Page {idx+1} ---\n{pytesseract.image_to_string(img)}")
-                text = "\n\n".join(page_texts)
+                    page_num = idx + 1
+                    log_op(f"Processing Page {page_num}/{total_pages}...")
+                    
+                    extracted_text = pytesseract.image_to_string(img).strip()
+                    
+                    log_op(f"Page {page_num} Done. Extracted {len(extracted_text)} characters.")
+                    
+                    pages_content.append({
+                        "index": idx,
+                        "page_number": page_num,
+                        "text": extracted_text
+                    })
             else:
                 # Standard Image
-                text = pytesseract.image_to_string(Image.open(file_path))
-            
+                log_op("Processing single image file...")
+                img = Image.open(file_path)
+                text = pytesseract.image_to_string(img).strip()
+                log_op(f"Image processing complete. Extracted {len(text)} characters.")
+                
+                pages_content.append({
+                    "index": 0,
+                    "page_number": 1,
+                    "text": text
+                })
+
             duration = (time.perf_counter() - start) * 1000
-            logger.info(f"OCR CPU Engine finished in {duration:.2f}ms")
+            log_op(f"OCR CPU Task finished in {duration:.2f}ms")
             
-            return {"pages": pages, "text": text}
+            return {
+                "total_pages": len(pages_content), 
+                "pages_content": pages_content
+            }
+
         except Exception as e:
-            logger.error(f"OCR Extraction Error: {str(e)}")
-            raise ValueError("Failed to extract text from document")
+            log_op(f"OCR Extraction Logic Error: {str(e)}")
+            raise ValueError(f"Failed to process document: {str(e)}")
 
 # ==========================================
 # 5. FASTAPI APP INIT
 # ==========================================
 
-app = FastAPI(
-    title=Config.APP_NAME,
-    version="1.0.0",
-    docs_url="/docs", # You can disable this in prod by setting to None
-    redoc_url=None
-)
+app = FastAPI(title=Config.APP_NAME)
 
-# STRICT CORS CONFIGURATION
 app.add_middleware(
     CORSMiddleware,
-    allow_origins=Config.ALLOWED_ORIGINS,  # Loaded from .env
+    allow_origins=Config.ALLOWED_ORIGINS,
     allow_credentials=True,
-    allow_methods=["GET", "POST"],         # STRICT: Only GET and POST allowed
-    allow_headers=["Authorization", "Content-Type", "X-Request-ID"], # Allowed headers
+    allow_methods=["GET", "POST"],
+    allow_headers=["Authorization", "Content-Type", "X-Request-ID"],
 )
 
-# Middleware: Request ID & Logging
 @app.middleware("http")
 async def request_context_middleware(request: Request, call_next):
     req_id = str(uuid.uuid4())
     request.state.request_id = req_id
     
-    # Inject ID into logger
     old_factory = logging.getLogRecordFactory()
     def record_factory(*args, **kwargs):
         record = old_factory(*args, **kwargs)
@@ -210,14 +548,13 @@ async def request_context_middleware(request: Request, call_next):
     logging.setLogRecordFactory(record_factory)
 
     start_time = time.perf_counter()
-    logger.info(f"Incoming Request: {request.method} {request.url.path} | Origin: {request.headers.get('origin', 'unknown')}")
+    logger.info(f"Incoming Request: {request.method} {request.url.path}")
 
     try:
         response = await call_next(request)
         process_time = (time.perf_counter() - start_time) * 1000
         response.headers["X-Request-ID"] = req_id
         response.headers["X-Process-Time"] = f"{process_time:.2f}ms"
-        logger.info(f"Response: {response.status_code} | Time: {process_time:.2f}ms")
         return response
     except Exception as e:
         logger.exception("Unhandled Exception in Middleware")
@@ -232,7 +569,6 @@ async def request_context_middleware(request: Request, call_next):
 
 @app.get("/", response_model=BaseResponse)
 async def root(request: Request):
-    """Simple connectivity check."""
     return {
         "request_id": request.state.request_id,
         "process_time_ms": 0,
@@ -240,79 +576,64 @@ async def root(request: Request):
         "message": "OCR API is running."
     }
 
-@app.get("/api/v1/ping", response_model=BaseResponse)
-async def health_check(request: Request):
-    """Docker Healthcheck Endpoint."""
-    return {
-        "request_id": request.state.request_id,
-        "process_time_ms": 0,
-        "status": StatusEnum.SUCCESS,
-        "message": "OCR API is healthy."
-    }
-
 @app.post("/api/v1/get_data", response_model=APIResponse)
 async def extract_data(
     request: Request,
     file: UploadFile = File(...),
     token: str = Depends(SecurityService.validate_token)
 ):
-    """
-    Main OCR Endpoint. 
-    Non-blocking: Offloads OCR to threadpool.
-    """
     start_ts = time.perf_counter()
     tmp_file_path = None
+    req_id = request.state.request_id
 
     try:
-        # 1. Validate File Type
+        logger.info(f"Received Upload: {file.filename} ({file.content_type})")
+        
+        # 1. Validate
         FileValidator.validate(file)
-
-        # 2. Save File (IO Bound)
+        
+        # 2. Save (Disk IO)
         tmp_file_path = FileValidator.check_size_and_save(file)
+        logger.info(f"File successfully saved to disk at: {tmp_file_path}")
 
-        # 3. Process (CPU Bound) - Run in ThreadPool for Non-Blocking
+        # 3. Process (CPU Bound) - Run in ThreadPool
         result = await run_in_threadpool(
             OCRProcessor.process_file,
             tmp_file_path,
-            file.content_type
+            file.content_type,
+            req_id
         )
 
+        # 4. Return Response (File is NOT deleted)
         return {
-            "request_id": request.state.request_id,
+            "request_id": req_id,
             "process_time_ms": (time.perf_counter() - start_ts) * 1000,
             "status": StatusEnum.SUCCESS,
             "message": "OCR Extraction Successful",
             "data": {
                 "filename": file.filename,
                 "content_type": file.content_type,
-                "pages": result["pages"],
-                "text": result["text"]
+                "saved_file_path": tmp_file_path,  # Returning the full path
+                "total_pages": result["total_pages"],
+                "pages_content": result["pages_content"]
             }
         }
 
-    except HTTPException as he:
-        raise he
-    except ValueError as ve:
-        # OCR logic errors
-        return {
-            "request_id": request.state.request_id,
-            "process_time_ms": (time.perf_counter() - start_ts) * 1000,
-            "status": StatusEnum.ERROR,
-            "error_message": str(ve)
-        }
     except Exception as e:
-        logger.error(f"Unexpected API Error: {e}")
-        return {
-            "request_id": request.state.request_id,
-            "process_time_ms": (time.perf_counter() - start_ts) * 1000,
-            "status": StatusEnum.ERROR,
-            "error_message": "An unexpected error occurred."
-        }
+        logger.error(f"Request failed: {str(e)}")
+        # Even on error, we might want to keep the file for debugging if it was saved
+        status_code = getattr(e, "status_code", 500)
+        return JSONResponse(
+            status_code=status_code,
+            content={
+                "request_id": req_id,
+                "process_time_ms": (time.perf_counter() - start_ts) * 1000,
+                "status": StatusEnum.ERROR,
+                "error_message": getattr(e, "detail", str(e))
+            }
+        )
     finally:
-        # Cleanup temp file
-        if tmp_file_path and os.path.exists(tmp_file_path):
-            try:
-                os.remove(tmp_file_path)
-                logger.info("Temp file deleted.")
-            except OSError:
-                pass
+        # User requested NOT to remove the temp file.
+        # Logging that file persists for clarity.
+        if tmp_file_path:
+            logger.info(f"Request complete. File preserved at: {tmp_file_path}")