talk to web page app

dependencies.py

@@ -0,0 +1,15 @@
+from fastapi import Body
+from loguru import logger
+
+from schemas import TextModelRequest
+from scraper import extract_urls, fetch_all
+
+async def get_urls_content(body: TextModelRequest ) -> str: 
+    urls = extract_urls(body.prompt)
+    if urls:
+        try:
+            urls_content = await fetch_all(urls)
+            return urls_content
+        except Exception as e:
+            logger.warning(f"Failed to fetch one or several URls - Error: {e}")
+    return ""

main.py

@@ -1,5 +1,5 @@
 # main.py
-from fastapi import FastAPI,status,Response,Request
+from fastapi import FastAPI,status,Response,Request,Depends
 from fastapi.responses import StreamingResponse,FileResponse
 from models import load_text_model,generate_text,load_audio_model,generate_audio,load_image_model, generate_image
 from schemas import VoicePresets
@@ -10,12 +10,15 @@ from uuid import uuid4
 import time
 from datetime import datetime, timezone
 import csv
+from dependencies import get_urls_content
+from schemas import TextModelResponse,TextModelRequest
 
 models = {} 
 
 @asynccontextmanager 
 async def lifespan(_: FastAPI) -> AsyncIterator[None]:
     # models["text2image"] = load_image_model() 
+    models["text"]=load_text_model()
     yield 
     models.clear() 
 
@@ -59,16 +62,17 @@ async def monitor_service(
 
 
 # app = FastAPI() 
-
 @app.get("/")
 def root_controller():
     return {"status": "healthy"}
 
 @app.get("/generate/text") 
-def serve_language_model_controller(prompt: str) -> str: 
-    pipe = load_text_model() 
-    output = generate_text(pipe, prompt) 
-    return output 
+async def serve_language_model_controller(request: Request,
+    body: TextModelRequest ,
+    urls_content: str = Depends(get_urls_content)) -> TextModelResponse: 
+    prompt = body.prompt + " " + urls_content
+    output = generate_text(models["text"], prompt, body.temperature)
+    return TextModelResponse(content=output, ip=request.client.host)
 
 @app.get("/logs")
 def get_logs():

requirements.txt

@@ -6,4 +6,7 @@ pydantic
 bitsandbytes
 soundfile
 diffusers
-loguru
+loguru
+beautifulsoup4 
+lxml 
+aiohttp

schemas.py

@@ -1,3 +1,59 @@
 from typing import Literal
+from datetime import datetime
+from typing import Annotated, Literal
+from uuid import uuid4
+from pydantic import BaseModel, Field, HttpUrl, IPvAnyAddress, PositiveInt,AfterValidator,validate_call
+
 
 VoicePresets = Literal["v2/en_speaker_1", "v2/en_speaker_9"]
+
+class ModelRequest(BaseModel): 
+    prompt: Annotated[str, Field(min_length=1, max_length=10000)]
+
+
+class ModelResponse(BaseModel): 
+    request_id: Annotated[str, Field(default_factory=lambda: uuid4().hex)]
+    ip: Annotated[str, IPvAnyAddress] | None
+    content: Annotated[str | None, Field(min_length=0, max_length=10000)]
+    created_at: datetime = datetime.now()
+
+
+class TextModelRequest(ModelRequest):
+    model: Literal["gpt-3.5-turbo", "gpt-4o"]
+    temperature: Annotated[float, Field(ge=0.0, le=1.0, default=0.0)]
+
+class TextModelResponse(ModelResponse):
+    tokens: Annotated[int|None, Field(ge=0)]
+
+ImageSize = Annotated[tuple[PositiveInt, PositiveInt], "Width and height of an image in pixels"]
+SupportedModels = Annotated[
+    Literal["tinysd", "sd1.5"], "Supported Image Generation Models"
+]
+
+@validate_call 
+def is_square_image(value: ImageSize) -> ImageSize: 
+    if value[0] / value[1] != 1:
+        raise ValueError("Only square images are supported")
+    if value[0] not in [512, 1024]:
+        raise ValueError(f"Invalid output size: {value} - expected 512 or 1024")
+    return value
+
+@validate_call 
+def is_valid_inference_step(
+    num_inference_steps: int, model: SupportedModels
+) -> int:
+    if model == "tinysd" and num_inference_steps > 2000: 
+        raise ValueError(
+            "TinySD model cannot have more than 2000 inference steps"
+        )
+    return num_inference_steps
+
+class ImageModelRequest(ModelRequest): 
+    model: SupportedModels
+    output_size: ImageSize
+    num_inference_steps: Annotated[int, Field(ge=0, le=2000)] = 200
+
+class ImageModelResponse(ModelResponse): 
+    size: ImageSize
+    url: Annotated[str, HttpUrl] | None = None
+

scrapper.py

@@ -0,0 +1,36 @@
+import asyncio
+import re
+
+import aiohttp
+from bs4 import BeautifulSoup
+from loguru import logger
+
+def extract_urls(text: str) -> list[str]:
+    url_pattern = r"(?P<url>https?:\/\/[^\s]+)" 
+    urls = re.findall(url_pattern, text) 
+    return urls
+
+
+def parse_inner_text(html_string: str) -> str:
+    soup = BeautifulSoup(html_string, "lxml")
+    if content := soup.find("div", id="bodyContent"): 
+        return content.get_text()
+    logger.warning("Could not parse the HTML content")
+    return ""
+
+
+async def fetch(session: aiohttp.ClientSession, url: str) -> str:
+    async with session.get(url) as response: 
+        html_string = await response.text()
+        return parse_inner_text(html_string)
+
+
+async def fetch_all(urls: list[str]) -> str:
+    async with aiohttp.ClientSession() as session: 
+        results = await asyncio.gather(
+            *[fetch(session, url) for url in urls], return_exceptions=True
+        )
+    success_results = [result for result in results if isinstance(result, str)]
+    if len(results) != len(success_results): 
+        logger.warning("Some URLs could not be fetched")
+    return " ".join(success_results)

utils.py

@@ -4,6 +4,7 @@ import numpy as np
 from PIL import Image
 from typing import Literal,TypeAlias
 import tiktoken
+from loguru import logger
 
 def audio_array_to_buffer(audio_array: np.array, sample_rate: int) -> BytesIO:
     buffer = BytesIO()
@@ -42,7 +43,7 @@ def calculate_usage_costs(
     if model not in price_table:
         # raise at runtime - in case someone ignores type errors
         raise ValueError(f"Cost calculation is not supported for {model} model.")
-    price = price_table[model] 9
+    price = price_table[model] 
     req_costs = price * count_tokens(prompt) / 1000
     res_costs = price * count_tokens(response) / 1000 
     total_costs = req_costs + res_costs