revert changes

app.py

@@ -630,15 +630,10 @@ def get_all_etf():
     return etf.getAllEtf()
 
 @app.get("/ticker/{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)
+def get_ticker_detail(symbol:str):
+    scraper = PSXScraper(symbol)
+    result = scraper.scrape()
+    ticker = build_ticker(result, symbol)
     return ticker
 
 @app.get("/indices")

ticker_detail.py

@@ -1,103 +1,90 @@
 import requests
 from bs4 import BeautifulSoup
-from datetime import datetime,timedelta
+from datetime import datetime
 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: str):
+    def __init__(self, symbol):
         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
     # ---------------------------
-    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
+    def fetch(self):
+        response = requests.get(self.url, headers=self.headers)
+        response.raise_for_status()
+        self.soup = BeautifulSoup(response.text, "lxml")
 
     # ---------------------------
     # Parse Top Price Section
     # ---------------------------
-    def _parse_quote_summary(self, soup: BeautifulSoup, data: Dict):
-        quote = soup.select_one(".quote__price")
+    def parse_quote_summary(self):
+        quote = self.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:
-            data["price"] = price.get_text(strip=True)
+            self.data["price"] = price.get_text(strip=True)
+
         if change:
-            data["change"] = change.get_text(strip=True)
+            self.data["change"] = change.get_text(strip=True)
+
         if change_pct:
-            data["change_percent"] = change_pct.get_text(strip=True)
+            self.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
-        for row in reg_panel.select(".stats_item"):
+
+        rows = reg_panel.select(".stats_item")
+
+        for row in rows:
             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))
-            data[key] = value_el.get_text(" ", strip=True)
+
+            value = value_el.get_text(" ", strip=True)
+
+            self.data[key] = value
 
     # ---------------------------
     # 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:
     """
@@ -177,6 +164,7 @@ 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")),
 
+       
     )
 
 def build_ticker(raw_data: dict, symbol: str) -> Ticker:
@@ -191,9 +179,8 @@ def build_ticker(raw_data: dict, symbol: str) -> Ticker:
 # Example Usage
 # ---------------------------
 if __name__ == "__main__":
-    scraper = PSXScraper("HUBC")
+    scraper = PSXScraper("NITGETF")
     result = scraper.scrape()
 
-    ticker = build_ticker(result, "HUBC")
-
+    ticker = build_ticker(result, "NITGETF")
     print(ticker.model_dump())