Update app.py

app.py

@@ -72,7 +72,7 @@ def get_time_range_in_unix_ms(start_date_str: str, end_date_str: str, timezone:
     return {"start_timestamp_ms": start_timestamp, "end_timestamp_ms": end_timestamp}
 
 
-# --- Asynchronous API & Processing Functions (No changes here) ---
+# --- FIXED Asynchronous API & Processing Functions ---
 
 async def call_price_api_async(session: aiohttp.ClientSession, ticker: str, start: int, end: int, interval: int) -> Dict:
     """Asynchronously calls the candle API."""
@@ -87,16 +87,51 @@ async def call_price_api_async(session: aiohttp.ClientSession, ticker: str, star
         return {"ticker": ticker, "interval": interval, "data": None, "error": str(e)}
 
 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."""
+    """OPTIMIZED: Calculate all requests first, then process in batches of 30."""
+    
+    # Step 1: Calculate all requests upfront
+    all_requests = []
+    for ticker in tickers:
+        for interval in intervals:
+            all_requests.append((ticker, start_time, end_time, interval))
+    
+    total_requests = len(all_requests)
+    logger.info(f"Total requests to make: {total_requests}")
+    
+    # Step 2: Process requests in batches of 30
     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 = [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)
+    
+    async with aiohttp.ClientSession(
+        timeout=aiohttp.ClientTimeout(total=30),  # Add timeout for better reliability
+        connector=aiohttp.TCPConnector(limit=50)  # Limit concurrent connections
+    ) as session:
+        
+        for i in progress.tqdm(range(0, total_requests, batch_size), desc="Processing Request Batches"):
+            batch_requests = all_requests[i:i+batch_size]
+            
+            # Create tasks for this batch
+            tasks = [
+                call_price_api_async(session, ticker, start, end, interval)
+                for ticker, start, end, interval in batch_requests
+            ]
+            
+            # Execute batch concurrently
+            batch_results = await asyncio.gather(*tasks, return_exceptions=True)
+            
+            # Handle any exceptions in results
+            for result in batch_results:
+                if isinstance(result, Exception):
+                    logger.error(f"Request failed with exception: {result}")
+                    # You can add error handling here if needed
+                else:
+                    results.append(result)
+            
+            # Optional: Add small delay between batches to be respectful to the API
+            if i + batch_size < total_requests:
+                await asyncio.sleep(0.1)
+    
+    logger.info(f"Completed {len(results)} requests out of {total_requests}")
     return results
 
 def process_and_merge_data(results: list) -> str:
@@ -123,7 +158,7 @@ def process_and_merge_data(results: list) -> str:
     return json.dumps(list(merged_data.values()), indent=4)
 
 
-# --- Gradio Backend Function (MODIFIED FOR NEW INPUT FORMAT) ---
+# --- 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."""
@@ -148,48 +183,57 @@ async def run_backend_processing(tickers_text: str, progress=gr.Progress(track_t
         return
 
     today_str = date.today().strftime("%Y-%m-%d")
-    yield f"Starting processing for {len(tickers)} tickers: {tickers}", "{}"
+    intervals = [1440, 15]
+    total_requests = len(tickers) * len(intervals)
+    
+    yield f"Starting processing for {len(tickers)} tickers: {tickers}\nTotal API requests: {total_requests}", "{}"
     
     try:
         time_range = get_time_range_in_unix_ms(today_str, today_str)
         start_time, end_time = time_range["start_timestamp_ms"], time_range["end_timestamp_ms"]
-        intervals = [1440, 15]
 
-        yield "Fetching data from API in batches...", "{}"
+        yield f"Fetching data from API in batches of 30 (Total: {total_requests} requests)...", "{}"
+        start_fetch_time = datetime.now()
+        
         results = await main_task(tickers, start_time, end_time, intervals, progress)
         
-        yield "Processing and merging data...", "{}"
+        fetch_duration = (datetime.now() - start_fetch_time).total_seconds()
+        yield f"Data fetching completed in {fetch_duration:.2f} seconds. Processing and merging data...", "{}"
+        
         processed_json = process_and_merge_data(results)
         
-        yield "Processing complete.", processed_json
+        total_duration = (datetime.now() - start_fetch_time).total_seconds()
+        yield f"Processing complete in {total_duration:.2f} seconds. Successfully processed {len(results)} API responses.", processed_json
         
     except Exception as e:
         logger.error(f"An unhandled error occurred: {e}")
         yield f"An error occurred: {e}", "{}"
 
 
-# --- Gradio UI (MODIFIED FOR NEW INPUT FORMAT) ---
+# --- Gradio UI ---
 
 with gr.Blocks(theme=gr.themes.Soft()) as demo:
-    gr.Markdown("## Stock Data Backend Processor")
-    gr.Markdown("Enter a list of stock tickers in Python list format.")
+    gr.Markdown("## Stock Data Backend Processor (Optimized)")
+    gr.Markdown("Enter a list of stock tickers in Python list format. The app will make concurrent API requests in batches of 30.")
     
     with gr.Row():
         with gr.Column(scale=1):
-            # Update textbox to be single-line and show the correct example format
             tickers_input = gr.Textbox(
-                lines=1, 
+                lines=2, 
                 label='Enter Tickers as a List', 
-                value='["RELIANCE", "INFY"]'
+                value='["RELIANCE", "INFY", "TCS"]',
+                placeholder='["TICKER1", "TICKER2", "TICKER3"]'
             )
             start_button = gr.Button("Start Processing", variant="primary")
+            
+            # Add some helpful info
+            gr.Markdown("**Note:** Each ticker makes 2 API calls (1440m and 15m intervals)")
         
         with gr.Column(scale=2):
-            logs_output = gr.Textbox(label="Logs", lines=15, interactive=False)
+            logs_output = gr.Textbox(label="Logs & Progress", lines=15, interactive=False)
             json_output = gr.JSON(label="Processed JSON Output")
 
     # --- Triggers ---
-    # Trigger on button click or pressing Enter in the textbox
     start_button.click(
         fn=run_backend_processing,
         inputs=[tickers_input],