Update app.py

app.py

@@ -2,13 +2,12 @@ import gradio as gr
 import re
 import asyncio
 import aiohttp
-from datetime import datetime, time
+from datetime import datetime, time, date
 from typing import Dict, Optional, List
 import pytz
 import tzlocal
 import logging
 import json
-from datetime import date
 
 # --- Basic Setup ---
 
@@ -21,36 +20,23 @@ class DateTimeValidationError(ValueError):
     """Custom exception for datetime validation errors."""
     pass
 
-# 3. Assume hist_url is globally defined
+# 3. API URL
 hist_url = "https://groww.in/v1/api/charting_service/v2/chart/exchange/NSE/segment/CASH"
 
 
 # --- Date/Time Functions ---
 
 def validate_datetime_format(dt_str: str) -> datetime:
-    """
-    Validate datetime string in strict 'YYYY-MM-DD' format.
-    """
+    """Validate datetime string in strict 'YYYY-MM-DD' format."""
     if not isinstance(dt_str, str):
-        logger.error(f"Expected string input, got {type(dt_str).__name__}")
         raise TypeError(f"Input must be a string, got {type(dt_str).__name__}")
-
     date_pattern = re.compile(r'^\d{4}-\d{2}-\d{2}$')
     if not date_pattern.match(dt_str):
-        logger.error(f"Invalid date format: '{dt_str}'. Expected 'YYYY-MM-DD'")
-        raise DateTimeValidationError(
-            f"Invalid date format: '{dt_str}'. Expected 'YYYY-MM-DD'"
-        )
-
+        raise DateTimeValidationError(f"Invalid date format: '{dt_str}'. Expected 'YYYY-MM-DD'")
     try:
-        parsed_date = datetime.strptime(dt_str, '%Y-%m-%d')
-        logger.debug(f"Successfully validated date: {dt_str}")
-        return parsed_date
+        return datetime.strptime(dt_str, '%Y-%m-%d')
     except ValueError as e:
-        logger.error(f"Invalid date value: '{dt_str}' - {str(e)}")
-        raise DateTimeValidationError(
-            f"Invalid date value: '{dt_str}'. Please provide a valid calendar date."
-        ) from e
+        raise DateTimeValidationError(f"Invalid date value: '{dt_str}'.") from e
 
 def _resolve_timezone(timezone: Optional[str]) -> pytz.BaseTzInfo:
     """Resolve timezone string to pytz timezone object."""
@@ -58,226 +44,146 @@ def _resolve_timezone(timezone: Optional[str]) -> pytz.BaseTzInfo:
         try:
             return pytz.timezone(timezone)
         except pytz.UnknownTimeZoneError as e:
-            logger.error(f"Unknown timezone: '{timezone}'")
             raise ValueError(f"Unknown timezone: '{timezone}'") from e
-    else:
-        local_tz = tzlocal.get_localzone()
-        logger.debug(f"Using local timezone: {local_tz}")
-        return local_tz
+    return tzlocal.get_localzone()
 
-def convert_to_unixtimestamp(
-    date_time_str: str,
-    timezone: Optional[str] = None
-) -> int:
-    """
-    Convert datetime string to Unix timestamp in milliseconds with timezone handling.
-    """
+def convert_to_unixtimestamp(date_time_str: str, timezone: Optional[str] = None) -> int:
+    """Convert 'YYYY-MM-DD HH:MM' string to Unix timestamp in milliseconds."""
     if not isinstance(date_time_str, str):
-        logger.error(f"Expected string input, got {type(date_time_str).__name__}")
-        raise TypeError(
-            f"DateTime input must be a string in 'YYYY-MM-DD HH:MM' format, "
-            f"got {type(date_time_str).__name__}"
-        )
-
+        raise TypeError(f"DateTime input must be a string, got {type(date_time_str).__name__}")
     try:
         dt = datetime.strptime(date_time_str, '%Y-%m-%d %H:%M')
-        logger.debug(f"Successfully parsed datetime: {date_time_str}")
     except ValueError as e:
-        logger.error(f"Invalid datetime format: '{date_time_str}'")
-        raise DateTimeValidationError(
-            f"Invalid datetime format: '{date_time_str}'. Expected 'YYYY-MM-DD HH:MM'"
-        ) from e
-
+        raise DateTimeValidationError(f"Invalid format: '{date_time_str}'. Expected 'YYYY-MM-DD HH:MM'") from e
+    
     target_tz = _resolve_timezone(timezone)
+    localized_dt = target_tz.localize(dt) if dt.tzinfo is None else dt.astimezone(target_tz)
+    return int(localized_dt.timestamp() * 1000)
 
-    if dt.tzinfo is None:
-        localized_dt = target_tz.localize(dt)
-    else:
-        localized_dt = dt.astimezone(target_tz)
-
-    timestamp_ms = int(localized_dt.timestamp() * 1000)
-    logger.debug(f"Converted '{date_time_str}' to timestamp: {timestamp_ms}")
-
-    return timestamp_ms
-
-def get_time_range_in_unix_ms(
-    start_date_str: str,
-    end_date_str: str,
-    timezone: str = 'Asia/Kolkata'
-) -> Dict[str, int]:
-    """
-    Calculates the start and end Unix timestamps in milliseconds for a date range.
-    """
+def get_time_range_in_unix_ms(start_date_str: str, end_date_str: str, timezone: str = 'Asia/Kolkata') -> Dict[str, int]:
+    """Calculates the start (00:00) and end (23:59) Unix timestamps for a date range."""
     start_date = validate_datetime_format(start_date_str)
     end_date = validate_datetime_format(end_date_str)
-
     start_datetime = datetime.combine(start_date, time.min)
     end_datetime = datetime.combine(end_date, time(23, 59))
-
-    start_datetime_str = start_datetime.strftime('%Y-%m-%d %H:%M')
-    end_datetime_str = end_datetime.strftime('%Y-%m-%d %H:%M')
-
-    start_timestamp = convert_to_unixtimestamp(start_datetime_str, timezone)
-    end_timestamp = convert_to_unixtimestamp(end_datetime_str, timezone)
-
-    return {
-        "start_timestamp_ms": start_timestamp,
-        "end_timestamp_ms": end_timestamp,
-    }
+    start_timestamp = convert_to_unixtimestamp(start_datetime.strftime('%Y-%m-%d %H:%M'), timezone)
+    end_timestamp = convert_to_unixtimestamp(end_datetime.strftime('%Y-%m-%d %H:%M'), timezone)
+    return {"start_timestamp_ms": start_timestamp, "end_timestamp_ms": end_timestamp}
 
 
 # --- Asynchronous API Function ---
 
-async def call_price_api_async(
-    session: aiohttp.ClientSession,
-    ticker: str,
-    start: int,
-    end: int,
-    interval: int,
-) -> Dict:
-    """
-    Asynchronously calls the Groww candle API and returns the raw JSON response.
-    """
+async def call_price_api_async(session: aiohttp.ClientSession, ticker: str, start: int, end: int, interval: int) -> Dict:
+    """Asynchronously calls the candle API."""
     url = f"{hist_url}/{ticker}"
-    params = {
-        "startTimeInMillis": start,
-        "endTimeInMillis": end,
-        "intervalInMinutes": interval,
-    }
-
+    params = {"startTimeInMillis": start, "endTimeInMillis": end, "intervalInMinutes": interval}
     try:
         async with session.get(url, params=params) as response:
             response.raise_for_status()
             json_data = await response.json()
-            return {
-                "ticker": ticker,
-                "interval": interval,
-                "data": json_data,
-                "error": None,
-            }
+            return {"ticker": ticker, "interval": interval, "data": json_data, "error": None}
     except aiohttp.ClientError as e:
-        return {
-            "ticker": ticker,
-            "interval": interval,
-            "data": None,
-            "error": str(e),
-        }
+        return {"ticker": ticker, "interval": interval, "data": None, "error": str(e)}
 
 
 # --- Main Processing Logic ---
 
-async def main(tickers: List[str], start_time: int, end_time: int, intervals: List[int], progress: gr.Progress):
-    """
-    Main function to run the asynchronous API calls in batches.
-    """
+async def main_task(tickers: List[str], start_time: int, end_time: int, intervals: List[int], progress: gr.Progress):
+    """Main function to run the asynchronous API calls in batches."""
     results = []
     batch_size = 30
-    
     async with aiohttp.ClientSession() as session:
         for i in progress.tqdm(range(0, len(tickers), batch_size), desc="Processing Batches"):
             batch_tickers = tickers[i:i+batch_size]
-            tasks = []
-            for ticker in batch_tickers:
-                for interval in intervals:
-                    tasks.append(
-                        call_price_api_async(session, ticker, start_time, end_time, interval)
-                    )
-            
+            tasks = [call_price_api_async(session, ticker, start_time, end_time, interval)
+                     for ticker in batch_tickers for interval in intervals]
             batch_results = await asyncio.gather(*tasks)
             results.extend(batch_results)
-            
     return results
 
 def process_and_merge_data(results: list) -> str:
-    """
-    Processes and merges the raw API results for different intervals.
-    """
+    """Processes and merges the raw API results for different intervals."""
     merged_data = {}
-
     for result in results:
-        ticker = result.get("ticker")
-        interval = result.get("interval")
-        data = result.get("data")
-        error = result.get("error")
-
+        ticker, interval, data, error = result.get("ticker"), result.get("interval"), result.get("data"), result.get("error")
         if ticker not in merged_data:
             merged_data[ticker] = {"symbol": ticker}
-
         if error:
             merged_data[ticker][f"error_{interval}m"] = error
             continue
-
         if data and data.get("candles") and data["candles"]:
             first_candle = data["candles"][0]
-            
-            if interval == 1440:
-                merged_data[ticker]["day open"] = first_candle[1] if len(first_candle) > 1 else None
-                merged_data[ticker]["day high"] = first_candle[2] if len(first_candle) > 2 else None
-                merged_data[ticker]["day low"] = first_candle[3] if len(first_candle) > 3 else None
-                merged_data[ticker]["day close"] = first_candle[4] if len(first_candle) > 4 else None
-            elif interval == 15:
-                merged_data[ticker]["start open"] = first_candle[1] if len(first_candle) > 1 else None
-                merged_data[ticker]["start high"] = first_candle[2] if len(first_candle) > 2 else None
-                merged_data[ticker]["start low"] = first_candle[3] if len(first_candle) > 3 else None
-                merged_data[ticker]["start close"] = first_candle[4] if len(first_candle) > 4 else None
+            if len(first_candle) > 4:
+                prefix = "day" if interval == 1440 else "start"
+                merged_data[ticker][f"{prefix} open"] = first_candle[1]
+                merged_data[ticker][f"{prefix} high"] = first_candle[2]
+                merged_data[ticker][f"{prefix} low"] = first_candle[3]
+                merged_data[ticker][f"{prefix} close"] = first_candle[4]
         else:
             merged_data[ticker][f"error_{interval}m"] = "No data or candles found"
+            
+    return json.dumps(list(merged_data.values()), indent=4)
 
-    final_results = list(merged_data.values())
-    return json.dumps(final_results, indent=4)
-
-# --- Gradio Interface ---
+# --- Gradio Backend Function ---
 
 async def run_backend_processing(tickers_text: str, progress=gr.Progress(track_tqdm=True)):
-    """
-    The main function to be called by the Gradio interface.
-    """
+    """The main function to be called by the Gradio interface."""
     if not tickers_text.strip():
-        return "Please enter at least one ticker.", "{}"
+        yield "Please enter at least one ticker.", "{}"
+        return  # Correct way to exit an async generator
 
-    tickers = [ticker.strip() for ticker in tickers_text.split('\n') if ticker.strip()]
-    
+    tickers = [ticker.strip().upper() for ticker in tickers_text.split('\n') if ticker.strip()]
     today_str = date.today().strftime("%Y-%m-%d")
-    
     yield f"Starting processing for {len(tickers)} tickers for date: {today_str}", "{}"
     
     try:
         time_range = get_time_range_in_unix_ms(today_str, today_str)
-        start_time = time_range["start_timestamp_ms"]
-        end_time = time_range["end_timestamp_ms"]
+        start_time, end_time = time_range["start_timestamp_ms"], time_range["end_timestamp_ms"]
         intervals = [1440, 15]
 
-        yield "Fetching data from API...", "{}"
-        
-        results = await main(tickers, start_time, end_time, intervals, progress)
+        yield "Fetching data from API in batches...", "{}"
+        results = await main_task(tickers, start_time, end_time, intervals, progress)
         
         yield "Processing and merging data...", "{}"
-        
         processed_json = process_and_merge_data(results)
         
         yield "Processing complete.", processed_json
         
     except Exception as e:
-        logger.error(f"An error occurred: {e}")
+        logger.error(f"An unhandled error occurred: {e}")
         yield f"An error occurred: {e}", "{}"
 
-with gr.Blocks() as demo:
-    gr.Markdown("# Backend Processing Logs")
+# --- Gradio UI ---
+
+with gr.Blocks(theme=gr.themes.Soft()) as demo:
+    gr.Markdown("## Stock Data Backend Processor")
+    gr.Markdown("Enter stock tickers (one per line) and click 'Start Processing' or press Enter.")
     
     with gr.Row():
         with gr.Column(scale=1):
-            tickers_input = gr.Textbox(lines=10, label="Enter Tickers (one per line)")
-            start_button = gr.Button("Start Processing")
+            # Pre-fill the textbox with the example tickers
+            tickers_input = gr.Textbox(
+                lines=10, 
+                label="Enter Tickers", 
+                value="RELIANCE\nINFY"
+            )
+            start_button = gr.Button("Start Processing", variant="primary")
         
         with gr.Column(scale=2):
             logs_output = gr.Textbox(label="Logs", lines=15, interactive=False)
             json_output = gr.JSON(label="Processed JSON Output")
 
-    start_button.click(
-        fn=run_backend_processing,
-        inputs=[tickers_input],
-        outputs=[logs_output, json_output]
-    )
+    # --- Triggers ---
+    
+    # Define a list of components that trigger the function
+    triggers = [start_button.click, tickers_input.submit]
+    
+    for event in triggers:
+        event(
+            fn=run_backend_processing,
+            inputs=[tickers_input],
+            outputs=[logs_output, json_output]
+        )
 
 if __name__ == "__main__":
     demo.launch()