testing fast response

app.py

@@ -17,8 +17,9 @@ from metals_price import MetalsPrice
 import os
 import pytz
 from currency_exchange import CurrencyExchange
-from ticker_detail import PSXScraper,build_ticker
+from ticker_detail import PSXScraper,build_ticker,get_ticker_data
 from index_detail import PSXIndicesScraper,convert_indices_to_tickers
+import httpx
 
 
 CACHE = {
@@ -629,10 +630,15 @@ def get_all_etf():
     return etf.getAllEtf()
 
 @app.get("/ticker/{symbol}")
-def get_ticker_detail(symbol:str):
-    scraper = PSXScraper(symbol)
-    result = scraper.scrape()
-    ticker = build_ticker(result, symbol)
+async def get_ticker_detail(symbol: str):
+    try:
+        raw_data = await get_ticker_data(symbol)
+    except httpx.HTTPStatusError as e:
+        raise HTTPException(status_code=404, detail=f"Symbol {symbol} not found or page error")
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+    ticker = build_ticker(raw_data, symbol)
     return ticker
 
 @app.get("/indices")

ticker_detail.py

@@ -1,90 +1,103 @@
 import requests
 from bs4 import BeautifulSoup
-from datetime import datetime
+from datetime import datetime,timedelta
 from pydantic import BaseModel
 from models import TickerData,Ticker,get_market_status
 import re
 import httpx
-
-
+import asyncio
+from functools import lru_cache, wraps
+from typing import Dict, Optional
+
+
+
+def ttl_cache(seconds: int):
+    def decorator(func):
+        cache = {}
+        @wraps(func)
+        async def wrapper(*args, **kwargs):
+            key = (args, tuple(sorted(kwargs.items())))
+            now = datetime.utcnow()
+            if key in cache:
+                result, timestamp = cache[key]
+                if now - timestamp < timedelta(seconds=seconds):
+                    return result
+            result = await func(*args, **kwargs)
+            cache[key] = (result, now)
+            return result
+        return wrapper
+    return decorator
 class PSXScraper:
     
     BASE_URL = "https://dps.psx.com.pk/company/{}"
 
-    def __init__(self, symbol):
+    def __init__(self, symbol: str):
         self.symbol = symbol.upper()
         self.url = self.BASE_URL.format(self.symbol)
-        self.headers = {
-            "User-Agent": "Mozilla/5.0"
-        }
-        self.soup = None
-        self.data = {}
+
 
     # ---------------------------
     # Fetch Page
     # ---------------------------
-    def fetch(self):
-        response = requests.get(self.url, headers=self.headers)
-        response.raise_for_status()
-        self.soup = BeautifulSoup(response.text, "lxml")
+    async def fetch(self, client: httpx.AsyncClient) -> BeautifulSoup:
+        """Fetch HTML asynchronously using a shared client."""
+        resp = await client.get(self.url, headers={"User-Agent": "Mozilla/5.0"})
+        resp.raise_for_status()
+        return BeautifulSoup(resp.text, "lxml")
+
+    async def scrape(self, client: httpx.AsyncClient) -> Dict:
+        soup = await self.fetch(client)
+        # parse_quote_summary and parse_reg_panel are synchronous helpers
+        data = {}
+        self._parse_quote_summary(soup, data)
+        self._parse_reg_panel(soup, data)
+        return data
 
     # ---------------------------
     # Parse Top Price Section
     # ---------------------------
-    def parse_quote_summary(self):
-        quote = self.soup.select_one(".quote__price")
+    def _parse_quote_summary(self, soup: BeautifulSoup, data: Dict):
+        quote = soup.select_one(".quote__price")
         if not quote:
             return
-
         price = quote.select_one(".quote__close")
         change = quote.select_one(".change__value")
         change_pct = quote.select_one(".change__percent")
-
         if price:
-            self.data["price"] = price.get_text(strip=True)
-
+            data["price"] = price.get_text(strip=True)
         if change:
-            self.data["change"] = change.get_text(strip=True)
-
+            data["change"] = change.get_text(strip=True)
         if change_pct:
-            self.data["change_percent"] = change_pct.get_text(strip=True)
+            data["change_percent"] = change_pct.get_text(strip=True)
 
-    # ---------------------------
-    # Parse REG Panel Stats
-    # ---------------------------
-    def parse_reg_panel(self):
-        reg_panel = self.soup.select_one(
-            'div.tabs__panel[data-name="REG"]'
-        )
 
+    def _parse_reg_panel(self, soup: BeautifulSoup, data: Dict):
+        reg_panel = soup.select_one('div.tabs__panel[data-name="REG"]')
         if not reg_panel:
             return
-
-        rows = reg_panel.select(".stats_item")
-
-        for row in rows:
+        for row in reg_panel.select(".stats_item"):
             label_el = row.select_one(".stats_label")
             value_el = row.select_one(".stats_value")
-
             if not label_el or not value_el:
                 continue
-
             key = normalize_key(label_el.get_text(strip=True))
-
-            value = value_el.get_text(" ", strip=True)
-
-            self.data[key] = value
+            data[key] = value_el.get_text(" ", strip=True)
 
     # ---------------------------
     # Public Method
     # ---------------------------
-    def scrape(self):
-        self.fetch()
-        self.parse_quote_summary()
-        self.parse_reg_panel()
-        return self.data
+    # def scrape(self):
+    #     self.fetch()
+    #     self.parse_quote_summary()
+    #     self.parse_reg_panel()
+    #     return self.data
 
 
+@ttl_cache(seconds=10)  # adjust based on how fresh you need the data
+async def get_ticker_data(symbol: str) -> Dict:
+    async with httpx.AsyncClient(timeout=10.0) as client:
+        scraper = PSXScraper(symbol)
+        return await scraper.scrape(client)
 
 def normalize_key(label: str) -> str:
     """
@@ -164,8 +177,6 @@ def map_to_ticker_data(raw: dict, symbol: str) -> TickerData:
         year_1_change=to_float(raw.get("1_year_change")),
         ytd_change=to_float(raw.get("ytd_change")),
 
-        stockCount=0,
-        sectorName=""
     )
 
 def build_ticker(raw_data: dict, symbol: str) -> Ticker: