Upload main.py with huggingface_hub

main.py

@@ -0,0 +1,238 @@
+from fastapi import FastAPI, HTTPException, Depends, BackgroundTasks
+from fastapi.middleware.cors import CORSMiddleware
+from pydantic import BaseModel
+from typing import Optional, List
+import uuid
+from datetime import datetime
+
+import sys
+import os
+sys.path.append(os.path.dirname(os.path.abspath(__file__)))
+
+from core.ai_gateway import AIGateway, ModelProvider
+from core.security import get_current_user, create_access_token, get_password_hash, verify_password
+from database.models import User, ContentItem, ScheduledPost
+from database.session import get_db
+from services.content_studio import ContentStudioService
+from utils.text_processing import optimize_content, extract_keywords
+
+app = FastAPI(
+    title="AuraNexus AI Content Orchestration Platform",
+    description="Open-source platform for AI-powered content creation and distribution",
+    version="0.1.0"
+)
+
+# Add CORS middleware
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+# Initialize services
+ai_gateway = AIGateway()
+content_studio = ContentStudioService(ai_gateway)
+
+class Token(BaseModel):
+    access_token: str
+    token_type: str
+
+class TokenData(BaseModel):
+    username: Optional[str] = None
+
+class UserCreate(BaseModel):
+    username: str
+    email: str
+    password: str
+
+class UserOut(BaseModel):
+    id: str
+    username: str
+    email: str
+    created_at: datetime
+
+class ContentGenerationRequest(BaseModel):
+    topic: str
+    content_type: str
+    platform: str
+    provider: Optional[ModelProvider] = ModelProvider.LOCAL_LLAMA
+
+class ContentGenerationResponse(BaseModel):
+    id: str
+    title: str
+    content_type: str
+    generated_content: str
+    platform_specific_variants: dict
+    tags: List[str]
+    created_at: datetime
+
+class OptimizationRequest(BaseModel):
+    content_id: str
+    optimization_type: str
+
+@app.on_event("startup")
+def startup_event():
+    from database.models import create_tables
+    create_tables()
+
+@app.get("/")
+async def root():
+    return {"message": "Welcome to AuraNexus AI Content Orchestration Platform"}
+
+@app.post("/api/v1/auth/register", response_model=UserOut)
+async def register(user: UserCreate, db=Depends(get_db)):
+    # Check if user already exists
+    existing_user = db.query(User).filter(User.username == user.username).first()
+    if existing_user:
+        raise HTTPException(status_code=400, detail="Username already registered")
+    
+    existing_email = db.query(User).filter(User.email == user.email).first()
+    if existing_email:
+        raise HTTPException(status_code=400, detail="Email already registered")
+    
+    # Create new user
+    hashed_password = get_password_hash(user.password)
+    db_user = User(
+        username=user.username,
+        email=user.email,
+        hashed_password=hashed_password
+    )
+    db.add(db_user)
+    db.commit()
+    db.refresh(db_user)
+    
+    return UserOut(
+        id=db_user.id,
+        username=db_user.username,
+        email=db_user.email,
+        created_at=db_user.created_at
+    )
+
+@app.post("/api/v1/auth/token", response_model=Token)
+async def login(username: str, password: str, db=Depends(get_db)):
+    user = db.query(User).filter(User.username == username).first()
+    if not user or not verify_password(password, user.hashed_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": user.id})
+    return {"access_token": access_token, "token_type": "bearer"}
+
+@app.post("/api/v1/content/generate", response_model=ContentGenerationResponse)
+async def generate_content(
+    request: ContentGenerationRequest,
+    current_user: User = Depends(get_current_user),
+    db=Depends(get_db)
+):
+    """
+    Generate content using AI models
+    """
+    try:
+        content_item = await content_studio.generate_content(
+            topic=request.topic,
+            content_type=request.content_type,
+            platform=request.platform,
+            user_id=current_user.id,
+            db=db
+        )
+        
+        return ContentGenerationResponse(
+            id=content_item.id,
+            title=content_item.title,
+            content_type=content_item.content_type,
+            generated_content=content_item.generated_content,
+            platform_specific_variants=content_item.platform_specific_variants,
+            tags=content_item.tags,
+            created_at=content_item.created_at
+        )
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Content generation failed: {str(e)}")
+
+@app.post("/api/v1/content/optimize")
+async def optimize_existing_content(
+    request: OptimizationRequest,
+    current_user: User = Depends(get_current_user),
+    db=Depends(get_db)
+):
+    """
+    Optimize existing content
+    """
+    try:
+        content_item = await content_studio.optimize_content(
+            content_id=request.content_id,
+            optimization_type=request.optimization_type,
+            db=db
+        )
+        
+        return {
+            "id": content_item.id,
+            "optimized_content": content_item.generated_content,
+            "updated_at": content_item.updated_at
+        }
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Content optimization failed: {str(e)}")
+
+@app.get("/api/v1/content/my", response_model=List[ContentGenerationResponse])
+async def get_my_content(
+    current_user: User = Depends(get_current_user),
+    db=Depends(get_db)
+):
+    """
+    Get all content items for the current user
+    """
+    content_items = db.query(ContentItem).filter(ContentItem.owner_id == current_user.id).all()
+    
+    return [
+        ContentGenerationResponse(
+            id=item.id,
+            title=item.title,
+            content_type=item.content_type,
+            generated_content=item.generated_content,
+            platform_specific_variants=item.platform_specific_variants,
+            tags=item.tags,
+            created_at=item.created_at
+        )
+        for item in content_items
+    ]
+
+@app.post("/api/v1/generate/text")
+async def generate_text_only(request: ContentGenerationRequest, current_user: User = Depends(get_current_user)):
+    """
+    Generate text content only
+    """
+    try:
+        prompt = content_studio._create_content_prompt(
+            request.topic, 
+            request.content_type, 
+            request.platform
+        )
+        
+        generated_text = await ai_gateway.generate_text(
+            prompt=prompt,
+            provider=request.provider
+        )
+        
+        return {"generated_text": generated_text}
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Text generation failed: {str(e)}")
+
+@app.get("/api/v1/models")
+async def list_available_models(current_user: User = Depends(get_current_user)):
+    """
+    List available AI models
+    """
+    available_models = [provider.value for provider in ai_gateway.models.keys()]
+    return {"available_models": available_models}
+
+@app.get("/api/v1/health")
+async def health_check():
+    return {"status": "healthy", "timestamp": datetime.utcnow()}
+
+if __name__ == "__main__":
+    import uvicorn
+    uvicorn.run(app, host="0.0.0.0", port=8000)