first commit

.gitignore

@@ -0,0 +1,66 @@
+# 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
+MANIFEST
+
+# Virtual environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# IDE
+.vscode/
+.idea/
+*.swp
+*.swo
+*~
+
+# OS
+.DS_Store
+.DS_Store?
+._*
+.Spotlight-V100
+.Trashes
+ehthumbs.db
+Thumbs.db
+
+# Logs
+*.log
+logs/
+
+# Local development
+.env.local
+.env.development
+.env.test
+.env.production
+
+# Test coverage
+htmlcov/
+.coverage
+.coverage.*
+coverage.xml
+*.cover
+.hypothesis/
+.pytest_cache/

DEPLOY.md

@@ -0,0 +1,47 @@
+# 🚀 Quick Deployment to Hugging Face Spaces
+
+## Files for Deployment
+
+Upload these 4 files to your Hugging Face Space:
+
+```
+📁 Your Hugging Face Space Repository
+├── 📄 app.py              # Main FastAPI application  
+├── 📄 Dockerfile          # Container configuration
+├── 📄 README.md           # Space description (rename README_HF.md)
+├── 📄 requirements.txt    # Python dependencies
+└── 📄 test.py            # Test script (optional)
+```
+
+## Deployment Steps
+
+### 1. Create Hugging Face Space
+- Go to [huggingface.co/spaces](https://huggingface.co/spaces)
+- Click "Create new Space"
+- Choose **SDK: Docker**
+- Set your space name
+
+### 2. Upload Files
+- Upload: `app.py`, `Dockerfile`, `requirements.txt`
+- **Rename** `README_HF.md` to `README.md` and upload
+- Optionally upload `test.py`
+
+### 3. Deploy
+- Hugging Face automatically builds and deploys
+- Your API will be available at: `https://your-space-name.hf.space`
+
+## Testing
+
+1. Update `test.py` with your Space URL
+2. Set environment variable: `export OPENAI_API_KEY="your_key"`
+3. Run: `python test.py`
+
+## Your API Endpoints
+
+- **Base**: `https://your-space-name.hf.space`
+- **Health**: `GET /health` 
+- **Address Detection**: `POST /address-detection`
+- **Summarization**: `POST /summarize`
+- **Docs**: `GET /docs`
+
+That's it! 🎉

Dockerfile

@@ -0,0 +1,24 @@
+FROM python:3.12-slim
+
+WORKDIR /app
+
+# Install system dependencies
+RUN apt-get update && apt-get install -y \
+    build-essential \
+    curl \
+    && rm -rf /var/lib/apt/lists/*
+
+# Copy requirements first for better caching
+COPY requirements.txt .
+
+# Install Python dependencies
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Copy application code
+COPY . .
+
+# Expose port
+EXPOSE 7860
+
+# Command to run the application
+CMD ["uvicorn", "app:app", "--host", "0.0.0.0", "--port", "7860"]

README.md

@@ -1,11 +1,202 @@
----
-title: Content Processor
-emoji: 😻
-colorFrom: green
-colorTo: green
-sdk: docker
-pinned: false
-short_description: fast api service that do address detection &  summarization
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# Address Detection and Summarization API
+
+A FastAPI application that provides two main endpoints for address detection and text summarization with sentiment analysis using OpenAI's GPT models.
+
+## Features
+
+- **Address Detection**: Extracts addresses from text content
+- **Text Summarization**: Generates summaries with sentiment analysis
+- **OpenAI Integration**: Uses GPT-3.5-turbo for natural language processing
+- **Header-based Authentication**: OpenAI API key passed via `x-api-key` header
+- **RESTful API**: Clean and simple API endpoints
+
+## Installation
+
+1. **Clone or navigate to the project directory**
+   ```bash
+   cd /mnt/BA1E86C91E867DDF/ubuntu_folder/python/fastapi/dummy_add-det_summ_ser
+   ```
+
+2. **Create and activate virtual environment** (if not already done)
+   ```bash
+   python -m venv .venv
+   source .venv/bin/activate  # On Linux/Mac
+   ```
+
+3. **Install dependencies**
+   ```bash
+   pip install -r requirements.txt
+   ```
+
+## Configuration
+
+**Important**: This API requires the OpenAI API key to be passed in the `x-api-key` request header, not as environment variables.
+
+## Running the Application
+
+Start the FastAPI server:
+
+```bash
+python main.py
+```
+
+Or using uvicorn directly:
+
+```bash
+uvicorn main:app --host 0.0.0.0 --port 8500 --reload
+```
+
+The API will be available at: http://localhost:8500
+
+## API Documentation
+
+Once running, visit:
+- Interactive API docs: http://localhost:8500/docs
+- ReDoc documentation: http://localhost:8500/redoc
+
+## API Endpoints
+
+### 1. Address Detection
+
+**POST** `/address-detection`
+
+Detects and extracts addresses from the provided text content.
+
+**Headers:**
+```
+Content-Type: application/json
+x-api-key: your_openai_api_key_here
+```
+
+**Request Body:**
+```json
+{
+  "entity_urn": "string",
+  "content": "string"
+}
+```
+
+**Response:**
+```json
+{
+  "message": "success|failure",
+  "result": "address1 || address2 || address3",
+  "action_type": "detect_address",
+  "entity_urn": "string",
+  "sentiment": null
+}
+```
+
+**Example:**
+```bash
+curl -X POST "http://localhost:8500/address-detection" \
+     -H "Content-Type: application/json" \
+     -H "x-api-key: your_openai_api_key_here" \
+     -d '{
+       "entity_urn": "test_001",
+       "content": "Please send the package to 123 Main Street, New York, NY 10001"
+     }'
+```
+
+### 2. Text Summarization
+
+**POST** `/summarize`
+
+Generates a summary of the text content along with sentiment analysis.
+
+**Headers:**
+```
+Content-Type: application/json
+x-api-key: your_openai_api_key_here
+```
+
+**Request Body:**
+```json
+{
+  "entity_urn": "string",
+  "content": "string"
+}
+```
+
+**Response:**
+```json
+{
+  "message": "success|failure",
+  "result": "summary text",
+  "action_type": "summarize",
+  "entity_urn": "string",
+  "sentiment": {
+    "label": "positive|negative",
+    "score": -1.0 to 1.0
+  }
+}
+```
+
+**Example:**
+```bash
+curl -X POST "http://localhost:8500/summarize" \
+     -H "Content-Type: application/json" \
+     -H "x-api-key: your_openai_api_key_here" \
+     -d '{
+       "entity_urn": "test_002",
+       "content": "I love this product! It exceeded my expectations..."
+     }'
+```
+
+## Testing
+
+Before running tests, make sure to set your OpenAI API key as an environment variable:
+
+```bash
+export OPENAI_API_KEY="your_openai_api_key_here"
+```
+
+Then run the test script to verify the endpoints:
+
+```bash
+python test_api.py
+```
+
+Make sure the server is running before executing the tests.
+
+The test script will also test error handling by making requests without the API key header.
+
+## Project Structure
+
+```
+dummy_add-det_summ_ser/
+├── main.py              # Main FastAPI application
+├── test_api.py          # Test script for API endpoints
+├── requirements.txt     # Python dependencies
+├── .env.example         # Environment variables template
+├── .venv/              # Virtual environment
+└── README.md           # This file
+```
+
+## Dependencies
+
+- **FastAPI**: Web framework for building APIs (v0.115.14)
+- **Uvicorn**: ASGI server for running FastAPI (v0.34.3)
+- **Pydantic**: Data validation using Python type annotations (v2.11.7)
+- **OpenAI**: Official OpenAI Python client (v1.92.1)
+- **python-dotenv**: Load environment variables from .env file (v1.1.1)
+- **httpx**: Modern HTTP client library for testing (v0.28.1)
+
+## Error Handling
+
+The API includes comprehensive error handling:
+- **Missing API Key**: Returns 422 error if `x-api-key` header is not provided
+- **Invalid API Key**: Returns 500 error if the OpenAI API key is invalid
+- **OpenAI API connection failures**: Returns 500 error with descriptive message
+- **Empty content validation**: Returns failure response with appropriate message
+- **Malformed requests**: Returns 422 error for validation issues
+
+All errors return appropriate HTTP status codes and descriptive error messages.
+
+## Notes
+
+- **API Key Security**: The OpenAI API key must be passed in the `x-api-key` header for each request
+- The API uses GPT-3.5-turbo model by default
+- Sentiment scores range from -1.0 (most negative) to 1.0 (most positive)
+- Address detection returns addresses concatenated with ' || ' separator
+- The `entity_urn` field is used instead of `entity_id` for better naming convention

README_HF.md

@@ -0,0 +1,124 @@
+---
+title: Address Detection and Summarization API
+emoji: 🏠📝
+colorFrom: blue
+colorTo: green
+sdk: docker
+pinned: false
+license: mit
+---
+
+# Address Detection and Summarization API
+
+A FastAPI service that provides two main endpoints for AI-powered text processing:
+
+## 🚀 Features
+
+- 🏠 **Address Detection**: Extracts and formats addresses from unstructured text
+- 📝 **Text Summarization**: Creates concise summaries with sentiment analysis
+- 🤖 **OpenAI Integration**: Uses GPT-4 for natural language processing
+- 🔐 **Secure**: API key required via `x-api-key` header
+- 📊 **Sentiment Analysis**: Returns sentiment label and score (-1.0 to 1.0)
+
+## 📋 API Endpoints
+
+### Root & Health
+- `GET /` - API information
+- `GET /health` - Health check
+- `GET /docs` - Interactive API documentation
+
+### Address Detection
+`POST /address-detection`
+
+Extract addresses from text content.
+
+**Request:**
+```json
+{
+  "entity_urn": "unique_id",
+  "content": "Please send to 123 Main Street, New York, NY 10001"
+}
+```
+
+**Headers:**
+```
+Content-Type: application/json
+x-api-key: your_openai_api_key
+```
+
+### Text Summarization  
+`POST /summarize`
+
+Generate summary with sentiment analysis.
+
+**Request:**
+```json
+{
+  "entity_urn": "unique_id",
+  "content": "Your text content to summarize..."
+}
+```
+
+## 🔧 Usage Examples
+
+### Using curl:
+
+```bash
+# Address Detection
+curl -X POST "https://your-space-name.hf.space/address-detection" \
+     -H "Content-Type: application/json" \
+     -H "x-api-key: your_openai_api_key" \
+     -d '{"entity_urn": "test", "content": "Send to 123 Main St, NYC"}'
+
+# Summarization
+curl -X POST "https://your-space-name.hf.space/summarize" \
+     -H "Content-Type: application/json" \
+     -H "x-api-key: your_openai_api_key" \
+     -d '{"entity_urn": "test", "content": "I love this product!"}'
+```
+
+### Response Format:
+
+```json
+{
+  "message": "success",
+  "result": "extracted_addresses || separated",
+  "action_type": "detect_address",
+  "entity_urn": "test",
+  "sentiment": null
+}
+```
+
+For summarization, `sentiment` contains:
+```json
+{
+  "label": "positive",
+  "score": 0.8
+}
+```
+
+## 🔑 Authentication
+
+You need an OpenAI API key to use this service:
+
+1. Get your API key from [OpenAI Platform](https://platform.openai.com/)
+2. Include it in the `x-api-key` header with each request
+3. No registration required - just use your own key
+
+## 🏗️ Built With
+
+- **FastAPI** 0.115.14 - Modern web framework
+- **OpenAI** 1.92.1 - AI language models  
+- **Pydantic** 2.11.7 - Data validation
+- **Python** 3.12 - Runtime
+
+## 📖 Documentation
+
+Visit `/docs` for interactive API documentation with request/response examples and testing interface.
+
+## 🔒 Security & Privacy
+
+- Your OpenAI API key is required for each request
+- No API keys are stored on our servers
+- All requests are processed in real-time
+- No conversation history is retained

app.py

@@ -0,0 +1,239 @@
+#!/usr/bin/env python3
+"""
+Address Detection and Summarization API for Hugging Face Spaces
+"""
+
+from fastapi import FastAPI, HTTPException, Header
+from fastapi.middleware.cors import CORSMiddleware
+from pydantic import BaseModel, Field
+from openai import OpenAI
+import os
+from enum import Enum
+from typing import Dict, Optional, Annotated
+import logging
+from dotenv import load_dotenv
+
+# Load environment variables
+load_dotenv()
+
+# Configure logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+app = FastAPI(title="Address Detection and Summarization API")
+
+# Add CORS middleware for Hugging Face Spaces
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+class Actions(Enum):
+    DETECT_ADDRESS = "detect_address"
+    SUMMARIZE = "summarize"
+
+# Request model
+class RequestModel(BaseModel):
+    entity_urn: str = Field(..., description="Unique identifier for the entity")
+    content: str = Field(..., description="Content to be processed")
+
+# Response models
+class ResponseModel(BaseModel):
+    message: str = Field(description="Result of the operation, e.g., 'success' or 'failure'")
+    result: str = Field(description="summary in case of summarization, or || separated addresses in case of address detection")
+    action_type: Actions = Field(..., description="Type of action performed")
+    entity_urn: str = Field(..., description="Unique identifier for the entity")
+    sentiment: Optional[Dict] = Field(default=None, description="Sentiment analysis result")
+
+def get_openai_client(api_key: str) -> OpenAI:
+    """Create OpenAI client with provided API key"""
+    if not api_key:
+        raise HTTPException(status_code=400, detail="x-api-key header is required")
+    return OpenAI(api_key=api_key)
+
+def get_openai_response(api_key: str, prompt: str, max_tokens: int = 10000) -> str:
+    """Get response from OpenAI API"""
+    try:
+        client = get_openai_client(api_key)
+        response = client.chat.completions.create(
+            model="gpt-4o",
+            messages=[{"role": "user", "content": prompt}],
+            max_tokens=max_tokens,
+            temperature=0.3
+        )
+        return response.choices[0].message.content.strip()
+    except Exception as e:
+        logger.error(f"OpenAI API error: {str(e)}")
+        raise HTTPException(status_code=500, detail=f"Failed to connect to OpenAI: {str(e)}")
+
+def detect_addresses(api_key: str, content: str) -> str:
+    """Detect addresses from content using OpenAI"""
+    prompt = f"""
+    Extract all addresses from the following text. Return only the addresses, separated by ' || '.
+    If no addresses are found, return empty string.
+
+    Text: {content}
+    
+    Addresses:
+    """
+    
+    try:
+        addresses = get_openai_response(api_key, prompt)
+        return addresses if addresses else ""
+    except Exception as e:
+        logger.error(f"Address detection error: {str(e)}")
+        return "Error detecting addresses"
+
+def summarize_and_analyze_sentiment(api_key: str, content: str) -> tuple:
+    """Summarize content and analyze sentiment using OpenAI"""
+    prompt = f"""
+    Please provide:
+    1. A concise summary of the following text
+    2. Sentiment analysis with label (POSITIVE/NEGATIVE) and score (-1.0 to 1.0)
+    3. Ensure the summary is clear and captures the main points
+    Format your response as:
+    SUMMARY: [your summary here]
+    SENTIMENT_LABEL: [POSITIVE or NEGATIVE]
+    SENTIMENT_SCORE: [score between -1.0 and 1.0]
+    
+    Text: {content}
+    """
+    
+    try:
+        response = get_openai_response(api_key, prompt)
+
+        # Parse the response
+        summary = ""
+        sentiment_label = "neutral"
+        sentiment_score = 0.0
+        
+        lines = response.split('\n')
+        for line in lines:
+            if line.startswith('SUMMARY:'):
+                summary = line.replace('SUMMARY:', '').strip()
+            elif line.startswith('SENTIMENT_LABEL:'):
+                sentiment_label = line.replace('SENTIMENT_LABEL:', '').strip().lower()
+            elif line.startswith('SENTIMENT_SCORE:'):
+                try:
+                    sentiment_score = float(line.replace('SENTIMENT_SCORE:', '').strip())
+                    # Ensure score is within range
+                    sentiment_score = max(-1.0, min(1.0, sentiment_score))
+                except ValueError:
+                    sentiment_score = 0.0
+        
+        # Ensure valid sentiment label
+        if sentiment_label not in ['positive', 'negative']:
+            sentiment_label = 'positive' if sentiment_score > 0 else 'negative'
+        
+        return summary, {"label": sentiment_label, "score": sentiment_score}
+    
+    except Exception as e:
+        logger.error(f"Summarization error: {str(e)}")
+        return "Error generating summary", {"label": "neutral", "score": 0.0}
+
+@app.get("/")
+async def root():
+    return {
+        "message": "Address Detection and Summarization API",
+        "version": "1.0.0",
+        "status": "healthy",
+        "endpoints": {
+            "address_detection": "/address-detection",
+            "summarization": "/summarize",
+            "health": "/health",
+            "docs": "/docs"
+        }
+    }
+
+@app.get("/health")
+async def health_check():
+    return {
+        "status": "healthy",
+        "service": "Address Detection and Summarization API",
+        "version": "1.0.0"
+    }
+
+@app.post("/address-detection", response_model=ResponseModel)
+async def address_detection(
+    request: RequestModel,
+    openai_api_key: Annotated[str, Header(alias="x-api-key")]
+):
+    """Endpoint for address detection"""
+    try:
+        logger.info(f"Processing address detection for entity_urn: {request.entity_urn}")
+        
+        if not request.content.strip():
+            return ResponseModel(
+                message="failure",
+                result="Content is empty",
+                action_type=Actions.DETECT_ADDRESS,
+                entity_urn=request.entity_urn,
+                sentiment=None
+            )
+        
+        addresses = detect_addresses(openai_api_key, request.content)
+        
+        return ResponseModel(   
+            message="success",
+            result=addresses,
+            action_type=Actions.DETECT_ADDRESS,
+            entity_urn=request.entity_urn,
+            sentiment=None
+        )
+    
+    except Exception as e:
+        logger.error(f"Address detection endpoint error: {str(e)}")
+        return ResponseModel(
+            message="failure",
+            result=f"Error: {str(e)}",
+            action_type=Actions.DETECT_ADDRESS,
+            entity_urn=request.entity_urn,
+            sentiment=None
+        )
+
+@app.post("/summarize", response_model=ResponseModel)
+async def summarize(
+    request: RequestModel,
+    openai_api_key: Annotated[str, Header(alias="x-api-key")]
+):
+    """Endpoint for text summarization and sentiment analysis"""
+    try:
+        logger.info(f"Processing summarization for entity_urn: {request.entity_urn}")
+        
+        if not request.content.strip():
+            return ResponseModel(   
+                message="failure",
+                result="Content is empty",
+                action_type=Actions.SUMMARIZE,
+                entity_urn=request.entity_urn,
+                sentiment={}
+            )
+        
+        summary, sentiment = summarize_and_analyze_sentiment(openai_api_key, request.content)
+
+        return ResponseModel(
+            message="success",
+            result=summary,
+            sentiment=sentiment,
+            action_type=Actions.SUMMARIZE,
+            entity_urn=request.entity_urn   
+        )
+    
+    except Exception as e:
+        logger.error(f"Summarization endpoint error: {str(e)}")
+        return ResponseModel(
+            message="failure",
+            result=f"Error: {str(e)}",
+            sentiment={},
+            action_type=Actions.SUMMARIZE,
+            entity_urn=request.entity_urn
+        )
+
+if __name__ == "__main__":
+    import uvicorn
+    # Use port 7860 for Hugging Face Spaces, fallback to 8500 for local
+    port = int(os.getenv("PORT", 7860))
+    uvicorn.run(app, host="0.0.0.0", port=port)

requirements.txt

@@ -0,0 +1,6 @@
+fastapi==0.115.14
+uvicorn[standard]==0.34.3
+pydantic==2.11.7
+openai==1.92.1
+python-dotenv==1.1.1
+httpx==0.28.1

test.py

@@ -0,0 +1,73 @@
+#!/usr/bin/env python3
+"""
+Simple test script for the deployed API
+Update BASE_URL to your Hugging Face Space URL
+"""
+
+import httpx
+import json
+import os
+
+# Update this to your actual Hugging Face Space URL
+BASE_URL = "https://your-space-name.hf.space"
+
+def test_api():
+    """Test the deployed API"""
+    
+    # Get OpenAI API key from environment
+    api_key = os.getenv("OPENAI_API_KEY")
+    if not api_key:
+        print("❌ Please set OPENAI_API_KEY environment variable")
+        print("   export OPENAI_API_KEY='your_actual_key'")
+        return
+    
+    headers = {
+        "Content-Type": "application/json",
+        "x-api-key": api_key
+    }
+    
+    print(f"🧪 Testing API at: {BASE_URL}")
+    print("=" * 50)
+    
+    # Test health endpoint
+    try:
+        with httpx.Client(timeout=30.0) as client:
+            response = client.get(f"{BASE_URL}/health")
+            print(f"✅ Health Check: {response.status_code}")
+            print(f"   {response.json()}")
+    except Exception as e:
+        print(f"❌ Health check failed: {e}")
+    
+    # Test address detection
+    try:
+        with httpx.Client(timeout=30.0) as client:
+            data = {
+                "entity_urn": "test_001",
+                "content": "Send package to 123 Main Street, New York, NY 10001"
+            }
+            response = client.post(f"{BASE_URL}/address-detection", json=data, headers=headers)
+            print(f"✅ Address Detection: {response.status_code}")
+            result = response.json()
+            print(f"   Addresses: {result.get('result', 'N/A')}")
+    except Exception as e:
+        print(f"❌ Address detection failed: {e}")
+    
+    # Test summarization
+    try:
+        with httpx.Client(timeout=30.0) as client:
+            data = {
+                "entity_urn": "test_002", 
+                "content": "I love this product! It's amazing and exceeded my expectations."
+            }
+            response = client.post(f"{BASE_URL}/summarize", json=data, headers=headers)
+            print(f"✅ Summarization: {response.status_code}")
+            result = response.json()
+            print(f"   Summary: {result.get('result', 'N/A')}")
+            print(f"   Sentiment: {result.get('sentiment', 'N/A')}")
+    except Exception as e:
+        print(f"❌ Summarization failed: {e}")
+    
+    print(f"\n📖 View docs at: {BASE_URL}/docs")
+
+if __name__ == "__main__":
+    test_api()