init

.gitattributes

@@ -0,0 +1 @@
+*.index filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -0,0 +1,11 @@
+__pycache__/
+env/
+venv/
+.venv/
+.idea/
+*.log
+*.egg-info/
+pip-wheel-EntityData/
+.env
+.DS_Store
+static/

Dockerfile

@@ -0,0 +1,17 @@
+FROM python:3.12.7
+
+RUN useradd -m -u 1000 user
+USER user
+ENV PATH="/home/user/.local/bin:$PATH"
+
+WORKDIR /app
+
+COPY --chown=user ./requirements.txt requirements.txt
+RUN pip install --no-cache-dir --upgrade -r requirements.txt
+
+USER root
+RUN apt-get update && apt-get install -y poppler-utils
+USER user
+
+COPY --chown=user . /app
+CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "7860"]

README.md

@@ -0,0 +1,8 @@
+---
+title: Ocr 2
+emoji: 😻
+colorFrom: purple
+colorTo: indigo
+sdk: docker
+pinned: false
+---

main.py

@@ -0,0 +1,3 @@
+from ocr import create_app
+
+app = create_app()

ocr/__init__.py

@@ -0,0 +1,46 @@
+import os
+
+from fastapi import FastAPI
+from fastapi.middleware.cors import CORSMiddleware
+from starlette.exceptions import HTTPException as StarletteHTTPException
+from starlette.staticfiles import StaticFiles
+
+from ocr.core.config import settings
+from ocr.core.wrappers import OcrResponseWrapper, ErrorOcrResponse
+
+
+def create_app() -> FastAPI:
+    app = FastAPI()
+
+    from ocr.api.message import report_router
+    app.include_router(report_router, tags=['message'])
+
+    app.add_middleware(
+        CORSMiddleware,
+        allow_origins=["*"],
+        allow_methods=["*"],
+        allow_headers=["*"],
+    )
+
+    static_directory = os.path.join(settings.BASE_DIR, 'static')
+    if not os.path.exists(static_directory):
+        os.makedirs(static_directory)
+
+    app.mount(
+        '/static',
+        StaticFiles(directory='static'),
+    )
+
+    @app.exception_handler(StarletteHTTPException)
+    async def http_exception_handler(_, exc):
+        return OcrResponseWrapper(
+            data=None,
+            successful=False,
+            error=ErrorOcrResponse(message=str(exc.detail))
+        ).response(exc.status_code)
+
+    @app.get("/")
+    async def read_root():
+        return {"message": "Hello world!"}
+
+    return app

ocr/api/message/__init__.py

@@ -0,0 +1,7 @@
+from fastapi.routing import APIRouter
+
+report_router = APIRouter(
+    prefix="/api/report", tags=["message"]
+)
+
+from . import views

ocr/api/message/ai/openai_request.py

@@ -0,0 +1,17 @@
+from ocr.api.message.ai.prompts import OCRPrompts
+from ocr.core.wrappers import openai_wrapper
+
+
+@openai_wrapper(model='gpt-4o-mini')
+async def generate_report(request_content: list[dict]):
+    messages = [
+        {
+            "role": "system",
+            "content": OCRPrompts.generate_general_answer
+        },
+        {
+            "role": "user",
+            "content": request_content
+        }
+    ]
+    return messages

ocr/api/message/ai/prompts.py

@@ -0,0 +1,44 @@
+class OCRPrompts:
+    generate_general_answer = """## Task
+
+You must analyze the text extracted from medical document and generate a comprehensive report in **Markdown2** format. Ensure that every detail provided in the document is included, and do not omit or modify any information. Your output must strictly follow the required format.
+
+## Report Structure
+
+The report should be structured as follows, with each section containing only relevant information from the document:
+
+```markdown
+## Patient Information
+
+- Name: [Patient Name]
+- Age: [Patient Age]
+- Date of Scan: [Date]
+- Indication: [Reason for the CT scan]
+
+## Findings
+
+**Primary findings**:
+[Describe significant abnormalities or findings relevant to the indication]
+
+** Secondary findings**:
+[List incidental findings, e.g., "Mild hepatic steatosis noted."]
+**No abnormalities**:
+[Mention organs or systems without abnormalities, e.g., "No evidence of lymphadenopathy or pleural effusion."]
+
+## Impression
+
+[Summarize the findings concisely, e.g., "Findings suggest a primary lung tumor. Biopsy recommended for further evaluation."]
+
+## Recommendations
+
+[Include next steps or further tests, e.g., "PET scan and consultation with oncology recommended."]
+```
+
+[INST]
+
+## Instructions
+
+- **Do not invent or infer any information.** Only use data provided in the user request.
+- Ensure that the format is followed strictly, and the output is complete without any deviations.
+
+[/INST]"""

ocr/api/message/db_requests.py

@@ -0,0 +1,26 @@
+import asyncio
+
+from ocr.api.message.model import MessageModel
+from ocr.core.config import settings
+
+
+async def get_all_chat_messages_obj(page_size: int, page_index: int) -> tuple[list[MessageModel], int]:
+    skip = page_size * page_index
+    objects, total_count = await asyncio.gather(
+        settings.DB_CLIENT.messages
+        .find()
+        .skip(skip)
+        .limit(page_size)
+        .to_list(length=page_size),
+        settings.DB_CLIENT.messages.count_documents({})
+    )
+    return objects, total_count
+
+
+async def save_report_obj(report: str, filename: str) -> MessageModel:
+    message = MessageModel(
+        text=report,
+        filename=filename,
+    )
+    await settings.DB_CLIENT.messages.insert_one(message.to_mongo())
+    return message

ocr/api/message/dto.py

@@ -0,0 +1,7 @@
+from pydantic import BaseModel
+
+
+class Paging(BaseModel):
+    pageSize: int
+    pageIndex: int
+    totalCount: int

ocr/api/message/model.py

@@ -0,0 +1,12 @@
+from datetime import datetime
+
+from pydantic import Field
+
+from ocr.core.database import MongoBaseModel
+
+
+class MessageModel(MongoBaseModel):
+    text: str
+    filename: str
+    datetimeInserted: datetime = Field(default_factory=datetime.now)
+    datetimeUpdated: datetime = Field(default_factory=datetime.now)

ocr/api/message/schemas.py

@@ -0,0 +1,22 @@
+from pydantic import BaseModel
+
+from ocr.api.message.dto import Paging
+from ocr.api.message.model import MessageModel
+from ocr.core.wrappers import OcrResponseWrapper
+
+
+class CreateMessageRequest(BaseModel):
+    text: str
+
+
+class MessageWrapper(OcrResponseWrapper[MessageModel]):
+    pass
+
+
+class AllMessageResponse(BaseModel):
+    paging: Paging
+    data: list[MessageModel]
+
+
+class AllMessageWrapper(OcrResponseWrapper[AllMessageResponse]):
+    pass

ocr/api/message/views.py

@@ -0,0 +1,41 @@
+from typing import Optional
+
+from fastapi import Query, UploadFile, File
+
+from ocr.api.message import report_router
+from ocr.api.message.ai.openai_request import generate_report
+from ocr.api.message.db_requests import get_all_chat_messages_obj, save_report_obj
+from ocr.api.message.dto import Paging
+from ocr.api.message.model import MessageModel
+from ocr.api.message.schemas import (AllMessageWrapper,
+                                     AllMessageResponse)
+from ocr.api.message.utils import divide_images, prepare_request_content, clean_response
+from ocr.core.wrappers import OcrResponseWrapper
+
+
+@report_router.get('/all')
+async def get_all_chat_messages(
+        pageSize: Optional[int] = Query(10, description="Number of countries to return per page"),
+        pageIndex: Optional[int] = Query(0, description="Page index to retrieve"),
+) -> AllMessageWrapper:
+    messages, _ = await get_all_chat_messages_obj(pageSize, pageIndex)
+    response = AllMessageResponse(
+        paging=Paging(pageSize=len(messages), pageIndex=0, totalCount=len(messages)),
+        data=messages
+    )
+    return AllMessageWrapper(data=response)
+
+
+@report_router.post('/generate')
+async def create_message(
+        file: UploadFile = File(...),
+) -> OcrResponseWrapper[MessageModel]:
+    try:
+        contents = await file.read()
+        images = divide_images(contents)
+        content = prepare_request_content(images)
+        report = await generate_report(content)
+        response = await save_report_obj(clean_response(report), file.filename)
+        return OcrResponseWrapper(data=response)
+    finally:
+        await file.close()

ocr/core/config.py

@@ -0,0 +1,38 @@
+import os
+import pathlib
+from functools import lru_cache
+
+import motor.motor_asyncio
+from dotenv import load_dotenv
+from openai import AsyncClient
+
+load_dotenv()
+
+class BaseConfig:
+    BASE_DIR: pathlib.Path = pathlib.Path(__file__).parent.parent.parent
+    SECRET_KEY = os.getenv('SECRET')
+    OPENAI_CLIENT = AsyncClient(api_key=os.getenv('OPENAI_API_KEY'))
+    DB_CLIENT = motor.motor_asyncio.AsyncIOMotorClient(os.getenv("MONGO_DB_URL")).Ocr
+
+class DevelopmentConfig(BaseConfig):
+    Issuer = "http://localhost:8000"
+    Audience = "http://localhost:3000"
+
+
+class ProductionConfig(BaseConfig):
+    Issuer = ""
+    Audience = ""
+
+
+@lru_cache()
+def get_settings() -> DevelopmentConfig | ProductionConfig:
+    config_cls_dict = {
+        'development': DevelopmentConfig,
+        'production': ProductionConfig,
+    }
+    config_name = os.getenv('FASTAPI_CONFIG', default='development')
+    config_cls = config_cls_dict[config_name]
+    return config_cls()
+
+
+settings = get_settings()

ocr/core/database.py

@@ -0,0 +1,101 @@
+from datetime import datetime
+from enum import Enum
+from typing import Dict, Any, Type
+
+from bson import ObjectId
+from pydantic import GetCoreSchemaHandler, BaseModel, Field, AnyUrl
+from pydantic.json_schema import JsonSchemaValue
+from pydantic_core import core_schema
+
+
+class PyObjectId:
+    @classmethod
+    def __get_pydantic_core_schema__(
+            cls, source: type, handler: GetCoreSchemaHandler
+    ) -> core_schema.CoreSchema:
+        return core_schema.with_info_after_validator_function(
+            cls.validate, core_schema.str_schema()
+        )
+
+    @classmethod
+    def __get_pydantic_json_schema__(
+            cls, schema: core_schema.CoreSchema, handler: GetCoreSchemaHandler
+    ) -> JsonSchemaValue:
+        return {"type": "string"}
+
+    @classmethod
+    def validate(cls, value: str) -> ObjectId:
+        if not ObjectId.is_valid(value):
+            raise ValueError(f"Invalid ObjectId: {value}")
+        return ObjectId(value)
+
+    def __getattr__(self, item):
+        return getattr(self.__dict__['value'], item)
+
+    def __init__(self, value: str = None):
+        if value is None:
+            self.value = ObjectId()
+        else:
+            self.value = self.validate(value)
+
+    def __str__(self):
+        return str(self.value)
+
+
+class MongoBaseModel(BaseModel):
+    id: str = Field(default_factory=lambda: str(PyObjectId()))
+
+    class Config:
+        arbitrary_types_allowed = True
+
+    def to_mongo(self) -> Dict[str, Any]:
+        def model_to_dict(model: BaseModel) -> Dict[str, Any]:
+            doc = {}
+            for name, value in model._iter():
+                key = model.__fields__[name].alias or name
+
+                if isinstance(value, BaseModel):
+                    doc[key] = model_to_dict(value)
+                elif isinstance(value, list) and all(isinstance(i, BaseModel) for i in value):
+                    doc[key] = [model_to_dict(item) for item in value]
+                elif value and isinstance(value, Enum):
+                    doc[key] = value.value
+                elif isinstance(value, datetime):
+                    doc[key] = value.isoformat()
+                elif value and isinstance(value, AnyUrl):
+                    doc[key] = str(value)
+                else:
+                    doc[key] = value
+
+            return doc
+
+        result = model_to_dict(self)
+        return result
+
+    @classmethod
+    def from_mongo(cls, data: Dict[str, Any]):
+        def restore_enums(inst: Any, model_cls: Type[BaseModel]) -> None:
+            for name, field in model_cls.__fields__.items():
+                value = getattr(inst, name)
+                if field and isinstance(field.annotation, type) and issubclass(field.annotation, Enum):
+                    setattr(inst, name, field.annotation(value))
+                elif isinstance(value, BaseModel):
+                    restore_enums(value, value.__class__)
+                elif isinstance(value, list):
+                    for i, item in enumerate(value):
+                        if isinstance(item, BaseModel):
+                            restore_enums(item, item.__class__)
+                        elif isinstance(field.annotation, type) and issubclass(field.annotation, Enum):
+                            value[i] = field.annotation(item)
+                elif isinstance(value, dict):
+                    for k, v in value.items():
+                        if isinstance(v, BaseModel):
+                            restore_enums(v, v.__class__)
+                        elif isinstance(field.annotation, type) and issubclass(field.annotation, Enum):
+                            value[k] = field.annotation(v)
+
+        if data is None:
+            return None
+        instance = cls(**data)
+        restore_enums(instance, instance.__class__)
+        return instance

ocr/core/wrappers.py

@@ -0,0 +1,87 @@
+import json
+from functools import wraps
+from typing import Generic, Optional, TypeVar
+
+import pydash
+from fastapi import HTTPException
+from pydantic import BaseModel
+from starlette.responses import JSONResponse
+
+from ocr.core.config import settings
+
+T = TypeVar('T')
+
+
+class ErrorOcrResponse(BaseModel):
+    message: str
+
+
+class OcrResponseWrapper(BaseModel, Generic[T]):
+    data: Optional[T] = None
+    successful: bool = True
+    error: Optional[ErrorOcrResponse] = None
+
+    def response(self, status_code: int):
+        return JSONResponse(
+            status_code=status_code,
+            content={
+                "data": self.data,
+                "successful": self.successful,
+                "error": self.error.dict() if self.error else None
+            }
+        )
+
+
+def exception_wrapper(http_error: int, error_message: str):
+    def decorator(func):
+        @wraps(func)
+        async def wrapper(*args, **kwargs):
+            try:
+                return await func(*args, **kwargs)
+            except Exception as e:
+                raise HTTPException(status_code=http_error, detail=error_message) from e
+
+        return wrapper
+
+    return decorator
+
+
+def openai_wrapper(
+        temperature: int | float = 0, model: str = "gpt-4o-mini", is_json: bool = False, return_: str = None
+):
+    def decorator(func):
+        @wraps(func)
+        async def wrapper(*args, **kwargs) -> str:
+            messages = await func(*args, **kwargs)
+            completion = await settings.OPENAI_CLIENT.chat.completions.create(
+                messages=messages,
+                temperature=temperature,
+                n=1,
+                model=model,
+                response_format={"type": "json_object"} if is_json else {"type": "text"}
+            )
+            response = completion.choices[0].message.content
+            if is_json:
+                response = json.loads(response)
+                if return_:
+                    return pydash.get(response, return_)
+            return response
+
+        return wrapper
+
+    return decorator
+
+
+def background_task():
+    def decorator(func):
+        @wraps(func)
+        async def wrapper(*args, **kwargs) -> str:
+            try:
+                result = await func(*args, **kwargs)
+                return result
+            except Exception as e:
+                pass
+
+        return wrapper
+
+    return decorator

requirements.txt

@@ -0,0 +1,33 @@
+annotated-types==0.7.0
+anyio==4.8.0
+certifi==2025.1.31
+click==8.1.8
+distro==1.9.0
+dnspython==2.7.0
+fastapi==0.115.8
+h11==0.14.0
+httpcore==1.0.7
+httptools==0.6.4
+httpx==0.28.1
+idna==3.10
+jiter==0.8.2
+motor==3.7.0
+openai==1.59.9
+packaging==24.2
+pdf2image==1.17.0
+pillow==11.1.0
+pydantic==2.10.6
+pydantic_core==2.27.2
+pymongo==4.11
+pytesseract==0.3.13
+python-dotenv==1.0.1
+python-multipart==0.0.20
+PyYAML==6.0.2
+sniffio==1.3.1
+starlette==0.45.3
+tqdm==4.67.1
+typing_extensions==4.12.2
+uvicorn==0.34.0
+uvloop==0.21.0
+watchfiles==1.0.4
+websockets==14.2