Update app.py

app.py

@@ -1,6 +1,7 @@
-from fastapi import FastAPI, HTTPException, Depends
+from fastapi import FastAPI, HTTPException
 from fastapi.middleware.cors import CORSMiddleware
 from pydantic import BaseModel
+from transformers import AutoModelForSeq2SeqLM, AutoTokenizer, pipeline
 import difflib
 import spacy
 import re
@@ -9,7 +10,7 @@ import nltk
 from collections import Counter
 import uvicorn
 import os
-import requests
+import torch
 
 # Download NLTK resources
 try:
@@ -30,34 +31,14 @@ app.add_middleware(
     allow_headers=["*"],  # Allows all headers
 )
 
-# Function to get API token
-def get_hf_api_token():
-    token = os.getenv("HF_API_TOKEN")
-    if not token:
-        raise HTTPException(status_code=500, detail="Hugging Face API token not configured")
-    return token
-
-# Function to call Hugging Face Inference API
-def get_humanized_text(text, token):
-    API_URL = "https://api-inference.huggingface.co/models/danibor/flan-t5-base-humanizer"
-    headers = {"Authorization": f"Bearer {token}"}
-    
-    try:
-        response = requests.post(API_URL, headers=headers, json={"inputs": text})
-        
-        # Print more detailed error info
-        if response.status_code != 200:
-            print(f"Hugging Face API error: {response.status_code}")
-            print(f"Response content: {response.text}")
-            
-        response.raise_for_status()
-        return response.json()[0]["generated_text"]
-    except Exception as e:
-        print(f"Error calling Hugging Face API: {e}")
-        return f"Error processing text with Hugging Face API: {str(e)}"
+# Global variable for the pipeline
+humanize_pipe = None
 
 # Load NLP models
 try:
+    # Initialize with a flag to ensure loading only happens once
+    model_loaded = False
+    
     # Load spaCy model
     nlp = spacy.load("en_core_web_sm")
     
@@ -66,11 +47,57 @@ try:
     
     print("NLP models loaded successfully!")
 except Exception as e:
-    print(f"Error loading models: {e}")
+    print(f"Error loading NLP models: {e}")
     # Create fallback functions if models fail to load
     def mock_function(text):
         return "Model could not be loaded. This is a fallback response."
 
+def get_humanize_pipeline():
+    """
+    Lazy-load the humanization pipeline on first use.
+    Ensures it runs on CPU with limited memory settings.
+    """
+    global humanize_pipe
+    if humanize_pipe is None:
+        try:
+            print("Loading the humanizer model on CPU...")
+            
+            # Force CPU usage
+            device = torch.device("cpu")
+            
+            # Set low memory footprint
+            model_kwargs = {
+                "low_cpu_mem_usage": True,
+                "device_map": "cpu"
+            }
+            
+            # Load model with specific settings for resource-constrained environments
+            model = AutoModelForSeq2SeqLM.from_pretrained(
+                "danibor/flan-t5-base-humanizer", 
+                **model_kwargs,
+                torch_dtype=torch.float32  # Use float32 instead of float16 for CPU
+            )
+            tokenizer = AutoTokenizer.from_pretrained("danibor/flan-t5-base-humanizer")
+            
+            # Create pipeline with optimized settings
+            humanize_pipe = pipeline(
+                "text2text-generation", 
+                model=model, 
+                tokenizer=tokenizer,
+                device=device,  # Explicitly specify CPU
+                framework="pt"
+            )
+            
+            print("Humanizer model loaded successfully!")
+        except Exception as e:
+            print(f"Error loading humanizer model: {e}")
+            # Return a simple function that just returns the input as fallback
+            def fallback_humanize(text, **kwargs):
+                return [{"generated_text": f"FALLBACK: {text} (Model loading failed: {str(e)})"}]
+            humanize_pipe = fallback_humanize
+    
+    return humanize_pipe
+
 # Define request models
 class TextRequest(BaseModel):
     text: str
@@ -93,12 +120,23 @@ class AnalyzeResponse(BaseModel):
     complexity: dict
 
 @app.post("/humanize", response_model=HumanizeResponse)
-async def humanize_text(request: TextRequest, hf_token: str = Depends(get_hf_api_token)):
+async def humanize_text(request: TextRequest):
     input_text = request.text
     
     try:
-        # Generate humanized text using Hugging Face API
-        humanized_text = get_humanized_text(input_text, hf_token)
+        # Get or initialize the pipeline
+        pipeline = get_humanize_pipeline()
+        
+        # Generate humanized text with memory-conscious settings
+        result = pipeline(
+            input_text, 
+            max_length=min(500, len(input_text) * 2),  # Limit max length
+            do_sample=True,
+            num_return_sequences=1,
+            batch_size=1  # Small batch size for memory constraints
+        )
+        
+        humanized_text = result[0]['generated_text']
         
         # Get the differences
         diff = get_diff(input_text, humanized_text)
@@ -115,6 +153,7 @@ async def humanize_text(request: TextRequest, hf_token: str = Depends(get_hf_api
             'nlp_analysis': nlp_analysis
         }
     except Exception as e:
+        print(f"Error in humanize endpoint: {str(e)}")
         raise HTTPException(status_code=500, detail=f"Error processing text: {str(e)}")
 
 def get_diff(text1, text2):