backend

.gitignore

@@ -0,0 +1,47 @@
+# Python
+__pycache__/
+*.py[cod]
+*$py.class
+*.so
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+
+# Virtual Environment
+venv/
+env/
+ENV/
+
+# IDE
+.idea/
+.vscode/
+*.swp
+*.swo
+
+# Database
+*.db
+*.sqlite3
+
+# Environment variables
+.env
+.env.local
+
+# Logs
+*.log
+
+# Hugging Face specific
+.cache/
+transformers/ 

Dockerfile

@@ -0,0 +1,33 @@
+FROM python:3.9
+
+# Set up a new user named "user" with user ID 1000
+RUN useradd -m -u 1000 user
+
+# Switch to the "user" user
+USER user
+
+# Set home to the user's home directory
+ENV HOME=/home/user \
+    PATH=/home/user/.local/bin:$PATH
+
+# Set the working directory to the user's home directory
+WORKDIR $HOME/app
+
+# Try and run pip command after setting the user with `USER user` to avoid permission issues with Python
+RUN pip install --no-cache-dir --upgrade pip
+
+# Copy the current directory contents into the container at $HOME/app setting the owner to the user
+COPY --chown=user . $HOME/app
+
+# Install dependencies
+RUN pip install --no-cache-dir --upgrade -r requirements.txt
+
+# Create a directory for model cache
+RUN mkdir -p $HOME/.cache/huggingface
+RUN chmod 777 $HOME/.cache/huggingface
+
+# Expose the port the app runs on
+EXPOSE 7860
+
+# Command to run the application
+CMD ["uvicorn", "app:app", "--host", "0.0.0.0", "--port", "7860"] 

LICENSE

@@ -0,0 +1,55 @@
+Synthex AI - Commercial License
+
+Copyright (c) 2024 Synthex AI
+
+This software and associated documentation files (the "Software") are proprietary and confidential. 
+The Software is protected by copyright laws and international copyright treaties, as well as other 
+intellectual property laws and treaties.
+
+TERMS AND CONDITIONS
+
+1. License Grant
+   This license grants you a limited, non-exclusive, non-transferable license to use the Software 
+   solely for your internal business purposes, subject to the terms and conditions of this Agreement.
+
+2. Restrictions
+   You may not:
+   - Copy, modify, or create derivative works of the Software
+   - Reverse engineer, decompile, or disassemble the Software
+   - Remove or alter any proprietary notices or labels on the Software
+   - Use the Software for any illegal purpose
+   - Transfer, sublicense, or resell the Software
+
+3. Proprietary Rights
+   The Software and all copies, modifications, and derivative works are owned by Synthex AI and 
+   are protected by copyright, trade secret, and other intellectual property laws.
+
+4. Confidentiality
+   You agree to maintain the confidentiality of the Software and not disclose it to any third party 
+   without Synthex AI's prior written consent.
+
+5. Warranty Disclaimer
+   THE SOFTWARE IS PROVIDED "AS IS" WITHOUT WARRANTY OF ANY KIND. SYNTHEX AI DISCLAIMS ALL 
+   WARRANTIES, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
+   FITNESS FOR A PARTICULAR PURPOSE, AND NONINFRINGEMENT.
+
+6. Limitation of Liability
+   IN NO EVENT SHALL SYNTHEX AI BE LIABLE FOR ANY CLAIM, DAMAGES, OR OTHER LIABILITY ARISING FROM, 
+   OUT OF, OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+7. Termination
+   This license is effective until terminated. Your rights under this license will terminate 
+   automatically without notice if you fail to comply with any of its terms.
+
+8. Governing Law
+   This Agreement shall be governed by and construed in accordance with the laws of the State of 
+   Delaware, without regard to its conflict of law provisions.
+
+9. Contact Information
+   For licensing inquiries, please contact:
+   Synthex AI
+   Email: [email protected]
+   Website: https://synthex.ai
+
+By using the Software, you acknowledge that you have read this Agreement, understand it, and agree 
+to be bound by its terms and conditions. 

README.md

@@ -0,0 +1,49 @@
+---
+title: Synthex Medical Text Generator
+emoji: 🏥
+colorFrom: blue
+colorTo: indigo
+sdk: docker
+app_port: 7860
+---
+
+# Synthex Medical Text Generator
+
+A synthetic medical text generator built with FastAPI and Hugging Face Transformers.
+
+## Features
+
+- Generate synthetic medical text data
+- Multiple record types:
+  - Clinical Notes
+  - Discharge Summaries
+  - Lab Reports
+  - Prescriptions
+- HIPAA-compliant fictional data
+- RESTful API endpoints
+
+## API Endpoints
+
+- `GET /`: Get API information
+- `POST /generate`: Generate medical records
+- `GET /health`: Health check endpoint
+
+## Example Usage
+
+```bash
+# Generate a clinical note
+curl -X POST "https://theaniketgiri-synthex.hf.space/generate" \
+     -H "Content-Type: application/json" \
+     -d '{"record_type": "clinical_note", "count": 1}'
+```
+
+## Technical Details
+
+- Built with FastAPI
+- Uses Bio_ClinicalBERT model from Hugging Face
+- Docker container with Python 3.9
+- Exposed on port 7860
+
+## License
+
+MIT License 

app.py

@@ -0,0 +1,89 @@
+from fastapi import FastAPI, HTTPException
+from fastapi.middleware.cors import CORSMiddleware
+from pydantic import BaseModel
+from typing import List, Optional
+from datetime import datetime
+from transformers import AutoTokenizer, AutoModelForCausalLM
+import torch
+import json
+
+app = FastAPI(
+    title="Synthex Medical Text Generator",
+    description="Generate synthetic medical text data for research and development purposes.",
+    version="1.0.0"
+)
+
+# Add CORS middleware
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],  # Allows all origins
+    allow_credentials=True,
+    allow_methods=["*"],  # Allows all methods
+    allow_headers=["*"],  # Allows all headers
+)
+
+# Initialize model and tokenizer
+model = None
+tokenizer = None
+
+def load_model():
+    global model, tokenizer
+    if model is None or tokenizer is None:
+        model_name = "emilyalsentzer/Bio_ClinicalBERT"
+        tokenizer = AutoTokenizer.from_pretrained(model_name)
+        model = AutoModelForCausalLM.from_pretrained(model_name)
+    return model, tokenizer
+
+class GenerateRequest(BaseModel):
+    record_type: str
+    count: int = 1
+
+class MedicalRecord(BaseModel):
+    type: str
+    content: str
+    generated_at: str
+
+@app.get("/")
+def read_root():
+    return {
+        "name": "Synthex Medical Text Generator",
+        "version": "1.0.0",
+        "description": "Generate synthetic medical text data for research and development purposes."
+    }
+
+@app.post("/generate", response_model=List[MedicalRecord])
+async def generate_records(request: GenerateRequest):
+    try:
+        model, tokenizer = load_model()
+        
+        records = []
+        for i in range(request.count):
+            # Generate text using the model
+            input_text = f"Generate a {request.record_type}:"
+            inputs = tokenizer(input_text, return_tensors="pt", max_length=512, truncation=True)
+            outputs = model.generate(
+                inputs["input_ids"],
+                max_length=200,
+                num_return_sequences=1,
+                temperature=0.7,
+                top_p=0.9,
+                do_sample=True
+            )
+            generated_text = tokenizer.decode(outputs[0], skip_special_tokens=True)
+            
+            # Create record
+            record = MedicalRecord(
+                type=request.record_type,
+                content=generated_text,
+                generated_at=datetime.now().isoformat()
+            )
+            records.append(record)
+        
+        return records
+    
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+@app.get("/health")
+def health_check():
+    return {"status": "healthy"} 

app/api/admin.py

@@ -0,0 +1,116 @@
+from fastapi import APIRouter, Depends, HTTPException, status
+from fastapi.security import OAuth2PasswordBearer, OAuth2PasswordRequestForm
+from sqlalchemy.orm import Session
+from app.core.database import get_db
+from app.models.models import BetaApplication, ApplicationStatus
+from app.core.config import settings
+from datetime import datetime, timedelta
+from jose import JWTError, jwt
+from pydantic import BaseModel
+from typing import List, Optional
+
+router = APIRouter()
+oauth2_scheme = OAuth2PasswordBearer(tokenUrl="token")
+
+class Token(BaseModel):
+    access_token: str
+    token_type: str
+
+class TokenData(BaseModel):
+    email: Optional[str] = None
+
+class ApplicationUpdate(BaseModel):
+    status: ApplicationStatus
+
+class BetaApplicationResponse(BaseModel):
+    id: str
+    email: str
+    company: str
+    use_case: str
+    status: str
+    created_at: datetime
+    updated_at: Optional[datetime] = None
+
+    class Config:
+        from_attributes = True
+
+class BetaApplicationList(BaseModel):
+    applications: List[BetaApplicationResponse]
+
+def create_access_token(data: dict):
+    to_encode = data.copy()
+    expire = datetime.utcnow() + timedelta(minutes=settings.ACCESS_TOKEN_EXPIRE_MINUTES)
+    to_encode.update({"exp": expire})
+    encoded_jwt = jwt.encode(to_encode, settings.SECRET_KEY, algorithm="HS256")
+    return encoded_jwt
+
+async def get_current_admin(token: str = Depends(oauth2_scheme)):
+    credentials_exception = HTTPException(
+        status_code=status.HTTP_401_UNAUTHORIZED,
+        detail="Could not validate credentials",
+        headers={"WWW-Authenticate": "Bearer"},
+    )
+    try:
+        payload = jwt.decode(token, settings.SECRET_KEY, algorithms=["HS256"])
+        email: str = payload.get("sub")
+        if email is None or email != settings.ADMIN_EMAIL:
+            raise credentials_exception
+        token_data = TokenData(email=email)
+    except JWTError:
+        raise credentials_exception
+    return token_data
+
+@router.post("/login", response_model=Token)
+async def login(form_data: OAuth2PasswordRequestForm = Depends()):
+    if form_data.username != settings.ADMIN_EMAIL or form_data.password != settings.ADMIN_PASSWORD:
+        raise HTTPException(
+            status_code=status.HTTP_401_UNAUTHORIZED,
+            detail="Incorrect email or password",
+            headers={"WWW-Authenticate": "Bearer"},
+        )
+    access_token = create_access_token(data={"sub": form_data.username})
+    return {"access_token": access_token, "token_type": "bearer"}
+
+@router.get("/applications")
+async def get_applications(
+    db: Session = Depends(get_db),
+    current_admin: TokenData = Depends(get_current_admin)
+):
+    applications = db.query(BetaApplication).all()
+    return {
+        "applications": [
+            {
+                "id": app.id,
+                "email": app.email,
+                "company": app.company,
+                "use_case": app.use_case,
+                "status": app.status.value,
+                "created_at": app.created_at.isoformat(),
+                "updated_at": app.updated_at.isoformat() if app.updated_at else None
+            }
+            for app in applications
+        ]
+    }
+
+@router.patch("/applications/{application_id}")
+async def update_application(
+    application_id: str,
+    update: ApplicationUpdate,
+    db: Session = Depends(get_db),
+    current_admin: TokenData = Depends(get_current_admin)
+):
+    application = db.query(BetaApplication).filter(
+        BetaApplication.id == application_id
+    ).first()
+    
+    if not application:
+        raise HTTPException(
+            status_code=404,
+            detail="Application not found"
+        )
+    
+    application.status = update.status
+    db.commit()
+    db.refresh(application)
+    
+    return {"message": "Application updated successfully"} 

app/api/auth.py

@@ -0,0 +1,51 @@
+from fastapi import APIRouter, Depends, HTTPException, status
+from fastapi.security import OAuth2PasswordBearer, OAuth2PasswordRequestForm
+from jose import JWTError, jwt
+from datetime import datetime, timedelta
+from pydantic import BaseModel
+from typing import Optional
+from app.core.config import settings
+
+router = APIRouter()
+oauth2_scheme = OAuth2PasswordBearer(tokenUrl="token")
+
+class Token(BaseModel):
+    access_token: str
+    token_type: str
+
+class TokenData(BaseModel):
+    username: Optional[str] = None
+
+def create_access_token(data: dict):
+    to_encode = data.copy()
+    expire = datetime.utcnow() + timedelta(minutes=settings.ACCESS_TOKEN_EXPIRE_MINUTES)
+    to_encode.update({"exp": expire})
+    encoded_jwt = jwt.encode(to_encode, settings.SECRET_KEY, algorithm="HS256")
+    return encoded_jwt
+
+async def get_current_user(token: str = Depends(oauth2_scheme)):
+    credentials_exception = HTTPException(
+        status_code=status.HTTP_401_UNAUTHORIZED,
+        detail="Could not validate credentials",
+        headers={"WWW-Authenticate": "Bearer"},
+    )
+    try:
+        payload = jwt.decode(token, settings.SECRET_KEY, algorithms=["HS256"])
+        username: str = payload.get("sub")
+        if username is None:
+            raise credentials_exception
+        token_data = TokenData(username=username)
+    except JWTError:
+        raise credentials_exception
+    return token_data
+
+@router.post("/token", response_model=Token)
+async def login_for_access_token(form_data: OAuth2PasswordRequestForm = Depends()):
+    if form_data.username != settings.ADMIN_EMAIL or form_data.password != settings.ADMIN_PASSWORD:
+        raise HTTPException(
+            status_code=status.HTTP_401_UNAUTHORIZED,
+            detail="Incorrect username or password",
+            headers={"WWW-Authenticate": "Bearer"},
+        )
+    access_token = create_access_token(data={"sub": form_data.username})
+    return {"access_token": access_token, "token_type": "bearer"} 

app/api/beta.py

@@ -0,0 +1,87 @@
+from fastapi import APIRouter, Depends, HTTPException, Body
+from sqlalchemy.orm import Session
+from app.core.database import get_db
+from app.models.models import BetaApplication, ApplicationStatus
+from pydantic import BaseModel, Field
+import uuid
+from datetime import datetime
+
+router = APIRouter()
+
+class BetaApplicationCreate(BaseModel):
+    email: str
+    company: str
+    useCase: str = Field(..., alias="use_case")
+
+    class Config:
+        populate_by_name = True
+
+class BetaApplicationResponse(BaseModel):
+    id: str
+    email: str
+    company: str
+    useCase: str = Field(..., alias="use_case")
+    status: str
+    createdAt: datetime = Field(..., alias="created_at")
+    updatedAt: datetime | None = Field(None, alias="updated_at")
+
+    class Config:
+        from_attributes = True
+        populate_by_name = True
+
+class VerifyApplicationRequest(BaseModel):
+    application_id: str
+
+@router.post("/apply", response_model=BetaApplicationResponse)
+def create_application(
+    application: BetaApplicationCreate,
+    db: Session = Depends(get_db)
+):
+    # Check if email already exists
+    existing = db.query(BetaApplication).filter(
+        BetaApplication.email == application.email
+    ).first()
+    
+    if existing:
+        raise HTTPException(
+            status_code=400,
+            detail="Email already registered"
+        )
+    
+    # Create new application
+    db_application = BetaApplication(
+        id=str(uuid.uuid4()),
+        email=application.email,
+        company=application.company,
+        use_case=application.useCase,
+        status=ApplicationStatus.PENDING
+    )
+    
+    db.add(db_application)
+    db.commit()
+    db.refresh(db_application)
+    
+    return db_application
+
+@router.post("/verify")
+def verify_application(
+    request: VerifyApplicationRequest,
+    db: Session = Depends(get_db)
+):
+    application = db.query(BetaApplication).filter(
+        BetaApplication.id == request.application_id
+    ).first()
+    
+    if not application:
+        raise HTTPException(
+            status_code=404,
+            detail="Application not found"
+        )
+    
+    if application.status != ApplicationStatus.APPROVED:
+        raise HTTPException(
+            status_code=403,
+            detail="Application not approved"
+        )
+    
+    return {"message": "Access granted"} 

app/api/data.py

@@ -0,0 +1,38 @@
+from fastapi import APIRouter, Depends, HTTPException
+from sqlalchemy.orm import Session
+from app.core.database import get_db
+from app.models.models import BetaApplication, ApplicationStatus
+from app.services.data_generator import DataGenerator
+from pydantic import BaseModel
+from typing import List, Dict, Any
+
+router = APIRouter()
+data_generator = DataGenerator()
+
+class GenerateDataRequest(BaseModel):
+    count: int = 10
+    record_types: List[str] = ["lab_report", "clinical_note", "discharge_summary"]
+
+class GenerateDataResponse(BaseModel):
+    records: List[Dict[str, Any]]
+
+@router.post("/generate", response_model=GenerateDataResponse)
+async def generate_data(
+    request: GenerateDataRequest,
+    db: Session = Depends(get_db)
+):
+    # Verify application status
+    application = db.query(BetaApplication).filter(
+        BetaApplication.status == ApplicationStatus.APPROVED
+    ).first()
+    
+    if not application:
+        raise HTTPException(
+            status_code=403,
+            detail="No approved application found"
+        )
+    
+    # Generate records
+    records = data_generator.generate_records(request.count, request.record_types)
+    
+    return {"records": records} 

app/api/generator.py

@@ -0,0 +1,98 @@
+from fastapi import APIRouter, HTTPException
+from pydantic import BaseModel
+from typing import List, Optional
+import random
+
+router = APIRouter()
+
+class GenerationRequest(BaseModel):
+    recordType: str
+    quantity: int
+
+class GeneratedRecord(BaseModel):
+    id: str
+    content: str
+    recordType: str
+
+# Templates for different record types
+TEMPLATES = {
+    "Clinical Note": [
+        "Patient presents with {symptom}. Vital signs: BP {bp}, HR {hr}, Temp {temp}. Assessment: {assessment}. Plan: {plan}.",
+        "Follow-up visit for {condition}. Patient reports {symptom}. Current medications: {meds}. Plan: {plan}."
+    ],
+    "Discharge Summary": [
+        "Patient admitted for {condition}. Treatment included {treatment}. Discharged on {date} with instructions to {instructions}.",
+        "Hospital course: {course}. Discharge medications: {meds}. Follow-up with {specialist} in {timeframe}."
+    ],
+    "Lab Report": [
+        "Lab results for {test}: {result}. Reference range: {range}. Interpretation: {interpretation}.",
+        "Blood work shows {finding}. Additional tests recommended: {tests}."
+    ],
+    "Prescription": [
+        "Prescribed {medication} {dose} {frequency} for {condition}. Duration: {duration}. Instructions: {instructions}.",
+        "Medication: {medication}. Dosage: {dose}. Take {frequency} with {food}. Refills: {refills}."
+    ],
+    "Patient Intake": [
+        "New patient intake. Chief complaint: {complaint}. History: {history}. Allergies: {allergies}. Current medications: {meds}.",
+        "Patient demographics: {demographics}. Insurance: {insurance}. Emergency contact: {contact}."
+    ]
+}
+
+# Placeholder data for template variables
+PLACEHOLDERS = {
+    "symptom": ["headache", "fever", "cough", "fatigue", "nausea"],
+    "bp": ["120/80", "130/85", "118/75", "125/82"],
+    "hr": ["72", "80", "68", "75"],
+    "temp": ["98.6", "99.1", "98.2", "99.5"],
+    "assessment": ["stable", "improving", "requires monitoring", "critical"],
+    "plan": ["continue current treatment", "schedule follow-up", "refer to specialist", "discharge"],
+    "condition": ["hypertension", "diabetes", "asthma", "arthritis"],
+    "meds": ["aspirin", "metformin", "albuterol", "ibuprofen"],
+    "treatment": ["antibiotics", "physical therapy", "surgery", "bed rest"],
+    "date": ["2023-10-01", "2023-10-15", "2023-11-01"],
+    "instructions": ["rest", "take medications as prescribed", "follow up in 2 weeks", "avoid strenuous activity"],
+    "course": ["stable", "complicated", "uneventful", "critical"],
+    "specialist": ["cardiologist", "neurologist", "orthopedist", "dermatologist"],
+    "timeframe": ["1 week", "2 weeks", "1 month", "3 months"],
+    "test": ["CBC", "lipid panel", "glucose", "thyroid function"],
+    "result": ["normal", "elevated", "low", "critical"],
+    "range": ["10-20", "70-100", "3.5-5.0", "0.5-1.5"],
+    "interpretation": ["within normal limits", "requires follow-up", "abnormal", "critical"],
+    "finding": ["anemia", "hyperlipidemia", "hypoglycemia", "hyperthyroidism"],
+    "tests": ["MRI", "CT scan", "ultrasound", "biopsy"],
+    "medication": ["amoxicillin", "lisinopril", "atorvastatin", "levothyroxine"],
+    "dose": ["500mg", "10mg", "20mg", "50mcg"],
+    "frequency": ["once daily", "twice daily", "three times daily", "as needed"],
+    "duration": ["7 days", "30 days", "90 days", "indefinite"],
+    "refills": ["0", "1", "2", "3"],
+    "food": ["with food", "on an empty stomach", "with water", "with milk"],
+    "complaint": ["chest pain", "shortness of breath", "joint pain", "dizziness"],
+    "history": ["hypertension", "diabetes", "asthma", "arthritis"],
+    "allergies": ["penicillin", "sulfa", "latex", "none"],
+    "demographics": ["45-year-old male", "60-year-old female", "30-year-old male", "50-year-old female"],
+    "insurance": ["Blue Cross", "Aetna", "Medicare", "Medicaid"],
+    "contact": ["John Doe (555-123-4567)", "Jane Smith (555-987-6543)"]
+}
+
+def generate_record(record_type: str) -> GeneratedRecord:
+    if record_type not in TEMPLATES:
+        raise ValueError(f"Unsupported record type: {record_type}")
+    
+    template = random.choice(TEMPLATES[record_type])
+    content = template.format(**{k: random.choice(v) for k, v in PLACEHOLDERS.items()})
+    
+    return GeneratedRecord(
+        id=f"record-{random.randint(1000, 9999)}",
+        content=content,
+        recordType=record_type
+    )
+
+@router.post("/generate", response_model=List[GeneratedRecord])
+async def generate_records(request: GenerationRequest):
+    if request.quantity <= 0:
+        raise HTTPException(status_code=400, detail="Quantity must be positive")
+    if request.quantity > 100:
+        raise HTTPException(status_code=400, detail="Quantity cannot exceed 100")
+    
+    records = [generate_record(request.recordType) for _ in range(request.quantity)]
+    return records 

app/api/medical.py

@@ -0,0 +1,33 @@
+from fastapi import APIRouter, HTTPException
+from pydantic import BaseModel
+from typing import List, Dict, Any
+from app.services.medical_generator import MedicalTextGenerator
+
+router = APIRouter()
+generator = MedicalTextGenerator()
+
+class GenerateRequest(BaseModel):
+    count: int = 1
+    record_type: str = "clinical_note"
+
+class GenerateResponse(BaseModel):
+    records: List[Dict[str, Any]]
+
+@router.post("/generate", response_model=GenerateResponse)
+async def generate_medical_text(request: GenerateRequest):
+    """
+    Generate synthetic medical text records.
+    
+    Args:
+        request: GenerateRequest containing count and record_type
+        
+    Returns:
+        GenerateResponse containing the generated records
+    """
+    try:
+        records = generator.batch_generate(request.count, request.record_type)
+        return GenerateResponse(records=records)
+    except ValueError as e:
+        raise HTTPException(status_code=400, detail=str(e))
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Error generating records: {str(e)}") 

app/core/config.py

@@ -0,0 +1,23 @@
+from pydantic_settings import BaseSettings
+from typing import Optional
+
+class Settings(BaseSettings):
+    # API Settings
+    API_V1_STR: str = "/api/v1"
+    PROJECT_NAME: str = "Synthex"
+    
+    # Security
+    SECRET_KEY: str = "your-secret-key-here"  # Change this in production
+    ACCESS_TOKEN_EXPIRE_MINUTES: int = 60 * 24 * 8  # 8 days
+    
+    # Database
+    DATABASE_URL: str = "postgresql://neondb_owner:npg_tRvA0lD3GrZk@ep-lucky-rain-a8rbsfj4-pooler.eastus2.azure.neon.tech/neondb?sslmode=require"
+    
+    # Admin
+    ADMIN_EMAIL: str = "[email protected]"
+    ADMIN_PASSWORD: str = "admin123"  # Change this in production
+    
+    class Config:
+        case_sensitive = True
+
+settings = Settings() 

app/core/database.py

@@ -0,0 +1,21 @@
+from sqlalchemy import create_engine
+from sqlalchemy.ext.declarative import declarative_base
+from sqlalchemy.orm import sessionmaker
+from app.core.config import settings
+
+engine = create_engine(settings.DATABASE_URL)
+SessionLocal = sessionmaker(autocommit=False, autoflush=False, bind=engine)
+
+Base = declarative_base()
+
+# Dependency
+def get_db():
+    db = SessionLocal()
+    try:
+        yield db
+    finally:
+        db.close()
+
+# Create tables
+def init_db():
+    Base.metadata.create_all(bind=engine) 

app/main.py

@@ -0,0 +1,40 @@
+from fastapi import FastAPI
+from fastapi.middleware.cors import CORSMiddleware
+from app.api import beta, admin, generator, auth, data, medical
+from app.core.config import settings
+from app.core.database import init_db, engine, Base
+
+app = FastAPI(
+    title="Synthex API",
+    description="API for generating synthetic medical records",
+    version="1.0.0",
+)
+
+# Initialize database on startup
+@app.on_event("startup")
+async def startup_event():
+    init_db()
+
+# Configure CORS
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["http://localhost:3000"],  # Frontend URL
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+# Include routers
+app.include_router(beta.router, prefix="/api/beta", tags=["beta"])
+app.include_router(admin.router, prefix="/api/admin", tags=["admin"])
+app.include_router(generator.router, prefix="/api/generator", tags=["generator"])
+app.include_router(auth.router, prefix="/api/auth", tags=["auth"])
+app.include_router(data.router, prefix="/api/data", tags=["data"])
+app.include_router(medical.router, prefix="/api/medical", tags=["medical"])
+
+@app.get("/")
+async def root():
+    return {"message": "Welcome to Synthex API"}
+
+# Create database tables
+Base.metadata.create_all(bind=engine) 

app/models/models.py

@@ -0,0 +1,20 @@
+from sqlalchemy import Column, String, DateTime, Enum
+from sqlalchemy.sql import func
+from app.core.database import Base
+import enum
+
+class ApplicationStatus(str, enum.Enum):
+    PENDING = "pending"
+    APPROVED = "approved"
+    REJECTED = "rejected"
+
+class BetaApplication(Base):
+    __tablename__ = "beta_applications"
+
+    id = Column(String, primary_key=True, index=True)
+    email = Column(String, unique=True, index=True)
+    company = Column(String)
+    use_case = Column(String)
+    status = Column(Enum(ApplicationStatus), default=ApplicationStatus.PENDING)
+    created_at = Column(DateTime(timezone=True), server_default=func.now())
+    updated_at = Column(DateTime(timezone=True), onupdate=func.now()) 

app/routers/data.py

@@ -0,0 +1,57 @@
+from fastapi import APIRouter, HTTPException
+from pydantic import BaseModel
+from typing import List, Optional
+from ..services.data_generator import DataGenerator
+import logging
+
+# Configure logging
+logging.basicConfig(level=logging.DEBUG)
+logger = logging.getLogger(__name__)
+
+router = APIRouter()
+generator = DataGenerator()
+
+class GenerateRequest(BaseModel):
+    count: int
+    types: List[str]
+    export_format: Optional[str] = "JSON"
+
+@router.post("/generate")
+async def generate_records(request: GenerateRequest):
+    """Generate synthetic medical records."""
+    try:
+        logger.debug(f"Received request: count={request.count}, types={request.types}, export_format={request.export_format}")
+        
+        # Validate count
+        if request.count < 1 or request.count > 100:
+            raise HTTPException(status_code=400, detail="Count must be between 1 and 100")
+        
+        # Validate types
+        valid_types = ["clinical_note", "discharge_summary", "lab_report", "prescription", "patient_intake"]
+        if not all(t in valid_types for t in request.types):
+            raise HTTPException(status_code=400, detail=f"Invalid record type. Must be one of: {', '.join(valid_types)}")
+        
+        # Generate records
+        logger.debug("Generating records...")
+        records = generator.generate_records(count=request.count, types=request.types)
+        logger.debug(f"Generated {len(records)} records")
+        
+        # Export if format specified
+        if request.export_format:
+            try:
+                logger.debug(f"Exporting records in {request.export_format} format")
+                exported_data = generator.export_records(records, request.export_format)
+                return {
+                    "records": records,
+                    "exported_data": exported_data,
+                    "export_format": request.export_format
+                }
+            except ValueError as e:
+                logger.error(f"Export error: {str(e)}")
+                raise HTTPException(status_code=400, detail=str(e))
+        
+        return {"records": records}
+    
+    except Exception as e:
+        logger.error(f"Error generating records: {str(e)}", exc_info=True)
+        raise HTTPException(status_code=500, detail=str(e)) 

app/services/data_generator.py

@@ -0,0 +1,251 @@
+from typing import List, Dict, Any
+from datetime import datetime, timedelta
+import random
+import json
+import csv
+import io
+
+class DataGenerator:
+    def __init__(self):
+        self.first_names = [
+            "John", "Jane", "Michael", "Emily", "David", "Sarah", "James", "Emma",
+            "Robert", "Olivia", "William", "Sophia", "Daniel", "Ava", "Matthew", "Isabella"
+        ]
+        self.last_names = [
+            "Smith", "Johnson", "Williams", "Brown", "Jones", "Garcia", "Miller", "Davis",
+            "Rodriguez", "Martinez", "Hernandez", "Lopez", "Gonzalez", "Wilson", "Anderson", "Thomas"
+        ]
+        self.doctors = [
+            "Dr. Sarah Chen", "Dr. Michael Patel", "Dr. Emily Rodriguez", "Dr. James Wilson",
+            "Dr. Lisa Thompson", "Dr. Robert Kim", "Dr. Maria Garcia", "Dr. David Lee"
+        ]
+        self.conditions = [
+            "Hypertension", "Type 2 Diabetes", "Asthma", "Arthritis", "Migraine",
+            "Anxiety", "Depression", "GERD", "Hypothyroidism", "Osteoporosis"
+        ]
+        self.medications = [
+            "Lisinopril", "Metformin", "Albuterol", "Ibuprofen", "Sumatriptan",
+            "Sertraline", "Omeprazole", "Levothyroxine", "Alendronate", "Atorvastatin"
+        ]
+        self.lab_tests = [
+            "Complete Blood Count", "Basic Metabolic Panel", "Lipid Panel", "Hemoglobin A1C",
+            "Thyroid Function Test", "Vitamin D Level", "Liver Function Test", "Urinalysis"
+        ]
+
+    def generate_patient_info(self) -> Dict[str, Any]:
+        first_name = random.choice(self.first_names)
+        last_name = random.choice(self.last_names)
+        age = random.randint(18, 85)
+        gender = random.choice(["Male", "Female"])
+        return {
+            "patient_name": f"{first_name} {last_name}",
+            "age": age,
+            "gender": gender,
+            "doctor_name": random.choice(self.doctors),
+            "date": datetime.now().strftime("%Y-%m-%d")
+        }
+
+    def generate_clinical_note(self, metadata: Dict[str, Any]) -> str:
+        condition = random.choice(self.conditions)
+        medications = random.sample(self.medications, random.randint(1, 3))
+        return f"""CLINICAL NOTE
+
+Patient: {metadata['patient_name']}
+Date: {metadata['date']}
+Provider: {metadata['doctor_name']}
+
+Chief Complaint:
+Patient presents with symptoms related to {condition.lower()}.
+
+History of Present Illness:
+Patient reports ongoing symptoms for the past {random.randint(1, 12)} months.
+Symptoms include {', '.join(random.sample(['fatigue', 'pain', 'discomfort', 'anxiety', 'depression'], 2))}.
+
+Assessment:
+Primary diagnosis: {condition}
+
+Plan:
+1. Continue current medications: {', '.join(medications)}
+2. Follow up in {random.randint(1, 3)} months
+3. Recommended lifestyle modifications
+4. Schedule routine lab work
+
+Signed: {metadata['doctor_name']}"""
+
+    def generate_discharge_summary(self, metadata: Dict[str, Any]) -> str:
+        condition = random.choice(self.conditions)
+        medications = random.sample(self.medications, random.randint(1, 3))
+        admission_date = (datetime.now().replace(day=1) - timedelta(days=random.randint(1, 30))).strftime("%Y-%m-%d")
+        discharge_date = datetime.now().strftime("%Y-%m-%d")
+        return f"""DISCHARGE SUMMARY
+
+Patient: {metadata['patient_name']}
+Admission Date: {admission_date}
+Discharge Date: {discharge_date}
+Attending Physician: {metadata['doctor_name']}
+
+Admission Diagnosis:
+{condition}
+
+Hospital Course:
+Patient was admitted for management of {condition.lower()}.
+Treatment included {', '.join(medications)}.
+Patient showed significant improvement during hospitalization.
+
+Discharge Medications:
+{', '.join(medications)}
+
+Discharge Instructions:
+1. Follow up with primary care physician in 1 week
+2. Continue medications as prescribed
+3. Maintain healthy lifestyle
+4. Call if symptoms worsen
+
+Signed: {metadata['doctor_name']}"""
+
+    def generate_lab_report(self, metadata: Dict[str, Any]) -> str:
+        test = random.choice(self.lab_tests)
+        result = random.uniform(1.0, 10.0)
+        reference_range = "1.0 - 10.0"
+        status = "Normal" if 1.0 <= result <= 10.0 else "Abnormal"
+        return f"""LABORATORY REPORT
+
+Patient: {metadata['patient_name']}
+Date: {metadata['date']}
+Ordering Physician: {metadata['doctor_name']}
+
+Test: {test}
+Result: {result:.1f}
+Reference Range: {reference_range}
+Status: {status}
+
+Comments:
+Results have been reviewed and interpreted by the laboratory director.
+Please contact the laboratory if you have any questions.
+
+Signed: Laboratory Director"""
+
+    def generate_prescription(self, metadata: Dict[str, Any]) -> str:
+        medication = random.choice(self.medications)
+        dosage = f"{random.randint(1, 10)}mg"
+        frequency = random.choice(["once daily", "twice daily", "three times daily", "as needed"])
+        quantity = random.randint(30, 90)
+        refills = random.randint(0, 3)
+        return f"""PRESCRIPTION
+
+Patient: {metadata['patient_name']}
+Date: {metadata['date']}
+Prescribing Physician: {metadata['doctor_name']}
+
+Medication: {medication}
+Dosage: {dosage}
+Frequency: {frequency}
+Quantity: {quantity}
+Refills: {refills}
+
+Instructions:
+Take {dosage} {frequency} with food.
+Store at room temperature.
+Call if side effects occur.
+
+Signed: {metadata['doctor_name']}"""
+
+    def generate_patient_intake(self, metadata: Dict[str, Any]) -> str:
+        conditions = random.sample(self.conditions, random.randint(1, 3))
+        medications = random.sample(self.medications, random.randint(1, 3))
+        allergies = random.sample(["Penicillin", "Sulfa", "Latex", "Peanuts"], random.randint(0, 2))
+        return f"""PATIENT INTAKE FORM
+
+Patient Information:
+Name: {metadata['patient_name']}
+Age: {metadata['age']}
+Gender: {metadata['gender']}
+Date: {metadata['date']}
+
+Medical History:
+Current Conditions: {', '.join(conditions)}
+Current Medications: {', '.join(medications)}
+Allergies: {', '.join(allergies) if allergies else 'None reported'}
+
+Family History:
+- Mother: {random.choice(self.conditions)}
+- Father: {random.choice(self.conditions)}
+
+Social History:
+- Smoking: {random.choice(['Never', 'Former', 'Current'])}
+- Alcohol: {random.choice(['None', 'Occasional', 'Regular'])}
+- Exercise: {random.choice(['None', 'Occasional', 'Regular'])}
+
+Review of Systems:
+- General: No significant findings
+- Cardiovascular: No significant findings
+- Respiratory: No significant findings
+- Gastrointestinal: No significant findings
+- Neurological: No significant findings
+
+Signed: {metadata['patient_name']}"""
+
+    def generate_records(self, count: int, types: List[str]) -> List[Dict[str, Any]]:
+        if not types:
+            raise ValueError("At least one record type must be specified")
+        records = []
+        type_generators = {
+            "clinical_note": self.generate_clinical_note,
+            "discharge_summary": self.generate_discharge_summary,
+            "lab_report": self.generate_lab_report,
+            "prescription": self.generate_prescription,
+            "patient_intake": self.generate_patient_intake
+        }
+        invalid_types = [t for t in types if t not in type_generators]
+        if invalid_types:
+            raise ValueError(f"Invalid record types: {', '.join(invalid_types)}")
+        for _ in range(count):
+            record_type = random.choice(types)
+            metadata = self.generate_patient_info()
+            content = type_generators[record_type](metadata)
+            records.append({
+                "id": f"REC-{random.randint(10000, 99999)}",
+                "type": record_type,
+                "content": content,
+                "generated_at": datetime.now().isoformat(),
+                "metadata": metadata
+            })
+        return records
+
+    def export_records(self, records: List[Dict[str, Any]], format: str) -> str:
+        if format == "JSON":
+            return json.dumps(records, indent=2)
+        elif format == "CSV":
+            output = io.StringIO()
+            writer = csv.writer(output)
+            writer.writerow(["ID", "Type", "Content", "Generated At", "Patient Name", "Age", "Gender", "Doctor Name", "Date"])
+            for record in records:
+                writer.writerow([
+                    record["id"],
+                    record["type"],
+                    record["content"],
+                    record["generated_at"],
+                    record["metadata"]["patient_name"],
+                    record["metadata"]["age"],
+                    record["metadata"]["gender"],
+                    record["metadata"]["doctor_name"],
+                    record["metadata"]["date"]
+                ])
+            return output.getvalue()
+        elif format == "TXT":
+            output = []
+            for record in records:
+                output.append(f"Record ID: {record['id']}")
+                output.append(f"Type: {record['type']}")
+                output.append(f"Generated At: {record['generated_at']}")
+                output.append(f"Patient: {record['metadata']['patient_name']}")
+                output.append(f"Age: {record['metadata']['age']}")
+                output.append(f"Gender: {record['metadata']['gender']}")
+                output.append(f"Doctor: {record['metadata']['doctor_name']}")
+                output.append(f"Date: {record['metadata']['date']}")
+                output.append("\nContent:")
+                output.append(record['content'])
+                output.append("\n" + "="*80 + "\n")
+            return "\n".join(output)
+        else:
+            raise ValueError(f"Unsupported export format: {format}") 

app/services/medical_generator.py

@@ -0,0 +1,137 @@
+import os
+import time
+from typing import List, Dict, Any
+from transformers import pipeline, AutoModelForCausalLM, AutoTokenizer
+from datetime import datetime
+
+class MedicalTextGenerator:
+    def __init__(self):
+        # Initialize with a medical-specific model
+        self.model_name = "emilyalsentzer/Bio_ClinicalBERT"
+        self.tokenizer = AutoTokenizer.from_pretrained(self.model_name)
+        self.model = AutoModelForCausalLM.from_pretrained(self.model_name)
+        
+        # Create text generation pipeline
+        self.generator = pipeline(
+            "text-generation",
+            model=self.model,
+            tokenizer=self.tokenizer,
+            max_length=512,
+            num_return_sequences=1
+        )
+        
+    def _generate_text(self, prompt: str) -> str:
+        """Generate text using the model."""
+        try:
+            # Generate text
+            outputs = self.generator(
+                prompt,
+                max_length=512,
+                num_return_sequences=1,
+                temperature=0.7,
+                top_p=0.9,
+                do_sample=True
+            )
+            
+            # Extract generated text
+            generated_text = outputs[0]['generated_text']
+            
+            # Clean up the text
+            generated_text = generated_text.replace(prompt, "").strip()
+            return generated_text
+        except Exception as e:
+            print(f"Error generating text: {e}")
+            return ""
+
+    def generate_clinical_note(self, template_type: str = "general") -> str:
+        """Generate a clinical note based on the template type."""
+        prompt = f"""
+        Generate a realistic but completely fictional clinical note for {template_type}.
+        Include:
+        - Chief complaint
+        - History of present illness
+        - Physical exam
+        - Assessment
+        - Plan
+        
+        Make it medically accurate but use fictional patient details.
+        Follow HIPAA guidelines and ensure no real PII is included.
+        """
+        return self._generate_text(prompt)
+
+    def generate_discharge_summary(self) -> str:
+        """Generate a discharge summary."""
+        prompt = """
+        Generate a realistic but completely fictional hospital discharge summary.
+        Include:
+        - Admission date
+        - Discharge date
+        - Reason for admission
+        - Hospital course
+        - Discharge medications
+        - Discharge instructions
+        - Follow-up plan
+        
+        Make it medically accurate but use fictional patient details.
+        Follow HIPAA guidelines and ensure no real PII is included.
+        """
+        return self._generate_text(prompt)
+
+    def generate_lab_report(self) -> str:
+        """Generate a laboratory report."""
+        prompt = """
+        Generate a realistic but completely fictional laboratory report.
+        Include:
+        - Test name
+        - Results
+        - Reference ranges
+        - Interpretation
+        - Comments
+        
+        Make it medically accurate but use fictional patient details.
+        Follow HIPAA guidelines and ensure no real PII is included.
+        """
+        return self._generate_text(prompt)
+
+    def generate_prescription(self) -> str:
+        """Generate a prescription."""
+        prompt = """
+        Generate a realistic but completely fictional prescription.
+        Include:
+        - Medication name
+        - Dosage
+        - Frequency
+        - Duration
+        - Special instructions
+        
+        Make it medically accurate but use fictional patient details.
+        Follow HIPAA guidelines and ensure no real PII is included.
+        """
+        return self._generate_text(prompt)
+
+    def batch_generate(self, count: int, record_type: str) -> List[Dict[str, Any]]:
+        """Generate multiple records of the specified type."""
+        records = []
+        type_generators = {
+            "clinical_note": self.generate_clinical_note,
+            "discharge_summary": self.generate_discharge_summary,
+            "lab_report": self.generate_lab_report,
+            "prescription": self.generate_prescription
+        }
+        
+        if record_type not in type_generators:
+            raise ValueError(f"Unsupported record type: {record_type}")
+        
+        generator = type_generators[record_type]
+        
+        for i in range(count):
+            content = generator()
+            records.append({
+                "id": f"REC-{datetime.now().strftime('%Y%m%d%H%M%S')}-{i+1}",
+                "type": record_type,
+                "content": content,
+                "generated_at": datetime.now().isoformat()
+            })
+            time.sleep(1)  # Small delay to prevent overload
+            
+        return records 

create_tables.py

@@ -0,0 +1,22 @@
+from app.core.database import Base, engine
+from app.models.models import BetaApplication
+from pydantic import BaseModel, Field
+from datetime import datetime
+
+# Create the tables
+Base.metadata.create_all(engine)
+
+print("Tables created successfully.")
+
+class BetaApplicationSchema(BaseModel):
+    id: str
+    email: str
+    company: str
+    useCase: str = Field(..., alias="use_case")
+    status: str
+    createdAt: datetime = Field(..., alias="created_at")
+    updatedAt: datetime | None = Field(None, alias="updated_at")
+
+    class Config:
+        orm_mode = True
+        allow_population_by_field_name = True 

init_db.py

@@ -0,0 +1,10 @@
+from app.core.database import Base, engine
+from app.models.models import BetaApplication
+
+def init_db():
+    Base.metadata.create_all(bind=engine)
+
+if __name__ == "__main__":
+    print("Creating database tables...")
+    init_db()
+    print("Database tables created successfully!") 

main.py

@@ -0,0 +1,39 @@
+from fastapi import FastAPI
+from fastapi.middleware.cors import CORSMiddleware
+from dotenv import load_dotenv
+import os
+
+# Load environment variables
+load_dotenv()
+
+# Create FastAPI app
+app = FastAPI(
+    title="Synthex API",
+    description="Backend API for Synthex Medical Text Generator",
+    version="1.0.0"
+)
+
+# Configure CORS
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["http://localhost:3000"],  # Frontend URL
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+# Health check endpoint
+@app.get("/")
+async def root():
+    return {"status": "healthy", "message": "Synthex API is running"}
+
+# Import and include routers
+from app.api import beta, admin, generator
+
+app.include_router(beta.router, prefix="/api/beta", tags=["beta"])
+app.include_router(admin.router, prefix="/api/admin", tags=["admin"])
+app.include_router(generator.router, prefix="/api/generator", tags=["generator"])
+
+if __name__ == "__main__":
+    import uvicorn
+    uvicorn.run(app, host="0.0.0.0", port=8000) 

pyproject.toml

@@ -0,0 +1,17 @@
+[tool.black]
+line-length = 88
+target-version = ['py38']
+include = '\.pyi?$'
+exclude = '''
+/(
+    \.git
+  | \.hg
+  | \.mypy_cache
+  | \.tox
+  | \.venv
+  | _build
+  | buck-out
+  | build
+  | dist
+)/
+''' 

recreate_tables.py

@@ -0,0 +1,14 @@
+from sqlalchemy import text
+from app.core.database import Base, engine
+from app.models.models import BetaApplication
+
+# Drop all tables with CASCADE
+with engine.connect() as conn:
+    conn.execute(text("DROP SCHEMA public CASCADE;"))
+    conn.execute(text("CREATE SCHEMA public;"))
+    conn.commit()
+
+# Create all tables
+Base.metadata.create_all(engine)
+
+print("Tables recreated successfully.") 

requirements-dev.txt

@@ -0,0 +1,6 @@
+-r requirements.txt
+pytest==7.4.3
+pytest-cov==4.1.0
+black==23.11.0
+flake8==6.1.0
+mypy==1.7.1 

requirements.txt

@@ -0,0 +1,9 @@
+streamlit>=1.24.0
+transformers>=4.30.0
+torch>=2.0.0
+pydantic>=1.8.0
+python-dotenv>=0.19.0
+fastapi>=0.68.0
+uvicorn[standard]>=0.15.0
+sqlalchemy>=1.4.0
+python-multipart>=0.0.5 

run_linters.py

@@ -0,0 +1,52 @@
+import subprocess
+import sys
+import os
+import platform
+
+def run_black():
+    print("\nRunning Black...")
+    try:
+        subprocess.run(
+            ["black", "app/", "tests/"],
+            check=True
+        )
+        print("Black completed successfully!")
+    except subprocess.CalledProcessError:
+        print("Black found issues!")
+        sys.exit(1)
+
+def run_flake8():
+    print("\nRunning Flake8...")
+    try:
+        subprocess.run(
+            ["flake8", "app/", "tests/"],
+            check=True
+        )
+        print("Flake8 completed successfully!")
+    except subprocess.CalledProcessError:
+        print("Flake8 found issues!")
+        sys.exit(1)
+
+def run_mypy():
+    print("\nRunning MyPy...")
+    try:
+        subprocess.run(
+            ["mypy", "app/", "tests/"],
+            check=True
+        )
+        print("MyPy completed successfully!")
+    except subprocess.CalledProcessError:
+        print("MyPy found issues!")
+        sys.exit(1)
+
+def main():
+    print("Running linters...")
+    
+    run_black()
+    run_flake8()
+    run_mypy()
+    
+    print("\nAll linters passed successfully!")
+
+if __name__ == "__main__":
+    main() 

run_tests.py

@@ -0,0 +1,25 @@
+import subprocess
+import sys
+import os
+import platform
+
+def run_tests():
+    print("Running tests...")
+    
+    if platform.system() == "Windows":
+        python = "venv/Scripts/python"
+    else:
+        python = "venv/bin/python"
+    
+    try:
+        subprocess.run(
+            [python, "-m", "pytest", "tests/", "-v"],
+            check=True
+        )
+        print("\nAll tests passed successfully!")
+    except subprocess.CalledProcessError:
+        print("\nSome tests failed!")
+        sys.exit(1)
+
+if __name__ == "__main__":
+    run_tests() 

setup.cfg

@@ -0,0 +1,31 @@
+[flake8]
+max-line-length = 88
+extend-ignore = E203
+exclude = .git,__pycache__,build,dist
+
+[mypy]
+python_version = 3.8
+warn_return_any = True
+warn_unused_configs = True
+disallow_untyped_defs = True
+disallow_incomplete_defs = True
+check_untyped_defs = True
+disallow_untyped_decorators = True
+no_implicit_optional = True
+warn_redundant_casts = True
+warn_unused_ignores = True
+warn_no_return = True
+warn_unreachable = True
+
+[coverage:run]
+source = app
+omit = tests/*
+
+[coverage:report]
+exclude_lines =
+    pragma: no cover
+    def __repr__
+    raise NotImplementedError
+    if __name__ == .__main__.:
+    pass
+    raise ImportError 

tests/test_api.py

@@ -0,0 +1,140 @@
+from fastapi.testclient import TestClient
+from app.main import app
+from app.core.database import Base, engine
+from app.models.models import BetaApplication
+import pytest
+
+client = TestClient(app)
+
+@pytest.fixture(autouse=True)
+def setup_database():
+    Base.metadata.create_all(bind=engine)
+    yield
+    Base.metadata.drop_all(bind=engine)
+
+def test_create_application():
+    response = client.post(
+        "/api/beta/apply",
+        json={
+            "email": "[email protected]",
+            "company": "Test Company",
+            "useCase": "Testing"
+        }
+    )
+    assert response.status_code == 200
+    data = response.json()
+    assert data["email"] == "[email protected]"
+    assert data["company"] == "Test Company"
+    assert data["useCase"] == "Testing"
+    assert data["status"] == "pending"
+
+def test_create_duplicate_application():
+    # Create first application
+    client.post(
+        "/api/beta/apply",
+        json={
+            "email": "[email protected]",
+            "company": "Test Company",
+            "useCase": "Testing"
+        }
+    )
+    
+    # Try to create duplicate
+    response = client.post(
+        "/api/beta/apply",
+        json={
+            "email": "[email protected]",
+            "company": "Another Company",
+            "useCase": "Another Use Case"
+        }
+    )
+    assert response.status_code == 400
+    assert response.json()["detail"] == "Email already registered"
+
+def test_verify_application():
+    # Create application
+    response = client.post(
+        "/api/beta/apply",
+        json={
+            "email": "[email protected]",
+            "company": "Test Company",
+            "useCase": "Testing"
+        }
+    )
+    application_id = response.json()["id"]
+    
+    # Try to verify unapproved application
+    response = client.post(
+        "/api/beta/verify",
+        json={"application_id": application_id}
+    )
+    assert response.status_code == 403
+    assert response.json()["detail"] == "Application not approved"
+
+def test_admin_login():
+    response = client.post(
+        "/api/admin/login",
+        data={
+            "username": "[email protected]",
+            "password": "admin123"
+        }
+    )
+    assert response.status_code == 200
+    data = response.json()
+    assert "access_token" in data
+    assert data["token_type"] == "bearer"
+
+def test_admin_login_invalid_credentials():
+    response = client.post(
+        "/api/admin/login",
+        data={
+            "username": "[email protected]",
+            "password": "wrong_password"
+        }
+    )
+    assert response.status_code == 401
+    assert response.json()["detail"] == "Incorrect email or password"
+
+def test_get_applications_unauthorized():
+    response = client.get("/api/admin/applications")
+    assert response.status_code == 401
+    assert response.json()["detail"] == "Not authenticated"
+
+def test_update_application():
+    # Create application
+    response = client.post(
+        "/api/beta/apply",
+        json={
+            "email": "[email protected]",
+            "company": "Test Company",
+            "useCase": "Testing"
+        }
+    )
+    application_id = response.json()["id"]
+    
+    # Login as admin
+    login_response = client.post(
+        "/api/admin/login",
+        data={
+            "username": "[email protected]",
+            "password": "admin123"
+        }
+    )
+    token = login_response.json()["access_token"]
+    
+    # Update application
+    response = client.patch(
+        f"/api/admin/applications/{application_id}",
+        json={"status": "approved"},
+        headers={"Authorization": f"Bearer {token}"}
+    )
+    assert response.status_code == 200
+    assert response.json()["message"] == "Application updated successfully"
+    
+    # Verify application
+    response = client.post(
+        "/api/beta/verify",
+        json={"application_id": application_id}
+    )
+    assert response.status_code == 200
+    assert response.json()["message"] == "Access granted" 

tests/test_integration.py

@@ -0,0 +1,29 @@
+import pytest
+from fastapi.testclient import TestClient
+from app.main import app
+
+client = TestClient(app)
+
+def test_beta_verification():
+    response = client.post("/api/beta/verify", json={"application_id": "test123"})
+    assert response.status_code == 200
+    assert response.json()["message"] == "Access granted"
+
+def test_jwt_authentication():
+    response = client.post("/api/auth/token", data={"username": "[email protected]", "password": "admin123"})
+    assert response.status_code == 200
+    assert "access_token" in response.json()
+
+def test_record_generation():
+    # First, get a token
+    token_response = client.post("/api/auth/token", data={"username": "[email protected]", "password": "admin123"})
+    token = token_response.json()["access_token"]
+
+    # Then, generate records
+    response = client.post(
+        "/api/generator/generate",
+        json={"recordType": "Clinical Note", "quantity": 5},
+        headers={"Authorization": f"Bearer {token}"}
+    )
+    assert response.status_code == 200
+    assert len(response.json()) == 5