Upload 4 files

app/config.py

@@ -0,0 +1,11 @@
+# app/config.py
+from pydantic_settings import BaseSettings
+
+class Settings(BaseSettings):
+    MODEL_NAME: str = "your-model-name"
+    MAX_LENGTH: int = 512
+    TEMPERATURE: float = 0.7
+    TOP_P: float = 0.9
+
+    class Config:
+        env_file = ".env"

app/main.py

@@ -0,0 +1,32 @@
+# app/main.py
+from fastapi import FastAPI
+from fastapi.middleware.cors import CORSMiddleware
+from app.models.recipe import RecipeRequest, RecipeResponse
+from app.services.recipe_generator import RecipeGenerator
+
+app = FastAPI(title="Recipe Generation API")
+
+# Configure CORS for Vercel frontend
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],  # Update this with your Vercel app URL in production
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+# Initialize recipe generator service
+recipe_generator = RecipeGenerator()
+
+@app.get("/")
+async def root():
+    return {"message": "Recipe Generation API is running"}
+
+@app.post("/generate-recipe", response_model=RecipeResponse)
+async def generate_recipe(request: RecipeRequest):
+    recipe = await recipe_generator.generate(request.ingredients)
+    return RecipeResponse(
+        title=recipe["title"],
+        ingredients=recipe["ingredients"],
+        instructions=recipe["instructions"]
+    )

app/models/recipe.py

@@ -0,0 +1,11 @@
+# app/models/recipe.py
+from pydantic import BaseModel
+from typing import List
+
+class RecipeRequest(BaseModel):
+    ingredients: List[str]
+
+class RecipeResponse(BaseModel):
+    title: str
+    ingredients: List[str]
+    instructions: List[str]

app/services/recipe_generator.py

@@ -0,0 +1,53 @@
+# app/services/recipe_generator.py
+from transformers import AutoTokenizer, AutoModelForCausalLM
+import torch
+
+class RecipeGenerator:
+    def __init__(self):
+        # Initialize your fine-tuned model and tokenizer
+        self.tokenizer = AutoTokenizer.from_pretrained("flax-community/t5-recipe-generation")
+        self.model = AutoModelForCausalLM.from_pretrained("flax-community/t5-recipe-generation")
+        
+    async def generate(self, ingredients: List[str]):
+        # Format ingredients for input
+        input_text = f"Generate a recipe using these ingredients: {', '.join(ingredients)}"
+        
+        # Tokenize and generate
+        inputs = self.tokenizer(input_text, return_tensors="pt", padding=True)
+        outputs = self.model.generate(
+            inputs.input_ids,
+            max_length=512,
+            num_return_sequences=1,
+            temperature=0.7,
+            top_p=0.9,
+            do_sample=True
+        )
+        
+        # Decode and parse the generated recipe
+        generated_text = self.tokenizer.decode(outputs[0], skip_special_tokens=True)
+        
+        # Parse the generated text into structured format
+        # This is a simple example - adjust based on your model's output format
+        lines = generated_text.split('\n')
+        title = lines[0]
+        ingredients_list = []
+        instructions_list = []
+        
+        # Simple parsing logic - adjust based on your model's output format
+        current_section = None
+        for line in lines[1:]:
+            if "Ingredients:" in line:
+                current_section = "ingredients"
+            elif "Instructions:" in line:
+                current_section = "instructions"
+            elif line.strip():
+                if current_section == "ingredients":
+                    ingredients_list.append(line.strip())
+                elif current_section == "instructions":
+                    instructions_list.append(line.strip())
+        
+        return {
+            "title": title,
+            "ingredients": ingredients_list,
+            "instructions": instructions_list
+        }