Added multiple file upload functionality

.gitignore

@@ -2,4 +2,5 @@
 .env
 data
 __pycache__/
-logs/
+logs/
+test.py

app.py

@@ -3,8 +3,20 @@ import os
 from application.services import streamlit_function, gemini_model
 from google.genai.errors import ClientError
 from application.utils import logger
+from application.schemas.response_schema import (
+    GEMINI_GHG_PARAMETERS, GEMINI_ENVIRONMENTAL_PARAMETERS_CSRD,
+    GEMINI_ENVIRONMENT_PARAMETERS, GEMINI_SOCIAL_PARAMETERS,
+    GEMINI_GOVERNANCE_PARAMETERS, GEMINI_MATERIALITY_PARAMETERS,
+    GEMINI_NET_ZERO_INTERVENTION_PARAMETERS, FULL_RESPONSE_SCHEMA
+)
+import test
 
 logger = logger.get_logger()
+streamlit_function.config_homepage()
+st.title("Sustainability Report Analyzer")
+st.write("Upload your sustainability report PDF and generate insights using different models.")
+
+MODEL = ["gemini-1.5-pro-latest", "gemini-2.0-flash", "gemini-1.5-flash", "gemini-2.5-exp"]
 
 MODEL_1 = "gemini-1.5-pro-latest"
 MODEL_2 = "gemini-2.0-flash"
@@ -14,8 +26,6 @@ API_1 = "gemini"
 API_2 = "gemini"
 API_3 = "gemini"
 
-streamlit_function.config_homepage()
-
 pdf_file = streamlit_function.upload_file("pdf", label="Upload Sustainability Report PDF")
 
 for key in [f"{MODEL_1}_result", f"{MODEL_2}_result", f"{MODEL_3}_result", "pdf_file"]:
@@ -28,13 +38,13 @@ if "excel_file" not in st.session_state:
 if st.session_state.pdf_file:
     with st.container():
         col1, col2, col3 = st.columns([5, 5, 5], gap="small")
-        file_name = st.session_state.pdf_file.name.removesuffix(".pdf")
+        file_name = st.session_state.pdf_file[0].name.removesuffix(".pdf")
         excel_file=None
 
         with col1:
             if st.button(f"Generate {MODEL_1} Response"):
                 with st.spinner(f"Calling {MODEL_1}..."):
-                    result = gemini_model.extract_emissions_data_as_json(API_1 , MODEL_1, st.session_state.pdf_file)
+                    result = gemini_model.extract_emissions_data_as_json(API_1 , MODEL_1, st.session_state.pdf_file[0],FULL_RESPONSE_SCHEMA)
                     excel_file = streamlit_function.export_results_to_excel(result, MODEL_1, file_name)
                     st.session_state[f"{MODEL_1}_result"] = result
             if st.session_state[f"{MODEL_1}_result"]:
@@ -44,7 +54,7 @@ if st.session_state.pdf_file:
         with col2:
             if st.button(f"Generate {MODEL_2} Response"):
                 with st.spinner(f"Calling {MODEL_2}..."):
-                    result = gemini_model.extract_emissions_data_as_json(API_2, MODEL_2, st.session_state.pdf_file)
+                    result = gemini_model.extract_emissions_data_as_json(API_2, MODEL_2, st.session_state.pdf_file[0],FULL_RESPONSE_SCHEMA)
                     excel_file = streamlit_function.export_results_to_excel(result, MODEL_2, file_name)
                     st.session_state[f"{MODEL_2}_result"] = result
             if st.session_state[f"{MODEL_2}_result"]:
@@ -55,7 +65,7 @@ if st.session_state.pdf_file:
             try:
                 if st.button(f"Generate {MODEL_3} Response"):
                     with st.spinner(f"Calling {MODEL_3}..."):
-                        result = gemini_model.extract_emissions_data_as_json(API_3, MODEL_3, st.session_state.pdf_file)
+                        result = gemini_model.extract_emissions_data_as_json(API_3, MODEL_3, st.session_state.pdf_file[0], FULL_RESPONSE_SCHEMA)
                         excel_file = streamlit_function.export_results_to_excel(result, MODEL_3, file_name)
                         st.session_state[f"{MODEL_3}_result"] = result
             except ClientError as e:
@@ -75,4 +85,4 @@ if st.session_state.pdf_file:
                 data=file,
                 file_name=f"{file_name}.xlsx",  
                 mime="application/vnd.openxmlformats-officedocument.spreadsheetml.sheet"
-            )
+            )

application/services/gemini_model.py

@@ -4,7 +4,6 @@ import re
 from typing import Optional, Dict, Union, IO, List, BinaryIO
 from google import genai
 from google.genai import types
-from application.schemas.response_schema import GEMINI_RESPONSE_FORMAT
 from application.utils import logger
 
 logger=logger.get_logger()
@@ -14,7 +13,20 @@ client = genai.Client(api_key=os.getenv("gemini_api_key"))
 PROMPT = (
     """You are a PDF parsing agent. Your job is to extract GHG Protocol Parameters 
     and ESG (Environmental, Social, Governance) Data from a company’s sustainability 
-    or ESG report in PDF format."""
+    or ESG report in PDF format.
+
+    You must extract the data based on a predefined response schema. It is critical 
+    that you return all keys specified in the schema, even if the value is not present 
+    or not found in the document. If a value is missing or unavailable, return a suitable 
+    placeholder according to the format used 
+    in the schema.
+
+    Your output should strictly follow the structure of the schema, ensuring completeness 
+    and consistency for downstream processing.
+
+    Be precise in extracting values and identifying relevant context from the PDF. Use 
+    surrounding text or tables to identify the most likely match for each field.
+    """
 )
 
 def sanitize_file_name(name: str, max_length: int = 40) -> str:
@@ -59,7 +71,6 @@ def get_files() -> List[str]:
     files = client.files.list()
     return [file.name for file in files]
 
-
 def delete_files(file_names: Union[str, List[str]]) -> None:
     """
     Deletes specified files from Gemini.
@@ -137,7 +148,8 @@ def upload_file(
 def extract_emissions_data_as_json(
     api: str,
     model: str,
-    file_input: Union[BinaryIO, bytes]
+    file_input: Union[BinaryIO, bytes],
+    response_schema
 ) -> Optional[dict]:
     """
     Extracts ESG data from a PDF using the Gemini API.
@@ -163,9 +175,15 @@ def extract_emissions_data_as_json(
             contents=[uploaded_file, PROMPT],
             config={
                 'response_mime_type': 'application/json',
-                'response_schema': GEMINI_RESPONSE_FORMAT
-            }
+                'response_schema': response_schema,
+            },
         )
+        if hasattr(response, 'usage_metadata'):
+            logger.info(f"Input tokens: {response.usage_metadata.prompt_token_count}")
+            logger.info(f"Output tokens: {response.usage_metadata.candidates_token_count}")
+            logger.info(f"Total tokens: {response.usage_metadata.total_token_count}")
+        else:
+            logger.info("Token usage metadata not available in response")
 
         logger.info("[Gemini] Response received.")
         try:

application/services/llm_service.py

@@ -151,8 +151,6 @@ def extract_emissions_data_as_json(
         logger.exception("Error during ESG data extraction.")
         return None
 
-# --- Debug Helper ---
-
 def list_all_files():
     """Lists all files currently uploaded to OpenAI."""
     try:
@@ -160,189 +158,4 @@ def list_all_files():
         for file in files:
             logger.info(f"File ID: {file.id}, Name: {file.filename}, Size: {file.bytes} bytes")
     except Exception as e:
-        logger.error(f"Failed to list files: {e}")
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-# import os
-# import json
-# from google import genai
-# from google.genai import types
-# from openai import OpenAI
-# from dotenv import load_dotenv
-# from application.utils import logger
-# import pandas as pd
-# import openpyxl
-
-# load_dotenv()
-# logger = logger.get_logger()
-
-
-
-# def load_schema_from_excel(file_path) -> str:
-#     df = pd.read_excel(file_path,engine='openpyxl')
-
-#     schema_lines = ["Schema fields and expected format:\n"]
-#     for _, row in df.iterrows():
-#         field = row.get("Field", "")
-#         description = row.get("Description", "")
-#         example = row.get("Example", "")
-#         schema_lines.append(f"- {field}: {description} (e.g., {example})")
-    
-#     return "\n".join(schema_lines)
-
-# schema_text = load_schema_from_excel("application/schemas/schema.xlsx")
-
-# # print(schema_text)
-
-# PROMPT = (f"""You are a PDF parsing agent. Your job is to extract GHG Protocol Parameters and ESG (Environmental, Social, Governance) Data from a company’s sustainability or ESG report in PDF format.
-#             Please return the response as raw JSON without markdown formatting (no triple backticks or json tags) using the following fields:
-#             Total GHG emissions (Metric Tons CO₂e)
-#             Scope 1, 2, and 3 emissions
-#             Emissions by gas (CO₂, CH₄, N₂O, HFCs, etc.)
-#             Energy and fuel consumption (MWh, GJ, Liters)
-#             Carbon offsets, intensity metrics, and reduction targets
-#             ESG disclosures including:
-#             Environmental Policies
-#             Whether the company has an Environmental Management System (EMS)
-#             Environmental certifications (if any)
-#             Ensure values include their units, are extracted accurately, and the fields match the schema provided below and If the value is zero replace it with null: 
-            
-#             {schema_text}
-
-#          """)
-
-# def extract_emissions_data_as_json(api, model, file_input):
-
-#     if api.lower()=="openai":
-
-#         client = OpenAI()
-
-#         file = client.files.create(
-#             file=("uploaded.pdf", file_input),
-#             purpose="assistants"
-#         )
-
-#         completion = client.chat.completions.create(
-#             model=model,
-#             messages=[
-#                 {
-#                     "role": "user",
-#                     "content": [
-#                         {
-#                             "type": "file",
-#                             "file": {
-#                                 "file_id": file.id,
-#                             }
-#                         },
-#                         {
-#                             "type": "text",
-#                             "text":PROMPT,
-#                         },
-#                     ]
-#                 }
-#             ]
-#         )
-
-#         try:
-#             return json.loads(completion.choices[0].message.content)
-#         except json.JSONDecodeError:
-#             logger.error("Warning: Output was not valid JSON.")
-#             return {"raw_response": completion.choices[0].message.content}
-        
-#     if api.lower()=="gemini":
-
-#         client = genai.Client(api_key=os.getenv('gemini_api_key'))
-
-#         file_bytes= file_input.read()
-#         response = client.models.generate_content(
-#         model=model,
-#         contents=[
-#             types.Part.from_bytes(
-#                 data=file_bytes,
-#                 mime_type='application/pdf',
-#             ),
-#             PROMPT])
-        
-#         try:
-#             return json.loads(response.text)
-#         except json.JSONDecodeError:
-#             return {"raw_response": response.text}
-    
-
-
-#                 # {
-#             # "type": "object",
-#             # "properties": {
-#             # "GHG_Protocol_Parameters": {
-#             #     "type": "object",
-#             #     "properties": {
-#             #     "Total_GHG_Emissions": { "type": "number" },
-#             #     "Scope_1_Emissions": { "type": "number" },
-#             #     "Scope_2_Emissions": { "type": "number" },
-#             #     "Scope_3_Emissions": { "type": "number" },
-#             #     "CO2_Emissions": { "type": "number" },
-#             #     "CH4_Emissions": { "type": "number" },
-#             #     "N2O_Emissions": { "type": "number" },
-#             #     "HFC_Emissions": { "type": "number" },
-#             #     "PFC_Emissions": { "type": "number" },
-#             #     "SF6_Emissions": { "type": "number" },
-#             #     "NF3_Emissions": { "type": "number" },
-#             #     "Biogenic_CO2_Emissions": { "type": "number" },
-#             #     "Emissions_Intensity_per_Revenue": { "type": "number" },
-#             #     "Emissions_Intensity_per_Employee": { "type": "number" },
-#             #     "Base_Year_Emissions": { "type": "number" },
-#             #     "Emissions_Reduction_Target": { "type": "number" },
-#             #     "Emissions_Reduction_Achieved": { "type": "number" },
-#             #     "Energy_Consumption": { "type": "number" },
-#             #     "Renewable_Energy_Consumption": { "type": "number" },
-#             #     "Non_Renewable_Energy_Consumption": { "type": "number" },
-#             #     "Energy_Intensity_per_Revenue": { "type": "number" },
-#             #     "Energy_Intensity_per_Employee": { "type": "number" },
-#             #     "Fuel_Consumption": { "type": "number" },
-#             #     "Electricity_Consumption": { "type": "number" },
-#             #     "Heat_Consumption": { "type": "number" },
-#             #     "Steam_Consumption": { "type": "number" },
-#             #     "Cooling_Consumption": { "type": "number" },
-#             #     "Purchased_Goods_and_Services_Emissions": { "type": "number" },
-#             #     "Capital_Goods_Emissions": { "type": "number" },
-#             #     "Fuel_and_Energy_Related_Activities_Emissions": { "type": "number" },
-#             #     "Upstream_Transportation_and_Distribution_Emissions": { "type": "number" },
-#             #     "Waste_Generated_in_Operations_Emissions": { "type": "number" },
-#             #     "Business_Travel_Emissions": { "type": "number" },
-#             #     "Employee_Commuting_Emissions": { "type": "number" },
-#             #     "Upstream_Leased_Assets_Emissions": { "type": "number" },
-#             #     "Downstream_Transportation_and_Distribution_Emissions": { "type": "number" },
-#             #     "Processing_of_Sold_Products_Emissions": { "type": "number" },
-#             #     "Use_of_Sold_Products_Emissions": { "type": "number" },
-#             #     "End_of_Life_Treatment_of_Sold_Products_Emissions": { "type": "number" },
-#             #     "Downstream_Leased_Assets_Emissions": { "type": "number" },
-#             #     "Franchises_Emissions": { "type": "number" },
-#             #     "Investments_Emissions": { "type": "number" },
-#             #     "Carbon_Offsets_Purchased": { "type": "number" },
-#             #     "Net_GHG_Emissions": { "type": "number" },
-#             #     "Carbon_Sequestration": { "type": "number" }
-#             #     }
-#             # },
-#             # "ESG_Parameters_CSRS": {
-#             #     "type": "object",
-#             #     "properties": {
-#             #     "Environmental_Policies": { "type": "string" },
-#             #     "Environmental_Management_System": { "type": "boolean" },
-#             #     "Environmental_Certifications": { "type": "string" }
-#             #     }
-#             # }
-#             # },
-#             # "required": ["GHG_Protocol_Parameters", "ESG_Parameters_CSRS"]}
+        logger.error(f"Failed to list files: {e}")

application/services/streamlit_function.py

@@ -4,6 +4,7 @@ import pandas as pd
 from io import BytesIO
 import json
 import os
+from openpyxl import load_workbook
 from application.utils import logger
 
 logger = logger.get_logger()
@@ -51,7 +52,7 @@ def upload_file(
     file_types: Union[str, List[str]] = "pdf",
     label: str = "📤 Upload a file",
     help_text: str = "Upload your file for processing.",
-    allow_multiple: bool = False,
+    allow_multiple: bool = True,
 ):
     """
     Streamlit file uploader widget with options.
@@ -78,8 +79,9 @@ def upload_file(
     if st.button("Submit"):
         st.session_state.pdf_file = uploaded_files
         return uploaded_files
+    
+def export_results_to_excel(results: dict, sheet_name: str, filename: str = "output.xlsx", column: str = None) -> BytesIO:
 
-def export_results_to_excel(results: dict, sheet_name: str, filename: str = "output.xlsx") -> BytesIO:
     """
     Converts a dictionary result into a formatted Excel file.
     Appends to a file in the 'data/' folder if it already exists,
@@ -94,34 +96,53 @@ def export_results_to_excel(results: dict, sheet_name: str, filename: str = "out
         BytesIO: In-memory Excel file for Streamlit download.
     """
     try:
-        df = pd.json_normalize(results, sep='_')
-        df.replace({None: "", "NULL": ""}, inplace=True)
-    except Exception as e:
-        df = pd.DataFrame([{"error": f"Could not parse result: {str(e)}"}])
+        if not results:
+            logger.error("Results object is None or empty.")
+            return None
+
+        filename = filename if filename.endswith(".xlsx") else f"{filename}.xlsx"
+        data = results.get(column, {})
+
+        logger.info(f"Exporting data for column '{column}' to {filename}")
+
+        if not isinstance(data, dict):
+            logger.error(f"Expected dictionary for column '{column}', but got {type(data)}")
+            return None
 
-    # Ensure correct file extension and path
-    filename = f"{filename}.xlsx" if not filename.endswith(".xlsx") else filename
-    full_path = os.path.join("data", filename)
+        df = pd.DataFrame(data.items(), columns=[column, "Value"])
+        df.fillna(0, inplace=True)
 
-    os.makedirs("data", exist_ok=True)  # Ensure the folder exists
+        os.makedirs("data", exist_ok=True)
+        physical_path = os.path.join("data", filename)
 
-    # Save to physical file
-    if os.path.exists(full_path):
-        with pd.ExcelWriter(full_path, engine="openpyxl", mode="a", if_sheet_exists="overlay") as writer:
-            book = writer.book
+        file_exists = os.path.exists(physical_path)
+        start_row = 0
+        start_column = 0
+
+        if file_exists:
+            book = load_workbook(physical_path)
             if sheet_name in book.sheetnames:
                 sheet = book[sheet_name]
                 start_row = sheet.max_row
+                start_column = sheet.max_column
             else:
                 start_row = 0
-            df.to_excel(writer, sheet_name=sheet_name, index=False, header=start_row == 0, startrow=start_row)
-    else:
-        df.to_excel(full_path, index=False, engine="openpyxl", sheet_name=sheet_name)
 
-    # Prepare in-memory Excel for download
-    output_stream = BytesIO()
-    with pd.ExcelWriter(output_stream, engine="openpyxl") as writer:
-        df.to_excel(writer, index=False, sheet_name=sheet_name)
-    output_stream.seek(0)
+        if file_exists:
+            with pd.ExcelWriter(physical_path, engine='openpyxl', mode='a', if_sheet_exists='overlay') as writer:
+                df.to_excel(writer, sheet_name=sheet_name, index=False, header=True, startrow=0, startcol=start_column)
+        else:
+            with pd.ExcelWriter(physical_path, engine='openpyxl', mode='w') as writer:
+                df.to_excel(writer, sheet_name=sheet_name, index=False, header=True, startrow=0)
+
+        output_stream = BytesIO()
+        with pd.ExcelWriter(output_stream, engine='openpyxl') as writer:
+            df.to_excel(writer, sheet_name=sheet_name, index=False)
 
-    return output_stream
+        output_stream.seek(0)
+        logger.info(f"Data exported to {filename} successfully.")
+        return output_stream
+
+    except Exception as e:
+        logger.error(f"Error creating Excel export: {e}")
+        return None

pages/multiple_pdf_extractor.py

@@ -0,0 +1,187 @@
+import streamlit as st
+import os
+from application.schemas.response_schema import (
+    GEMINI_GHG_PARAMETERS, GEMINI_ENVIRONMENTAL_PARAMETERS_CSRD,
+    GEMINI_ENVIRONMENT_PARAMETERS, GEMINI_SOCIAL_PARAMETERS,
+    GEMINI_GOVERNANCE_PARAMETERS, GEMINI_MATERIALITY_PARAMETERS,
+    GEMINI_NET_ZERO_INTERVENTION_PARAMETERS
+)
+from application.services import streamlit_function, gemini_model
+from application.utils import logger
+
+logger = logger.get_logger()
+streamlit_function.config_homepage()
+
+st.title("Sustainability Report Analyzer")
+st.write("Upload your sustainability report PDF and generate insights using Gemini models.")
+
+AVAILABLE_MODELS = [
+    "gemini-1.5-pro-latest",
+    "gemini-2.0-flash",
+    "gemini-1.5-flash",
+    "gemini-2.5-pro-exp-03-25"
+]
+
+RESPONSE_SCHEMAS = {
+    "Greenhouse Gas (GHG) Protocol Parameters": GEMINI_GHG_PARAMETERS,
+    "Environmental Parameters (CSRD)": GEMINI_ENVIRONMENTAL_PARAMETERS_CSRD,
+    "Environmental Parameters": GEMINI_ENVIRONMENT_PARAMETERS,
+    "Social Parameters": GEMINI_SOCIAL_PARAMETERS,
+    "Governance Parameters": GEMINI_GOVERNANCE_PARAMETERS,
+    "Materiality Parameters": GEMINI_MATERIALITY_PARAMETERS,
+    "Net Zero Intervention Parameters": GEMINI_NET_ZERO_INTERVENTION_PARAMETERS,
+}
+
+selected_model = st.selectbox("Select Gemini Model", options=AVAILABLE_MODELS)
+
+uploaded_files = streamlit_function.upload_file("pdf", label="📤 Upload Sustainability Report PDF")
+if uploaded_files:
+    st.session_state.uploaded_files = uploaded_files
+
+if "uploaded_files" not in st.session_state:
+    st.session_state.uploaded_files = []
+
+if st.session_state.uploaded_files:
+    columns = st.columns(3)
+
+    for i, pdf_file in enumerate(st.session_state.uploaded_files):
+        with columns[i % 3]:
+            file_name = pdf_file.name.removesuffix(".pdf")
+            st.write(f"📄 **File {i+1}:** `{pdf_file.name}`")
+
+            extract_btn = st.button(f"Extract Data from File {i+1}", key=f"extract_{i}")
+            result_key = f"{selected_model}_result_file_{i+1}"
+
+            if extract_btn:
+                with st.spinner(f"Extracting data from `{pdf_file.name}` using `{selected_model}`..."):
+                    try:
+                        all_results = {}
+                        
+                        for label, schema in RESPONSE_SCHEMAS.items():
+                            result = gemini_model.extract_emissions_data_as_json("gemini", selected_model, pdf_file, schema)
+                            streamlit_function.export_results_to_excel(result, sheet_name=selected_model, filename=file_name, column=label)
+                            all_results[label] = result
+                        st.session_state[result_key] = all_results
+                        st.success("Data extraction complete.")
+                    except Exception as e:
+                        logger.error(f"Extraction failed: {e}")
+                        st.error("Failed to extract data.")
+
+            if st.session_state.get(result_key):
+                st.write(f"🧾 **Extracted Metrics for File {i+1}:**")
+                st.json(st.session_state[result_key])
+
+        file_path = f"data/{file_name}.xlsx"
+
+    if os.path.exists(file_path):
+        with open(file_path, "rb") as file:
+            st.download_button(
+                label="Download Excel File",
+                data=file,
+                file_name=f"{file_name}.xlsx",  
+                mime="application/vnd.openxmlformats-officedocument.spreadsheetml.sheet"
+            )
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+# import streamlit as st
+# from application.schemas.response_schema import GEMINI_GHG_PARAMETERS, GEMINI_ENVIRONMENTAL_PARAMETERS_CSRD,GEMINI_ENVIRONMENT_PARAMETERS,GEMINI_SOCIAL_PARAMETERS, GEMINI_GOVERNANCE_PARAMETERS, GEMINI_MATERIALITY_PARAMETERS, GEMINI_NET_ZERO_INTERVENTION_PARAMETERS
+# from application.services import streamlit_function, gemini_model
+# from application.utils import logger
+# import test
+
+# logger = logger.get_logger()
+# streamlit_function.config_homepage()
+# st.title("Sustainability Report Analyzer")
+# st.write("Upload your sustainability report PDF and generate insights using different models.")
+
+# MODEL = ["gemini-1.5-pro-latest", "gemini-2.0-flash", "gemini-1.5-flash", "gemini-2.5-pro-exp-03-25"]
+
+# MODEL_1 = "gemini-1.5-pro-latest"
+# MODEL_2 = "gemini-2.0-flash"
+# MODEL_3 = "gemini-1.5-flash"
+
+# API_1 = "gemini"
+# API_2 = "gemini"
+# API_3 = "gemini"
+
+# response_schema = [ GEMINI_GHG_PARAMETERS, GEMINI_ENVIRONMENTAL_PARAMETERS_CSRD,
+#                     GEMINI_ENVIRONMENT_PARAMETERS,GEMINI_SOCIAL_PARAMETERS,
+#                     GEMINI_GOVERNANCE_PARAMETERS, GEMINI_MATERIALITY_PARAMETERS, 
+#                     GEMINI_NET_ZERO_INTERVENTION_PARAMETERS]
+
+# if "uploaded_files" not in st.session_state:
+#     st.session_state.uploaded_files = []
+
+# MODEL = st.selectbox(
+#     "Select Model",
+#     options=MODEL,
+#     index=0,
+# )
+
+# uploaded_files = streamlit_function.upload_file("pdf", label="Upload Sustainability Report PDF")
+
+# if uploaded_files:
+#     st.session_state.uploaded_files = uploaded_files
+
+# if st.session_state.uploaded_files:
+#     columns = st.columns([5, 5, 5], gap="small")
+
+#     for i, col in enumerate(columns):
+#         if i < len(st.session_state.uploaded_files):
+#             pdf_file = st.session_state.uploaded_files[i]
+#             file_name = pdf_file.name.removesuffix(".pdf")
+#             result_key = f"{MODEL}_result_file_{i+1}"
+
+#             with col:
+#                 st.write(f"**File {i+1}:** `{pdf_file.name}`")
+#                 if st.button(f"Extract Data from File {i+1}", key=f"extract_btn_{i}"):
+#                     with st.spinner(f"Extracting data from File {i+1} using {MODEL}..."):
+#                         for schema in response_schema:
+#                             result = gemini_model.extract_emissions_data_as_json(API_1, MODEL, pdf_file, schema)
+#                             if schema == GEMINI_GHG_PARAMETERS:
+#                                 column = "Greenhouse Gas (GHG) Protocol Parameters"
+#                             elif schema == GEMINI_ENVIRONMENTAL_PARAMETERS_CSRD:
+#                                 column = "Environmental Parameters (CSRD)"
+#                             elif schema == GEMINI_ENVIRONMENT_PARAMETERS:
+#                                 column = "Environmental Parameters"
+#                             elif schema == GEMINI_SOCIAL_PARAMETERS:
+#                                 column = "Social Parameters"
+#                             elif schema == GEMINI_GOVERNANCE_PARAMETERS:
+#                                 column = "Governance Parameters"
+#                             elif schema == GEMINI_MATERIALITY_PARAMETERS:
+#                                 column = "Materiality Parameters"
+#                             elif schema == GEMINI_NET_ZERO_INTERVENTION_PARAMETERS:
+#                                 column = "Net Zero Intervention Parameters"
+#                             else:
+#                                 column = None
+                            
+#                             test.export_results_to_excel(result, sheet_name=MODEL, filename=file_name, column=column )
+#                             st.session_state[result_key] = result
+
+#                 if st.session_state.get(result_key):
+#                     st.write(f"**Extracted Metrics for File {i+1}:**")
+#                     st.json(st.session_state[result_key])

test.py

@@ -0,0 +1,62 @@
+import os
+import pandas as pd
+from io import BytesIO
+from openpyxl import load_workbook
+from application.utils import logger
+
+logger = logger.get_logger()
+
+def export_results_to_excel(results: dict, sheet_name: str, filename: str = "output.xlsx", column: str = None) -> BytesIO:
+    try:
+        if not results:
+            logger.error("Results object is None or empty.")
+            return None
+
+        filename = filename if filename.endswith(".xlsx") else f"{filename}.xlsx"
+        data = results.get(column, {})
+
+        logger.info(f"Exporting data for column '{column}' to {filename}")
+
+        if not isinstance(data, dict):
+            logger.error(f"Expected dictionary for column '{column}', but got {type(data)}")
+            return None
+
+        df = pd.DataFrame(data.items(), columns=[column, "Value"])
+        df.fillna(0, inplace=True)
+
+        os.makedirs("data", exist_ok=True)
+        physical_path = os.path.join("data", filename)
+
+        file_exists = os.path.exists(physical_path)
+        start_row = 0
+        start_column = 0
+
+        if file_exists:
+            book = load_workbook(physical_path)
+            if sheet_name in book.sheetnames:
+                sheet = book[sheet_name]
+                start_row = sheet.max_row
+                start_column = sheet.max_column
+            else:
+                start_row = 0
+
+        if file_exists:
+            with pd.ExcelWriter(physical_path, engine='openpyxl', mode='a', if_sheet_exists='overlay') as writer:
+                df.to_excel(writer, sheet_name=sheet_name, index=False, header=True, startrow=0, startcol=start_column)
+        else:
+            with pd.ExcelWriter(physical_path, engine='openpyxl', mode='w') as writer:
+                df.to_excel(writer, sheet_name=sheet_name, index=False, header=True, startrow=0)
+
+        output_stream = BytesIO()
+        with pd.ExcelWriter(output_stream, engine='openpyxl') as writer:
+            df.to_excel(writer, sheet_name=sheet_name, index=False)
+
+        output_stream.seek(0)
+        logger.info(f"Data exported to {filename} successfully.")
+        return output_stream
+
+    except Exception as e:
+        logger.error(f"Error creating Excel export: {e}")
+        return None
+    
+# export_results_to_excel(zalando_data, "Zalando Data","test", "Greenhouse Gas (GHG) Protocol Parameters")