need to test all routes once again

.gitignore

@@ -0,0 +1,26 @@
+venv/
+.venv/
+.env
+__pycache__/
+*.pyc
+*.pyo
+*.pyd
+*.sqlite3
+*.db
+*.log
+*.bak
+*.swp
+*.tmp
+*.xlsx
+*.csv
+input/
+output*/
+csv_notes_pnl/
+generated_notes*/
+balancesheet_excel/
+cashflow_excel/
+pnl_excel/
+docker-compose.override.yml
+.vscode/
+app/__pycache__/
+pnlbs/__pycache__/

Dockerfile

@@ -0,0 +1,46 @@
+# Use Python 3.11 as base image (you can change to 3.9 if you want)
+FROM python:3.11-slim
+
+# -------------------------------
+# Set working directory
+WORKDIR /app
+
+# -------------------------------
+# Install system dependencies
+RUN apt-get update && apt-get install -y \
+    build-essential \
+    curl \
+    git \
+    && rm -rf /var/lib/apt/lists/*
+
+# -------------------------------
+# Copy requirements file
+COPY requirements.txt .
+
+# -------------------------------
+# Install Python dependencies
+RUN pip install --no-cache-dir -r requirements.txt
+
+# -------------------------------
+# Create necessary directories (customize as needed)
+RUN mkdir -p /app/input \
+    /app/output1 \
+    /app/generated_notes \
+    && chmod -R 777 /app/input /app/output1 /app/generated_notes
+
+# -------------------------------
+# Copy the application code
+COPY . /app/
+
+# -------------------------------
+# Set environment variables
+ENV PYTHONPATH=/app
+ENV PYTHONUNBUFFERED=1
+
+# -------------------------------
+# Expose the port the app runs on
+EXPOSE 8000
+
+# -------------------------------
+# Command to run the FastAPI app
+CMD ["uvicorn", "app.main:app", "--host", "0.0.0.0", "--port", "8000"]

app/api.py

@@ -0,0 +1,391 @@
+from fastapi import APIRouter, UploadFile, File, Form, HTTPException
+from fastapi.responses import JSONResponse, PlainTextResponse
+from typing import Optional, Dict, Any
+from app.notes import generate_notes
+from app.utils import clean_value
+import pandas as pd
+import os
+from app.pnl import generate_pnl_report
+import shutil
+from app.extract import extract_trial_balance_data, analyze_and_save_results
+from app.new_main import FlexibleFinancialNoteGenerator
+import json
+from app.main16_23 import process_json
+from app.json_xlsx import json_to_xlsx
+from app.utils_normalize import normalize_llm_note_json, normalize_llm_notes_json
+from app.bs import generate_balance_sheet_report
+from app.cashflow import generate_cashflow_report
+import subprocess
+import logging
+
+# Configure logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+router = APIRouter()
+
+def process_uploaded_file(file: UploadFile) -> pd.DataFrame:
+    """
+    Save uploaded file, extract trial balance, and return DataFrame.
+    """
+    os.makedirs("input", exist_ok=True)
+    file_location = f"input/{file.filename}"
+    with open(file_location, "wb") as buffer:
+        shutil.copyfileobj(file.file, buffer)
+    structured_data = extract_trial_balance_data(file_location)
+    output_file = "output1/parsed_trial_balance.json"
+    analyze_and_save_results(structured_data, output_file)
+    with open(output_file, "r", encoding="utf-8") as f:
+        parsed_data = json.load(f)
+    tb_df = pd.DataFrame(parsed_data if isinstance(parsed_data, list) else parsed_data.get("trial_balance", parsed_data))
+    tb_df['amount'] = tb_df['amount'].apply(clean_value)
+    return tb_df
+
+@router.post("/notes/json")
+async def post_notes_json(
+    file: UploadFile = File(...),
+    note_number: Optional[str] = Form(None)
+):
+    """
+    Generate notes as JSON from uploaded Excel file.
+    Optionally filter by note_number (comma-separated).
+    """
+    tb_df = process_uploaded_file(file)
+    notes = generate_notes(tb_df)
+    # Filter notes if note_number is provided
+    if note_number:
+        numbers = [n.strip() for n in note_number.split(",")]
+        notes = [note for note in notes if any(note['Note'].startswith(f"{n}.") or note['Note'] == n for n in numbers)]
+    return JSONResponse({"notes": notes})
+
+@router.post("/notes/text")
+async def post_notes_text(
+    file: UploadFile = File(...),
+    note_number: Optional[str] = Form(None)
+):
+    """
+    Generate notes as Markdown text from uploaded Excel file.
+    Optionally filter by note_number (comma-separated).
+    """
+    tb_df = process_uploaded_file(file)
+    notes = generate_notes(tb_df)
+    # Filter notes if note_number is provided
+    if note_number:
+        numbers = [n.strip() for n in note_number.split(",")]
+        notes = [note for note in notes if any(note['Note'].startswith(f"{n}.") or note['Note'] == n for n in numbers)]
+    # Build markdown string
+    md = "# Notes to Financial Statements for the Year Ended March 31, 2024\n\n"
+    for note in notes:
+        md += f"## {note['Note']}\n\n{note['Content']}\n\n"
+    return PlainTextResponse(md, media_type="text/plain")
+
+@router.post("/cf")
+async def generate_cashflow():
+    """
+    Generate Cash Flow Statement Excel file.
+    """
+    try:
+        generate_cashflow_report()
+        return {"message": "Cash Flow report generated successfully as 'cashflow_excel/cashflow_report.xlsx'."}
+    except Exception as e:
+        logger.error(f"Failed to generate Cash Flow report: {str(e)}")
+        return {"error": f"Failed to generate Cash Flow report: {str(e)}"}
+    
+
+@router.post("/bs")
+async def generate_balancesheet():
+    """
+    Generate Balance Sheet Excel file.
+    """
+    try:
+        generate_balance_sheet_report()
+        return {"message": "Balance Sheet report generated successfully as 'balancesheet_excel/balancesheet_report.xlsx'."}
+    except Exception as e:
+        logger.error(f"Failed to generate Balance Sheet: {str(e)}")
+        return {"error": f"Failed to generate Balance Sheet: {str(e)}"}
+
+@router.post("/pnl")
+async def generate_pnl():
+    """
+    Generate Profit & Loss Excel file.
+    """
+    try:
+        generate_pnl_report()
+        return {"message": "P&L report generated successfully as 'pnl_excel/pnl_report.xlsx'."}
+    except Exception as e:
+        logger.error(f"Failed to generate P&L report: {str(e)}")
+        return {"error": f"Failed to generate P&L report: {str(e)}"}
+    
+    
+@router.post("/new")
+async def llm_generate_and_excel(
+    file: UploadFile = File(...),
+    note_number: Optional[str] = Form(None)
+):
+    """
+    Generate notes using LLM and save as Excel.
+    Optionally filter by note_number (comma-separated).
+    """
+    os.makedirs("input", exist_ok=True)
+    file_location = f"input/{file.filename}"
+    with open(file_location, "wb") as buffer:
+        shutil.copyfileobj(file.file, buffer)
+
+    # Extract trial balance and save as JSON
+    structured_data = extract_trial_balance_data(file_location)
+    output_json = "output1/parsed_trial_balance.json"
+    analyze_and_save_results(structured_data, output_json)
+
+    # Initialize the generator
+    try:
+        generator = FlexibleFinancialNoteGenerator()
+    except Exception as e:
+        logger.error(f"Generator init failed: {e}")
+        raise HTTPException(status_code=500, detail=f"Generator init failed: {e}")
+
+    os.makedirs("generated_notes_excel", exist_ok=True)
+    wrapped_json_path = "generated_notes/notes_wrapped.json"
+
+    if note_number:
+        # Support multiple note numbers (comma-separated)
+        note_numbers = [n.strip() for n in note_number.split(",")]
+        all_notes = []
+        for n in note_numbers:
+            success = generator.generate_note(n, trial_balance_path=output_json)
+            if success:
+                # Read the just-generated note
+                with open("generated_notes/notes.json", "r", encoding="utf-8") as f:
+                    note_json = json.load(f)
+                all_notes.append(note_json)
+        # Now write all notes together
+        with open("generated_notes/notes.json", "w", encoding="utf-8") as f:
+            json.dump({"notes": all_notes}, f, indent=2, ensure_ascii=False)
+        # --- Normalize all notes ---
+        wrapped = normalize_llm_notes_json({"notes": all_notes})
+        with open(wrapped_json_path, "w", encoding="utf-8") as f2:
+            json.dump(wrapped, f2, ensure_ascii=False, indent=2)
+        # --------------------------
+        excel_path = "generated_notes_excel/notes.xlsx"
+        json_to_xlsx(wrapped_json_path, excel_path)
+        return {"message": f"Notes {', '.join(note_numbers)} generated. Excel saved at {excel_path}."}
+    else:
+        # Generate all notes
+        results = generator.generate_all_notes(trial_balance_path=output_json)
+        if not any(results.values()):
+            logger.error("Failed to generate any notes. LLM API may be down or unreachable.")
+            raise HTTPException(status_code=500, detail="Failed to generate any notes. LLM API may be down or unreachable.")
+        # Read all notes.json
+        with open("generated_notes/notes.json", "r", encoding="utf-8") as f:
+            notes_json = json.load(f)
+        # --- Normalize all notes ---
+        wrapped = normalize_llm_notes_json(notes_json)
+        with open(wrapped_json_path, "w", encoding="utf-8") as f2:
+            json.dump(wrapped, f2, ensure_ascii=False, indent=2)
+        # --------------------------
+        excel_path = "generated_notes_excel/notes.xlsx"
+        json_to_xlsx(wrapped_json_path, excel_path)
+        return {"message": f"All notes generated. Excel saved at {excel_path}."}
+        
+
+
+@router.post("/hardcoded")
+async def run_full_pipeline(
+    file: UploadFile = File(...),
+    note_number: Optional[str] = Form(None)
+):
+    """
+    Run the full hardcoded pipeline: extract, process, filter, and convert to Excel.
+    Optionally filter by note_number (comma-separated).
+    """
+    os.makedirs("input", exist_ok=True)
+    file_location = f"input/{file.filename}"
+    with open(file_location, "wb") as buffer:
+        shutil.copyfileobj(file.file, buffer)
+
+    # Run extract.py logic and save to output1
+    os.makedirs("output1", exist_ok=True)
+    structured_data = extract_trial_balance_data(file_location)
+    output1_json = "output1/parsed_trial_balance.json"
+    analyze_and_save_results(structured_data, output1_json)
+
+    # Run main16-23.py logic and save to output2
+    os.makedirs("output2", exist_ok=True)
+    try:
+        process_json(output1_json)
+    except ImportError:
+        logger.error("main16_23.process_json not found. Please ensure 'app/main16_23.py' exists and is named correctly.")
+        raise HTTPException(status_code=500, detail="main16_23.process_json not found. Please ensure 'app/main16_23.py' exists and is named correctly.")
+    except Exception as e:
+        logger.error(f"main16_23.process_json failed: {e}")
+        raise HTTPException(status_code=500, detail=f"main16_23.process_json failed: {e}")
+
+    # Filter notes if note_number is provided
+    notes_json = "output2/notes_output.json"
+    with open(notes_json, "r", encoding="utf-8") as f:
+        notes_data = json.load(f)
+
+    # If notes_data is a dict with a key (e.g. "notes"), extract the list
+    if isinstance(notes_data, dict):
+        for key in ["notes", "trial_balance"]:
+            if key in notes_data:
+                notes_data = notes_data[key]
+                break
+
+    # Always wrap as dict for Excel conversion
+    def wrap_notes(notes):
+        return {"notes": notes}
+
+    # Filter notes if note_number is provided
+    if note_number:
+        numbers = [n.strip() for n in note_number.split(",")]
+        notes_data = [
+            note for note in notes_data
+            if str(note.get('note_number', '')).strip() in numbers
+        ]
+        filtered_json = "output2/notes_output_filtered.json"
+        with open(filtered_json, "w", encoding="utf-8") as f2:
+            json.dump(wrap_notes(notes_data), f2, ensure_ascii=False, indent=2)
+        json_input_for_excel = filtered_json
+    else:
+        temp_json = "output2/notes_output_wrapped.json"
+        with open(temp_json, "w", encoding="utf-8") as f2:
+            json.dump(wrap_notes(notes_data), f2, ensure_ascii=False, indent=2)
+        json_input_for_excel = temp_json
+
+    # Run json-xlsx.py logic and save to output3
+    os.makedirs("output3", exist_ok=True)
+    try:
+        output3_xlsx = "output3/final_output.xlsx"
+        json_to_xlsx(json_input_for_excel, output3_xlsx)
+    except ImportError:
+        logger.error("json_xlsx.json_to_xlsx not found")
+        raise HTTPException(status_code=500, detail="json_xlsx.json_to_xlsx not found")
+    except Exception as e:
+        logger.error(f"json_xlsx.json_to_xlsx failed: {e}")
+        raise HTTPException(status_code=500, detail=f"json_xlsx.json_to_xlsx failed: {e}")
+
+    return {"message": "Pipeline completed successfully. Excel file saved in output3."}
+
+def run_subprocess(
+    script_path: str,
+    args: list,
+    env: Dict[str, str],
+    cwd: str
+) -> subprocess.CompletedProcess:
+    """
+    Run a subprocess and return the result.
+    Raises HTTPException on failure.
+    """
+    try:
+        logger.info(f"Running {script_path} with args {args} in {cwd}")
+        result = subprocess.run(
+            ["python", script_path] + args,
+            capture_output=True,
+            text=True,
+            check=True,
+            env=env,
+            cwd=cwd
+        )
+        logger.debug(f"{script_path} STDOUT:\n{result.stdout}")
+        logger.debug(f"{script_path} STDERR:\n{result.stderr}")
+        return result
+    except subprocess.CalledProcessError as e:
+        logger.error(f"{script_path} failed: {e}")
+        logger.error(f"STDOUT: {e.stdout}")
+        logger.error(f"STDERR: {e.stderr}")
+        raise HTTPException(
+            status_code=500,
+            detail=f"{script_path} failed: {e}\nSTDOUT:\n{e.stdout}\nSTDERR:\n{e.stderr}"
+        )
+
+
+def extract_output_file(stdout: str, keyword: str = "Output file:") -> Optional[str]:
+    """
+    Extract output file path from subprocess stdout.
+    """
+    for line in stdout.splitlines():
+        if keyword in line:
+            return line.split(keyword)[-1].strip()
+    return None
+
+
+
+
+@router.post("/bs_from_notes")
+async def bs_from_notes(file: UploadFile = File(...)):
+    """
+    Accepts an Excel file, runs the full pipeline (sircodebs.py -> csv_json_bs.py -> bl_llm.py),
+    and returns the path to the generated balance sheet Excel file.
+    """
+    os.makedirs("input", exist_ok=True)
+    input_excel_path = os.path.join("input", file.filename)
+    with open(input_excel_path, "wb") as buffer:
+        shutil.copyfileobj(file.file, buffer)
+    logger.info(f"Uploaded Excel saved to: {input_excel_path}")
+    logger.info(f"Files in input/: {os.listdir('input')}")
+
+    env = os.environ.copy()
+    if os.getenv("OPENROUTER_API_KEY"):
+        env["OPENROUTER_API_KEY"] = os.getenv("OPENROUTER_API_KEY")
+    env["INPUT_FILE"] = "clean_financial_data_bs.json"
+    cwd = "C:/SAHIL/NOTES"
+
+    # Run sircodebs.py
+    run_subprocess("pnlbs/sircodebs.py", [input_excel_path], env, cwd)
+    logger.info(f"Files in csv_notes_bs/: {os.listdir('csv_notes_bs') if os.path.exists('csv_notes_bs') else 'csv_notes_bs does not exist'}")
+
+    # Run csv_json_bs.py
+    run_subprocess("pnlbs/csv_json_bs.py", [], env, cwd)
+    logger.info(f"clean_financial_data_bs.json exists: {os.path.exists('clean_financial_data_bs.json')}")
+
+    # Run bl_llm.py
+    result = run_subprocess("pnlbs/bl_llm.py", [], env, cwd)
+    output_file = extract_output_file(result.stdout)
+    if not output_file or not os.path.exists(output_file):
+        debug_msg = f"\nSTDOUT:\n{result.stdout}\nSTDERR:\n{result.stderr}"
+        logger.error(f"Could not determine output file from bl_llm.py output.{debug_msg}")
+        raise HTTPException(status_code=500, detail=f"Could not determine output file from bl_llm.py output.{debug_msg}")
+
+    logger.info(f"Pipeline completed. Output file: {output_file}")
+    return {"message": "Balance Sheet generated successfully.", "file": output_file}
+
+
+
+
+@router.post("/pnl_from_notes")
+async def pnl_from_notes(file: UploadFile = File(...)):
+    """
+    Accepts an Excel file, runs the full pipeline (sircodepnl.py -> csv_json_pnl.py -> pnl_note.py),
+    and returns the path to the generated P&L Excel file.
+    """
+    os.makedirs("input", exist_ok=True)
+    input_excel_path = os.path.join("input", file.filename)
+    with open(input_excel_path, "wb") as buffer:
+        shutil.copyfileobj(file.file, buffer)
+    logger.info(f"Uploaded Excel saved to: {input_excel_path}")
+    logger.info(f"Files in input/: {os.listdir('input')}")
+
+    env = os.environ.copy()
+    if os.getenv("OPENROUTER_API_KEY"):
+        env["OPENROUTER_API_KEY"] = os.getenv("OPENROUTER_API_KEY")
+    env["INPUT_FILE"] = "clean_financial_data_pnl.json"
+    cwd = "C:/SAHIL/NOTES"
+
+    # Run sircodepnl.py
+    run_subprocess("pnlbs/sircodepnl.py", [input_excel_path], env, cwd)
+    logger.info(f"Files in csv_notes_pnl/: {os.listdir('csv_notes_pnl') if os.path.exists('csv_notes_pnl') else 'csv_notes_pnl does not exist'}")
+
+    # Run csv_json_pnl.py
+    run_subprocess("pnlbs/csv_json_pnl.py", [], env, cwd)
+    logger.info(f"clean_financial_data_pnl.json exists: {os.path.exists('clean_financial_data_pnl.json')}")
+
+    # Run pnl_note.py
+    result = run_subprocess("pnlbs/pnl_note.py", [], env, cwd)
+    output_file = extract_output_file(result.stdout)
+    if not output_file or not os.path.exists(output_file):
+        debug_msg = f"\nSTDOUT:\n{result.stdout}\nSTDERR:\n{result.stderr}"
+        logger.error(f"Could not determine output file from pnl_note.py output.{debug_msg}")
+        raise HTTPException(status_code=500, detail=f"Could not determine output file from pnl_note.py output.{debug_msg}")
+
+    logger.info(f"Pipeline completed. Output file: {output_file}")
+    return {"message": "Profit and Loss statement generated successfully.", "file": output_file}

app/bs.py

@@ -0,0 +1,314 @@
+import os
+import json
+import logging
+from typing import Optional, Dict, Any
+from openpyxl import Workbook
+from openpyxl.styles import Font, Border, Side, Alignment
+
+# Configure logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+# Configuration (externalized via environment variables)
+BALANCE_SHEET_OUTPUT_FOLDER = os.getenv("BALANCE_SHEET_OUTPUT_FOLDER", "balancesheet_excel")
+BALANCE_SHEET_OUTPUT_FILE = os.getenv("BALANCE_SHEET_OUTPUT_FILE", "balancesheet_report.xlsx")
+
+def load_note_data(note_number: str, folder: Optional[str] = None) -> Optional[Dict[str, Any]]:
+    """
+    Load note data for a specific note_number from notes.json in the specified folder.
+    Returns the note dict or None if not found.
+    """
+    folder = folder or os.path.join(os.path.dirname(os.path.dirname(__file__)), "generated_notes")
+    file_path = os.path.join(folder, "notes.json")
+    try:
+        with open(file_path, "r", encoding="utf-8") as f:
+            data = json.load(f)
+            notes = data.get("notes", [])
+            for note in notes:
+                n_num = note.get("note_number") or note.get("metadata", {}).get("note_number")
+                if str(n_num) == str(note_number):
+                    return note
+            logger.warning(f"Note {note_number} not found in {file_path}")
+    except (FileNotFoundError, json.JSONDecodeError) as e:
+        logger.error(f"Error loading note {note_number}: {e}")
+    return None
+
+def extract_total_from_note(note_data: Optional[Dict[str, Any]], year: str = "2024") -> float:
+    """
+    Extract total value from note data for the specified year.
+    Returns 0.0 if not found or invalid.
+    """
+    if not note_data or "structure" not in note_data:
+        return 0.0
+    for category in note_data["structure"]:
+        if year == "2024" and "total" in category:
+            try:
+                value = float(category["total"])
+                if value > 100000:
+                    value = value / 100000
+                return value
+            except (ValueError, TypeError):
+                continue
+        elif year == "2023" and "previous_total" in category:
+            try:
+                value = float(category["previous_total"])
+                if value > 100000:
+                    value = value / 100000
+                return value
+            except (ValueError, TypeError):
+                continue
+    # If no total found, sum up subcategory values
+    total = 0.0
+    for category in note_data["structure"]:
+        if "subcategories" in category:
+            for subcat in category["subcategories"]:
+                if year == "2024" and "value" in subcat:
+                    try:
+                        value = float(subcat["value"])
+                        if value > 100000:
+                            value = value / 100000
+                        total += value
+                    except (ValueError, TypeError):
+                        continue
+                elif year == "2023" and "previous_value" in subcat:
+                    try:
+                        value = float(subcat["previous_value"])
+                        if value > 100000:
+                            value = value / 100000
+                        total += value
+                    except (ValueError, TypeError):
+                        continue
+    return total
+
+def extract_specific_value(note_data: Optional[Dict[str, Any]], key: str, year: str = "2024") -> float:
+    """
+    Extract specific value from note data based on key and year.
+    Returns 0.0 if not found or invalid.
+    """
+    if not note_data or "structure" not in note_data:
+        return 0.0
+    for category in note_data["structure"]:
+        if "subcategories" in category:
+            for subcat in category["subcategories"]:
+                label = subcat.get("label", "").lower().replace(" ","").replace("-","").replace("/","").replace("&","")
+                if key.lower() in label:
+                    if year == "2024" and "value" in subcat:
+                        try:
+                            value = float(subcat["value"])
+                            if value > 100000:
+                                value = value / 100000
+                            return value
+                        except (ValueError, TypeError):
+                            continue
+                    elif year == "2023" and "previous_value" in subcat:
+                        try:
+                            value = float(subcat["previous_value"])
+                            if value > 100000:
+                                value = value / 100000
+                            return value
+                        except (ValueError, TypeError):
+                            continue
+    return 0.0
+
+def format_currency(value: float) -> str:
+    """
+    Format currency value for display.
+    """
+    if isinstance(value, (int, float)) and value != 0:
+        return f"{value:,.2f}"
+    return "0.00"
+
+def generate_balance_sheet_report() -> None:
+    """
+    Generate Balance Sheet report in Excel format using data from generated_notes folder.
+    Output location is configurable via environment variables.
+    """
+    wb = Workbook()
+    ws = wb.active
+    ws.title = "Balance Sheet"
+
+    # Define styles
+    bold_font = Font(bold=True)
+    thin_border = Border(left=Side(style="thin"), right=Side(style="thin"),
+                        top=Side(style="thin"), bottom=Side(style="thin"))
+    center_align = Alignment(horizontal="center")
+    left_align = Alignment(horizontal="left")
+    right_align = Alignment(horizontal="right")
+
+    # Set column widths
+    ws.column_dimensions["A"].width = 50
+    ws.column_dimensions["B"].width = 10
+    ws.column_dimensions["C"].width = 20
+    ws.column_dimensions["D"].width = 20
+
+    # Header
+    ws["A1"] = "Balance Sheet as at March 31, 2024"
+    ws["A1"].font = bold_font
+    ws.merge_cells("A1:D1")
+    ws["A1"].alignment = center_align
+
+    # Units
+    ws["A2"] = "In Lakhs"
+    ws.merge_cells("A2:D2")
+    ws["A2"].alignment = right_align
+
+    # Table headers
+    headers = ["", "Notes", "March 31, 2024", "March 31, 2023"]
+    for col, header in enumerate(headers, 1):
+        cell = ws.cell(row=4, column=col)
+        cell.value = header
+        cell.font = bold_font
+        cell.border = thin_border
+        cell.alignment = center_align if col > 1 else left_align
+
+    # Load all required notes (2-15 for Balance Sheet)
+    notes_data = {str(note_num): load_note_data(str(note_num)) for note_num in range(2, 16)}
+
+    # Extract values from notes
+    share_capital_2024 = extract_total_from_note(notes_data.get("2"), "2024")
+    share_capital_2023 = extract_total_from_note(notes_data.get("2"), "2023")
+    reserves_surplus_2024 = extract_total_from_note(notes_data.get("3"), "2024")
+    reserves_surplus_2023 = extract_total_from_note(notes_data.get("3"), "2023")
+    long_term_borrowings_2024 = extract_total_from_note(notes_data.get("4"), "2024")
+    long_term_borrowings_2023 = extract_total_from_note(notes_data.get("4"), "2023")
+    deferred_tax_liability_2024 = extract_total_from_note(notes_data.get("5"), "2024")
+    deferred_tax_liability_2023 = extract_total_from_note(notes_data.get("5"), "2023")
+    trade_payables_2024 = extract_total_from_note(notes_data.get("6"), "2024")
+    trade_payables_2023 = extract_total_from_note(notes_data.get("6"), "2023")
+    other_current_liabilities_2024 = extract_total_from_note(notes_data.get("7"), "2024")
+    other_current_liabilities_2023 = extract_total_from_note(notes_data.get("7"), "2023")
+    short_term_provisions_2024 = extract_total_from_note(notes_data.get("8"), "2024")
+    short_term_provisions_2023 = extract_total_from_note(notes_data.get("8"), "2023")
+    fixed_assets_2024 = extract_total_from_note(notes_data.get("9"), "2024")
+    fixed_assets_2023 = extract_total_from_note(notes_data.get("9"), "2023")
+    long_term_loans_advances_2024 = extract_total_from_note(notes_data.get("10"), "2024")
+    long_term_loans_advances_2023 = extract_total_from_note(notes_data.get("10"), "2023")
+    inventories_2024 = extract_total_from_note(notes_data.get("11"), "2024")
+    inventories_2023 = extract_total_from_note(notes_data.get("11"), "2023")
+    trade_receivables_2024 = extract_total_from_note(notes_data.get("12"), "2024")
+    trade_receivables_2023 = extract_total_from_note(notes_data.get("12"), "2023")
+    cash_bank_balances_2024 = extract_total_from_note(notes_data.get("13"), "2024")
+    cash_bank_balances_2023 = extract_total_from_note(notes_data.get("13"), "2023")
+    short_term_loans_advances_2024 = extract_total_from_note(notes_data.get("14"), "2024")
+    short_term_loans_advances_2023 = extract_total_from_note(notes_data.get("14"), "2023")
+    other_current_assets_2024 = extract_total_from_note(notes_data.get("15"), "2024")
+    other_current_assets_2023 = extract_total_from_note(notes_data.get("15"), "2023")
+
+    # Calculate totals
+    shareholders_funds_2024 = share_capital_2024 + reserves_surplus_2024
+    shareholders_funds_2023 = share_capital_2023 + reserves_surplus_2023
+    non_current_liabilities_2024 = long_term_borrowings_2024 + deferred_tax_liability_2024
+    non_current_liabilities_2023 = long_term_borrowings_2023 + deferred_tax_liability_2023
+    current_liabilities_2024 = trade_payables_2024 + other_current_liabilities_2024 + short_term_provisions_2024
+    current_liabilities_2023 = trade_payables_2023 + other_current_liabilities_2023 + short_term_provisions_2023
+    total_equity_liabilities_2024 = shareholders_funds_2024 + non_current_liabilities_2024 + current_liabilities_2024
+    total_equity_liabilities_2023 = shareholders_funds_2023 + non_current_liabilities_2023 + current_liabilities_2023
+    non_current_assets_2024 = fixed_assets_2024 + long_term_loans_advances_2024
+    non_current_assets_2023 = fixed_assets_2023 + long_term_loans_advances_2023
+    current_assets_2024 = (inventories_2024 + trade_receivables_2024 + cash_bank_balances_2024 +
+                          short_term_loans_advances_2024 + other_current_assets_2024)
+    current_assets_2023 = (inventories_2023 + trade_receivables_2023 + cash_bank_balances_2023 +
+                          short_term_loans_advances_2023 + other_current_assets_2023)
+    total_assets_2024 = non_current_assets_2024 + current_assets_2024
+    total_assets_2023 = non_current_assets_2023 + current_assets_2023
+
+    # Balance Sheet line items
+    line_items = [
+        # Equity and Liabilities
+        {"label": "Equity and liabilities", "note": "", "value_2024": "", "value_2023": "", "is_header": True},
+        {"label": "Shareholders' funds", "note": "", "value_2024": "", "value_2023": "", "is_subheader": True},
+        {"label": "Share capital", "note": "2", "value_2024": share_capital_2024, "value_2023": share_capital_2023},
+        {"label": "Reserves and surplus", "note": "3", "value_2024": reserves_surplus_2024, "value_2023": reserves_surplus_2023},
+        {"label": "", "note": "", "value_2024": shareholders_funds_2024, "value_2023": shareholders_funds_2023, "is_total": True},
+        
+        {"label": "Non-Current liabilities", "note": "", "value_2024": "", "value_2023": "", "is_subheader": True},
+        {"label": "Long term borrowings", "note": "4", "value_2024": long_term_borrowings_2024, "value_2023": long_term_borrowings_2023},
+        {"label": "Deferred Tax Liability (Net)", "note": "5", "value_2024": deferred_tax_liability_2024, "value_2023": deferred_tax_liability_2023},
+        {"label": "", "note": "", "value_2024": non_current_liabilities_2024, "value_2023": non_current_liabilities_2023, "is_total": True},
+        
+        {"label": "Current liabilities", "note": "", "value_2024": "", "value_2023": "", "is_subheader": True},
+        {"label": "Trade payables", "note": "6", "value_2024": trade_payables_2024, "value_2023": trade_payables_2023},
+        {"label": "Other current liabilities", "note": "7", "value_2024": other_current_liabilities_2024, "value_2023": other_current_liabilities_2023},
+        {"label": "Short term provisions", "note": "8", "value_2024": short_term_provisions_2024, "value_2023": short_term_provisions_2023},
+        {"label": "", "note": "", "value_2024": current_liabilities_2024, "value_2023": current_liabilities_2023, "is_total": True},
+        
+        {"label": "TOTAL", "note": "", "value_2024": total_equity_liabilities_2024, "value_2023": total_equity_liabilities_2023, "is_grand_total": True},
+        
+        # Assets
+        {"label": "", "note": "", "value_2024": "", "value_2023": "", "is_spacer": True},
+        {"label": "Assets", "note": "", "value_2024": "", "value_2023": "", "is_header": True},
+        {"label": "Non-current assets", "note": "", "value_2024": "", "value_2023": "", "is_subheader": True},
+        {"label": "Fixed assets", "note": "9", "value_2024": fixed_assets_2024, "value_2023": fixed_assets_2023},
+        {"label": "Long Term Loans and Advances", "note": "10", "value_2024": long_term_loans_advances_2024, "value_2023": long_term_loans_advances_2023},
+        {"label": "", "note": "", "value_2024": non_current_assets_2024, "value_2023": non_current_assets_2023, "is_total": True},
+        
+        {"label": "Current assets", "note": "", "value_2024": "", "value_2023": "", "is_subheader": True},
+        {"label": "Inventories", "note": "11", "value_2024": inventories_2024, "value_2023": inventories_2023},
+        {"label": "Trade receivables", "note": "12", "value_2024": trade_receivables_2024, "value_2023": trade_receivables_2023},
+        {"label": "Cash and bank balances", "note": "13", "value_2024": cash_bank_balances_2024, "value_2023": cash_bank_balances_2023},
+        {"label": "Short-term loans and advances", "note": "14", "value_2024": short_term_loans_advances_2024, "value_2023": short_term_loans_advances_2023},
+        {"label": "Other current assets", "note": "15", "value_2024": other_current_assets_2024, "value_2023": other_current_assets_2023},
+        {"label": "", "note": "", "value_2024": current_assets_2024, "value_2023": current_assets_2023, "is_total": True},
+        
+        {"label": "TOTAL", "note": "", "value_2024": total_assets_2024, "value_2023": total_assets_2023, "is_grand_total": True}
+    ]
+
+    # Write line items to Excel
+    row = 5
+    for item in line_items:
+        # Skip spacer rows
+        if item.get("is_spacer"):
+            row += 1
+            continue
+            
+        ws.cell(row=row, column=1).value = item["label"]
+        ws.cell(row=row, column=2).value = item["note"]
+        
+        # Format values
+        ws.cell(row=row, column=3).value = "" if item["value_2024"] == "" else format_currency(item["value_2024"])
+        ws.cell(row=row, column=4).value = "" if item["value_2023"] == "" else format_currency(item["value_2023"])
+        
+        # Apply formatting
+        for col in range(1, 5):
+            ws.cell(row=row, column=col).border = thin_border
+            ws.cell(row=row, column=col).alignment = center_align if col > 1 else left_align
+            
+            # Apply special formatting based on item type
+            if item.get("is_header") or item.get("is_grand_total"):
+                ws.cell(row=row, column=col).font = bold_font
+            elif item.get("is_subheader"):
+                ws.cell(row=row, column=col).font = bold_font
+            elif item.get("is_total"):
+                ws.cell(row=row, column=col).font = bold_font
+        
+        row += 1
+
+    # Add footer note
+    row += 1
+    ws.cell(row=row, column=1).value = "The accompanying notes are an integral part of the financial statements."
+    ws.cell(row=row, column=1).alignment = left_align
+    row += 1
+    ws.cell(row=row, column=1).value = "As per my report of even date."
+    ws.cell(row=row, column=1).alignment = left_align
+    ws.cell(row=row, column=4).value = "For and on behalf of the Board of Directors"
+    ws.cell(row=row, column=4).alignment = center_align
+
+    # Save Excel file with error handling
+    try:
+        os.makedirs(BALANCE_SHEET_OUTPUT_FOLDER, exist_ok=True)
+        output_file = os.path.join(BALANCE_SHEET_OUTPUT_FOLDER, BALANCE_SHEET_OUTPUT_FILE)
+        wb.save(output_file)
+        logger.info(f"Balance Sheet report generated successfully and saved to {output_file}")
+    except PermissionError:
+        logger.error(f"PermissionError: Unable to save to {output_file}. Trying alternative location...")
+        fallback_file = os.path.join(os.path.expanduser("~"), "Desktop", "balance_sheet_report_fallback.xlsx")
+        try:
+            wb.save(fallback_file)
+            logger.info(f"Balance Sheet report saved to alternative location: {fallback_file}")
+        except Exception as e:
+            logger.error(f"Failed to save Balance Sheet report: {str(e)}")
+    except Exception as e:
+        logger.error(f"Error saving Balance Sheet report: {str(e)}")
+
+if __name__ == "__main__":
+    generate_balance_sheet_report()

app/cashflow.py

@@ -0,0 +1,362 @@
+import os
+import json
+import logging
+from typing import Optional, Dict, Any
+from openpyxl import Workbook
+from openpyxl.styles import Font, Border, Side, Alignment
+
+# Configure logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+# Configuration (externalized via environment variables)
+CASHFLOW_OUTPUT_FOLDER = os.getenv("CASHFLOW_OUTPUT_FOLDER", "cashflow_excel")
+CASHFLOW_OUTPUT_FILE = os.getenv("CASHFLOW_OUTPUT_FILE", "cashflow_report.xlsx")
+
+def load_data(file_path: str) -> Dict[str, Any]:
+    """
+    Load data from a JSON file with error handling.
+    Returns an empty dict if file not found or invalid.
+    """
+    try:
+        with open(file_path, "r", encoding="utf-8") as f:
+            return json.load(f)
+    except (FileNotFoundError, json.JSONDecodeError) as e:
+        logger.warning(f"Error loading file {file_path}: {e}")
+        return {}
+
+def load_note_data(note_number: str, folder: Optional[str] = None) -> Optional[Dict[str, Any]]:
+    """
+    Load note data for a specific note_number from notes.json in the specified folder.
+    Returns the note dict or None if not found.
+    """
+    folder = folder or os.path.join(os.path.dirname(os.path.dirname(__file__)), "generated_notes")
+    file_path = os.path.join(folder, "notes.json")
+    try:
+        with open(file_path, "r", encoding="utf-8") as f:
+            data = json.load(f)
+            notes = data.get("notes", [])
+            for note in notes:
+                n_num = note.get("note_number") or note.get("metadata", {}).get("note_number")
+                if str(n_num) == str(note_number):
+                    return note
+            logger.warning(f"Note {note_number} not found in {file_path}")
+    except (FileNotFoundError, json.JSONDecodeError) as e:
+        logger.error(f"Error loading note {note_number}: {e}")
+    return None
+
+def load_trail_balance(folder: str = "output1") -> Dict[str, Any]:
+    """
+    Load parsed trial balance data from JSON file in the specified folder.
+    Returns an empty dict if file not found or invalid.
+    """
+    return load_data(os.path.join(folder, "parsed_trail_balance.json"))
+
+def extract_value_from_notes(note_data: Optional[Dict[str, Any]], key: str, year: str = "2024") -> Optional[float]:
+    """
+    Extract specific value from note data based on key and year.
+    Returns None if not found or invalid.
+    """
+    if not note_data or "structure" not in note_data:
+        return None
+    key = key.lower().replace(" ","").replace("-","").replace("/","").replace("&","")
+    for category in note_data["structure"]:
+        if "subcategories" in category:
+            for subcat in category["subcategories"]:
+                label = subcat.get("label", "").lower().replace(" ","").replace("-","").replace("/","").replace("&","")
+                if key in label:
+                    if year == "2024" and "value" in subcat:
+                        try:
+                            value = float(subcat["value"])
+                            if value > 100000:
+                                value = value / 100000
+                            return value
+                        except (ValueError, TypeError):
+                            continue
+                    elif year == "2023" and "previous_value" in subcat:
+                        try:
+                            value = float(subcat["previous_value"])
+                            if value > 100000:
+                                value = value / 100000
+                            return value
+                        except (ValueError, TypeError):
+                            continue
+    return None
+
+def extract_value_from_tb(tb_data: Dict[str, Any], account_name: str, year: str = "2024") -> Optional[float]:
+    """
+    Extract balance from trial balance for a specific account and year.
+    Returns None if not found or invalid.
+    """
+    if not tb_data or "accounts" not in tb_data.get(year, {}):
+        return None
+    for account in tb_data[year]["accounts"]:
+        if account.get("name", "").lower() == account_name.lower():
+            balance = float(account.get("balance", 0))
+            return balance / 100000 if balance > 100000 else balance
+    return None
+
+def calculate_movement(tb_2024: Dict[str, Any], tb_2023: Dict[str, Any], account_name: str) -> Optional[float]:
+    """
+    Calculate movement (2024 - 2023) from trial balance data.
+    Returns None if not found or invalid.
+    """
+    val_2024 = extract_value_from_tb({"2024": tb_2024}, account_name, "2024")
+    val_2023 = extract_value_from_tb({"2023": tb_2023}, account_name, "2023")
+    if val_2024 is not None and val_2023 is not None:
+        return val_2024 - val_2023
+    return None
+
+def format_currency(value: Optional[float]) -> str:
+    """
+    Format currency value for display, handling None.
+    """
+    if value is None:
+        return "-"
+    if isinstance(value, (int, float)) and value != 0:
+        return f"{value:,.2f}"
+    return "-"
+
+def generate_cashflow_report() -> None:
+    """
+    Generate Cash Flow Statement report in Excel format using notes and trial balance data.
+    Output location is configurable via environment variables.
+    """
+    wb = Workbook()
+    ws = wb.active
+    ws.title = "Cash Flow Statement"
+
+    # Define styles
+    bold_font = Font(bold=True)
+    thin_border = Border(left=Side(style="thin"), right=Side(style="thin"),
+                        top=Side(style="thin"), bottom=Side(style="thin"))
+    center_align = Alignment(horizontal="center")
+    left_align = Alignment(horizontal="left")
+    right_align = Alignment(horizontal="right")
+
+    # Set column widths
+    ws.column_dimensions["A"].width = 50
+    ws.column_dimensions["B"].width = 20
+    ws.column_dimensions["C"].width = 20
+
+    # Header
+    ws["A1"] = "Statement of Cash Flows for the year ended March 31, 2024"
+    ws["A1"].font = bold_font
+    ws.merge_cells("A1:C1")
+    ws["A1"].alignment = center_align
+
+    # Units
+    ws["A2"] = "In Lakhs"
+    ws.merge_cells("A2:C2")
+    ws["A2"].alignment = right_align
+
+    # Table headers
+    headers = ["Particulars", "March 31, 2024", "March 31, 2023"]
+    for col, header in enumerate(headers, 1):
+        cell = ws.cell(row=4, column=col)
+        cell.value = header
+        cell.font = bold_font
+        cell.border = thin_border
+        cell.alignment = center_align if col > 1 else left_align
+
+    # Load data
+    note_4 = load_note_data("4")  # Cash Flow Statement
+    note_13 = load_note_data("13")  # Cash and Cash Equivalents
+    note_6 = load_note_data("6")  # Trade Payables
+    note_7 = load_note_data("7")  # Other Current Liabilities
+    note_8 = load_note_data("8")  # Provisions
+    note_9 = load_note_data("9")  # Fixed Assets
+    tb_data = load_trail_balance()
+    tb_2024 = tb_data.get("2024", {})
+    tb_2023 = tb_data.get("2023", {})
+
+    # Extract or calculate values
+    values = {
+        "profit_before_tax": {"2024": extract_value_from_notes(note_4, "profit before taxation", "2024") or extract_value_from_tb(tb_2024, "Profit before Taxation"),
+                              "2023": extract_value_from_notes(note_4, "profit before taxation", "2023") or extract_value_from_tb(tb_2023, "Profit before Taxation")},
+        "depreciation_amortization": {"2024": extract_value_from_notes(note_4, "depreciation and amortisation expense", "2024") or extract_value_from_tb(tb_2024, "Depreciation and Amortisation Expense"),
+                                      "2023": extract_value_from_notes(note_4, "depreciation and amortisation expense", "2023") or extract_value_from_tb(tb_2023, "Depreciation and Amortisation Expense")},
+        "interest_income": {"2024": extract_value_from_notes(note_4, "interest income", "2024") or extract_value_from_tb(tb_2024, "Interest Income"),
+                            "2023": extract_value_from_notes(note_4, "interest income", "2023") or extract_value_from_tb(tb_2023, "Interest Income")},
+        "trade_receivables": {"2024": calculate_movement(tb_2024, tb_2023, "Trade Receivables") or extract_value_from_notes(note_4, "increase/decrease in trade receivables", "2024"),
+                              "2023": calculate_movement(tb_2023, tb_2023, "Trade Receivables") or extract_value_from_notes(note_4, "increase/decrease in trade receivables", "2023")},
+        "inventories": {"2024": calculate_movement(tb_2024, tb_2023, "Inventories") or extract_value_from_notes(note_4, "increase/decrease in inventories", "2024"),
+                        "2023": calculate_movement(tb_2023, tb_2023, "Inventories") or extract_value_from_notes(note_4, "increase/decrease in inventories", "2023")},
+        "other_current_assets": {"2024": calculate_movement(tb_2024, tb_2023, "Other Current Assets") or extract_value_from_notes(note_4, "increase/decrease in other current assets", "2024"),
+                                 "2023": calculate_movement(tb_2023, tb_2023, "Other Current Assets") or extract_value_from_notes(note_4, "increase/decrease in other current assets", "2023")},
+        "short_term_loans": {"2024": calculate_movement(tb_2024, tb_2023, "Short Term Loans & Advances") or extract_value_from_notes(note_4, "increase/decrease in short term loans & advances", "2024"),
+                             "2023": calculate_movement(tb_2023, tb_2023, "Short Term Loans & Advances") or extract_value_from_notes(note_4, "increase/decrease in short term loans & advances", "2023")},
+        "capital_work_progress": {"2024": calculate_movement(tb_2024, tb_2023, "Capital Work in Progress") or extract_value_from_notes(note_4, "increase/decrease in capital work in progress", "2024"),
+                                  "2023": calculate_movement(tb_2023, tb_2023, "Capital Work in Progress") or extract_value_from_notes(note_4, "increase/decrease in capital work in progress", "2023")},
+        "long_term_loans": {"2024": calculate_movement(tb_2024, tb_2023, "Long Term Loans & Advances") or extract_value_from_notes(note_4, "increase/decrease in long term loans & advances", "2024"),
+                            "2023": calculate_movement(tb_2023, tb_2023, "Long Term Loans & Advances") or extract_value_from_notes(note_4, "increase/decrease in long term loans & advances", "2023")},
+        "short_term_provisions": {"2024": calculate_movement(tb_2024, tb_2023, "Short Term Provisions") or extract_value_from_notes(note_8, "short term provisions", "2024"),
+                                  "2023": calculate_movement(tb_2023, tb_2023, "Short Term Provisions") or extract_value_from_notes(note_8, "short term provisions", "2023")},
+        "trade_payables": {"2024": calculate_movement(tb_2024, tb_2023, "Trade Payables") or extract_value_from_notes(note_6, "trade payables", "2024"),
+                           "2023": calculate_movement(tb_2023, tb_2023, "Trade Payables") or extract_value_from_notes(note_6, "trade payables", "2023")},
+        "other_current_liabilities": {"2024": calculate_movement(tb_2024, tb_2023, "Other Current Liabilities") or extract_value_from_notes(note_7, "other current liabilities", "2024"),
+                                      "2023": calculate_movement(tb_2023, tb_2023, "Other Current Liabilities") or extract_value_from_notes(note_7, "other current liabilities", "2023")},
+        "purchase_assets": {"2024": extract_value_from_notes(note_9, "purchase of assets", "2024") or calculate_movement(tb_2024, tb_2023, "Fixed Assets"),
+                            "2023": extract_value_from_notes(note_9, "purchase of assets", "2023") or calculate_movement(tb_2023, tb_2023, "Fixed Assets")},
+        "sale_assets": {"2024": extract_value_from_notes(note_9, "sale of assets", "2024"),
+                        "2023": extract_value_from_notes(note_9, "sale of assets", "2023")},
+        "dividend_paid": {"2024": extract_value_from_notes(note_4, "dividend paid", "2024") or extract_value_from_tb(tb_2024, "Dividend Paid"),
+                          "2023": extract_value_from_notes(note_4, "dividend paid", "2023") or extract_value_from_tb(tb_2023, "Dividend Paid")},
+        "long_term_borrowings": {"2024": calculate_movement(tb_2024, tb_2023, "Long Term Borrowings") or extract_value_from_notes(note_4, "long term borrowings", "2024"),
+                                 "2023": calculate_movement(tb_2023, tb_2023, "Long Term Borrowings") or extract_value_from_notes(note_4, "long term borrowings", "2023")},
+        "cash_equivalents_opening": {"2024": extract_value_from_notes(note_13, "cash and cash equivalents at the beginning", "2024") or extract_value_from_tb(tb_2023, "Cash and Cash Equivalents"),
+                                     "2023": extract_value_from_notes(note_13, "cash and cash equivalents at the beginning", "2023") or extract_value_from_tb(tb_2023, "Cash and Cash Equivalents")},
+        "cash_equivalents_closing": {"2024": extract_value_from_notes(note_13, "cash and cash equivalents at the end", "2024") or extract_value_from_tb(tb_2024, "Cash and Cash Equivalents"),
+                                     "2023": extract_value_from_notes(note_13, "cash and cash equivalents at the end", "2023") or extract_value_from_tb(tb_2023, "Cash and Cash Equivalents")},
+        "cash_on_hand": {"2024": extract_value_from_notes(note_13, "cash on hand", "2024") or extract_value_from_tb(tb_2024, "Cash on Hand"),
+                         "2023": extract_value_from_notes(note_13, "cash on hand", "2023") or extract_value_from_tb(tb_2023, "Cash on Hand")},
+        "bank_current_accounts": {"2024": extract_value_from_notes(note_13, "with banks in current accounts", "2024") or extract_value_from_tb(tb_2024, "Bank Current Accounts"),
+                                  "2023": extract_value_from_notes(note_13, "with banks in current accounts", "2023") or extract_value_from_tb(tb_2023, "Bank Current Accounts")},
+        "bank_fixed_deposits": {"2024": extract_value_from_notes(note_13, "with banks in fixed deposits", "2024") or extract_value_from_tb(tb_2024, "Bank Fixed Deposits"),
+                                "2023": extract_value_from_notes(note_13, "with banks in fixed deposits", "2023") or extract_value_from_tb(tb_2023, "Bank Fixed Deposits")},
+    }
+
+    # Calculate derived values
+    operating_profit_2024 = (values["profit_before_tax"]["2024"] or 0) + (values["depreciation_amortization"]["2024"] or 0) - (values["interest_income"]["2024"] or 0)
+    operating_profit_2023 = (values["profit_before_tax"]["2023"] or 0) + (values["depreciation_amortization"]["2023"] or 0) - (values["interest_income"]["2023"] or 0)
+    cash_used_operations_2024 = operating_profit_2024 + sum(v["2024"] for k, v in values.items() if k.startswith("trade_") or k.startswith("inventories") or k.startswith("other_current_") or k.startswith("short_term_") or k.startswith("capital_work_") or k.startswith("long_term_") or k.startswith("short_term_provisions") or k.startswith("trade_payables") or k.startswith("other_current_liabilities") if v["2024"] is not None)
+    cash_used_operations_2023 = operating_profit_2023 + sum(v["2023"] for k, v in values.items() if k.startswith("trade_") or k.startswith("inventories") or k.startswith("other_current_") or k.startswith("short_term_") or k.startswith("capital_work_") or k.startswith("long_term_") or k.startswith("short_term_provisions") or k.startswith("trade_payables") or k.startswith("other_current_liabilities") if v["2023"] is not None)
+    direct_taxes_paid_2024 = extract_value_from_notes(note_8, "provision for taxation", "2024")
+    direct_taxes_paid_2023 = extract_value_from_notes(note_8, "provision for taxation", "2023")
+    net_cash_operating_2024 = cash_used_operations_2024 - (direct_taxes_paid_2024 or 0)
+    net_cash_operating_2023 = cash_used_operations_2023 - (direct_taxes_paid_2023 or 0)
+    net_cash_investing_2024 = -(values["purchase_assets"]["2024"] or 0) + (values["sale_assets"]["2024"] or 0) + (values["interest_income"]["2024"] or 0)
+    net_cash_investing_2023 = -(values["purchase_assets"]["2023"] or 0) + (values["sale_assets"]["2023"] or 0) + (values["interest_income"]["2023"] or 0)
+    net_cash_financing_2024 = (values["long_term_borrowings"]["2024"] or 0) - (values["dividend_paid"]["2024"] or 0)
+    net_cash_financing_2023 = (values["long_term_borrowings"]["2023"] or 0) - (values["dividend_paid"]["2023"] or 0)
+    total_cash_flow_2024 = net_cash_operating_2024 + net_cash_investing_2024 + net_cash_financing_2024
+    total_cash_flow_2023 = net_cash_operating_2023 + net_cash_investing_2023 + net_cash_financing_2023
+
+    # Debug logs
+    logger.debug(f"Total Cash Flow 2024: {format_currency(total_cash_flow_2024)}")
+    logger.debug(f"Total Cash Flow 2023: {format_currency(total_cash_flow_2023)}")
+    logger.debug(f"Net Cash from Operating Activities 2024: {format_currency(net_cash_operating_2024)}")
+    logger.debug(f"Net Cash from Operating Activities 2023: {format_currency(net_cash_operating_2023)}")
+
+    # Prepare line items for Excel
+    line_items = [
+        {"label": "Cash flow from operating activities", "value_2024": "", "value_2023": "", "is_header": True},
+        {"label": "Profit before taxation", "value_2024": values["profit_before_tax"]["2024"], "value_2023": values["profit_before_tax"]["2023"]},
+        {"label": "Adjustment for:", "value_2024": "", "value_2023": "", "is_subheader": True},
+        {"label": "Add: Depreciation and Amortisation Expense", "value_2024": values["depreciation_amortization"]["2024"], "value_2023": values["depreciation_amortization"]["2023"]},
+        {"label": "Less: Interest income", "value_2024": -values["interest_income"]["2024"] if values["interest_income"]["2024"] is not None else None, "value_2023": -values["interest_income"]["2023"] if values["interest_income"]["2023"] is not None else None},
+        {"label": "Operating profit before working capital changes", "value_2024": operating_profit_2024, "value_2023": operating_profit_2023, "is_total": True},
+        {"label": "Movements in working capital:", "value_2024": "", "value_2023": "", "is_subheader": True},
+        {"label": "(Increase)/Decrease in Trade Receivables", "value_2024": values["trade_receivables"]["2024"], "value_2023": values["trade_receivables"]["2023"]},
+        {"label": "(Increase)/Decrease in Inventories", "value_2024": values["inventories"]["2024"], "value_2023": values["inventories"]["2023"]},
+        {"label": "(Increase)/Decrease in Other Current Assets", "value_2024": values["other_current_assets"]["2024"], "value_2023": values["other_current_assets"]["2023"]},
+        {"label": "(Increase)/Decrease in Short Term Loans & Advances", "value_2024": values["short_term_loans"]["2024"], "value_2023": values["short_term_loans"]["2023"]},
+        {"label": "(Increase)/Decrease in Capital Work in Progress", "value_2024": values["capital_work_progress"]["2024"], "value_2023": values["capital_work_progress"]["2023"]},
+        {"label": "(Increase)/Decrease in Long Term Loans & Advances", "value_2024": values["long_term_loans"]["2024"], "value_2023": values["long_term_loans"]["2023"]},
+        {"label": "Increase/(Decrease) in Short Term Provisions", "value_2024": values["short_term_provisions"]["2024"], "value_2023": values["short_term_provisions"]["2023"]},
+        {"label": "Increase/(Decrease) in Trade Payables", "value_2024": values["trade_payables"]["2024"], "value_2023": values["trade_payables"]["2023"]},
+        {"label": "Increase/(Decrease) in Other Current Liabilities", "value_2024": values["other_current_liabilities"]["2024"], "value_2023": values["other_current_liabilities"]["2023"]},
+        {"label": "Cash used in operations", "value_2024": cash_used_operations_2024, "value_2023": cash_used_operations_2023, "is_total": True},
+        {"label": "Less: Direct taxes paid (net of refunds)", "value_2024": direct_taxes_paid_2024, "value_2023": direct_taxes_paid_2023},
+        {"label": "Net cash flow used in operating activities", "value_2024": net_cash_operating_2024, "value_2023": net_cash_operating_2023, "is_total": True},
+        {"label": "Cash flows from investing activities", "value_2024": "", "value_2023": "", "is_header": True},
+        {"label": "Purchase of Assets", "value_2024": -values["purchase_assets"]["2024"] if values["purchase_assets"]["2024"] is not None else None, "value_2023": -values["purchase_assets"]["2023"] if values["purchase_assets"]["2023"] is not None else None},
+        {"label": "Sale of Assets", "value_2024": values["sale_assets"]["2024"], "value_2023": values["sale_assets"]["2023"]},
+        {"label": "Interest income", "value_2024": values["interest_income"]["2024"], "value_2023": values["interest_income"]["2023"]},
+        {"label": "Net cash flow used in investing activities", "value_2024": net_cash_investing_2024, "value_2023": net_cash_investing_2023, "is_total": True},
+        {"label": "Cash flows from financing activities", "value_2024": "", "value_2023": "", "is_header": True},
+        {"label": "Dividend paid", "value_2024": -values["dividend_paid"]["2024"] if values["dividend_paid"]["2024"] is not None else None, "value_2023": -values["dividend_paid"]["2023"] if values["dividend_paid"]["2023"] is not None else None},
+        {"label": "Long Term Borrowings", "value_2024": values["long_term_borrowings"]["2024"], "value_2023": values["long_term_borrowings"]["2023"]},
+        {"label": "Net cash generated from financing activities", "value_2024": net_cash_financing_2024, "value_2023": net_cash_financing_2023, "is_total": True},
+        {"label": "Net increase/(decrease) in cash and cash equivalents", "value_2024": total_cash_flow_2024, "value_2023": total_cash_flow_2023, "is_total": True},
+        {"label": "Cash and cash equivalents at the beginning of the year", "value_2024": values["cash_equivalents_opening"]["2024"], "value_2023": values["cash_equivalents_opening"]["2023"]},
+        {"label": "Cash and cash equivalents at the end of the year", "value_2024": values["cash_equivalents_closing"]["2024"], "value_2023": values["cash_equivalents_closing"]["2023"], "is_grand_total": True},
+        {"label": "Components of cash and cash equivalents", "value_2024": "", "value_2023": "", "is_header": True},
+        {"label": "Cash on hand", "value_2024": values["cash_on_hand"]["2024"], "value_2023": values["cash_on_hand"]["2023"]},
+        {"label": "With banks in Current Accounts", "value_2024": values["bank_current_accounts"]["2024"], "value_2023": values["bank_current_accounts"]["2023"]},
+        {"label": "With banks in Fixed Deposits", "value_2024": values["bank_fixed_deposits"]["2024"], "value_2023": values["bank_fixed_deposits"]["2023"]},
+        {"label": "Total cash and cash equivalents (Refer note 13)", "value_2024": values["cash_equivalents_closing"]["2024"], "value_2023": values["cash_equivalents_closing"]["2023"], "is_total": True},
+    ]
+
+    # Write line items to Excel
+    row = 5
+    for item in line_items:
+        ws.cell(row=row, column=1).value = item["label"]
+        ws.cell(row=row, column=2).value = format_currency(item["value_2024"])
+        ws.cell(row=row, column=3).value = format_currency(item["value_2023"])
+        # Apply formatting
+        for col in range(1, 4):
+            ws.cell(row=row, column=col).border = thin_border
+            ws.cell(row=row, column=col).alignment = center_align if col > 1 else left_align
+            if item.get("is_header") or item.get("is_grand_total") or item.get("is_subheader") or item.get("is_total"):
+                ws.cell(row=row, column=col).font = bold_font
+        row += 1
+
+    # Add notes and footer
+    row += 1
+    ws.cell(row=row, column=1).value = "Notes:"
+    ws.cell(row=row, column=1).font = bold_font
+    ws.cell(row=row, column=1).alignment = left_align
+    row += 1
+    ws.cell(row=row, column=1).value = "1. The Cash Flow statement is prepared under 'indirect method' as set out in the Indian Accounting Standard - 7 on Cash Flow Statements. Cash and cash equivalents in the Cash Flow Statement comprise cash at bank and in hand and deposits with bank."
+    ws.cell(row=row, column=1).alignment = left_align
+    ws.merge_cells(f"A{row}:C{row}")
+    row += 1
+    ws.cell(row=row, column=1).value = "2. Previous year's figures have been regrouped, wherever necessary."
+    ws.cell(row=row, column=1).alignment = left_align
+    ws.merge_cells(f"A{row}:C{row}")
+    row += 1
+    ws.cell(row=row, column=1).value = "3. The accompanying notes form an integral part of the Financial Statements"
+    ws.cell(row=row, column=1).alignment = left_align
+    ws.merge_cells(f"A{row}:C{row}")
+    row += 1
+    ws.cell(row=row, column=1).value = "As per my report of even date."
+    ws.cell(row=row, column=1).alignment = left_align
+    ws.cell(row=row, column=3).value = "For and on behalf of the Board of Directors"
+    ws.cell(row=row, column=3).alignment = center_align
+    row += 2
+    ws.cell(row=row, column=1).value = "For M/s Siva Parvathi & Associates"
+    ws.cell(row=row, column=1).alignment = left_align
+    ws.cell(row=row+1, column=1).value = "ICAI Firm registration number: 020872S"
+    ws.cell(row=row+1, column=1).alignment = left_align
+    ws.cell(row=row+2, column=1).value = "Chartered Accountants"
+    ws.cell(row=row+2, column=1).alignment = left_align
+    row += 4
+    ws.cell(row=row, column=1).value = "S. Siva Parvathi"
+    ws.cell(row=row, column=1).alignment = left_align
+    ws.cell(row=row, column=3).value = "Director"
+    ws.cell(row=row, column=3).alignment = center_align
+    ws.cell(row=row, column=4).value = "Director"
+    ws.cell(row=row, column=4).alignment = center_align
+    row += 1
+    ws.cell(row=row, column=1).value = "Proprietor"
+    ws.cell(row=row, column=1).alignment = left_align
+    row += 1
+    ws.cell(row=row, column=1).value = "UDIN:24226087BKEECZ1200"
+    ws.cell(row=row, column=1).alignment = left_align
+    row += 1
+    ws.cell(row=row, column=1).value = "Place: Hyderabad"
+    ws.cell(row=row, column=1).alignment = left_align
+    row += 1
+    ws.cell(row=row, column=1).value = "Date: 04/09/2024"
+    ws.cell(row=row, column=1).alignment = left_align
+
+    # Save Excel file with error handling
+    try:
+        os.makedirs(CASHFLOW_OUTPUT_FOLDER, exist_ok=True)
+        output_file = os.path.join(CASHFLOW_OUTPUT_FOLDER, CASHFLOW_OUTPUT_FILE)
+        wb.save(output_file)
+        logger.info(f"Cash Flow Statement report generated successfully and saved to {output_file}")
+    except PermissionError:
+        logger.error(f"PermissionError: Unable to save to {output_file}. Trying alternative location...")
+        fallback_file = os.path.join(os.path.expanduser("~"), "Desktop", "cash_flow_report_fallback.xlsx")
+        try:
+            wb.save(fallback_file)
+            logger.info(f"Cash Flow Statement report saved to alternative location: {fallback_file}")
+        except Exception as e:
+            logger.error(f"Failed to save Cash Flow Statement report: {str(e)}")
+    except Exception as e:
+        logger.error(f"Error saving Cash Flow Statement report: {str(e)}")
+
+if __name__ == "__main__":
+    generate_cashflow_report()

app/extract.py

@@ -0,0 +1,251 @@
+import pandas as pd
+import json
+import os
+import re
+import glob
+import logging
+from pathlib import Path
+from typing import Any, Dict, List, Tuple, Optional
+import requests
+from dotenv import load_dotenv
+from pydantic import BaseModel, Field, ValidationError
+from pydantic_settings import BaseSettings
+
+# Configure logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+class Settings(BaseSettings):
+    """
+    Application settings loaded from environment variables or .env file.
+    """
+    MAPPING_FILE: str = Field(default="mapping1.json", env="MAPPING_FILE")
+    RULES_FILE: str = Field(default="rules1.json", env="RULES_FILE")
+    OUTPUT_DIR: str = Field(default="output1", env="OUTPUT_DIR")
+
+settings = Settings()
+
+class TrialBalanceRecord(BaseModel):
+    """
+    Pydantic model for a trial balance record.
+    """
+    account_name: str
+    group: str
+    amount: float
+    mapped_by: str
+    source_file: str
+
+def load_mappings(
+    mapping_file: str = settings.MAPPING_FILE,
+    rules_file: str = settings.RULES_FILE
+) -> Tuple[Dict[str, Any], Dict[str, Any]]:
+    """
+    Loads exact mappings and keyword rules from JSON files.
+    Returns two dictionaries: exact_mappings, keyword_rules.
+    """
+    exact_mappings = {}
+    keyword_rules = {}
+    try:
+        if Path(mapping_file).exists():
+            with open(mapping_file, 'r', encoding='utf-8') as f:
+                exact_mappings = json.load(f)
+        if Path(rules_file).exists():
+            with open(rules_file, 'r', encoding='utf-8') as f:
+                keyword_rules = json.load(f)
+    except Exception as e:
+        logger.error(f"Error loading mappings: {e}")
+    return exact_mappings, keyword_rules
+
+def get_smart_rules() -> Dict[str, List[str]]:
+    """
+    Returns a dictionary of smart rules for account classification.
+    """
+    return {
+        'Cash and Cash Equivalents': [r'\b(cash|bank|petty|till|vault|fd|fixed\s*deposit)\b'],
+        'Trade Receivables': [r'\b(debtor|receivable|customer|outstanding.*debtor)\b'],
+        'Trade Payables': [r'\b(creditor|payable|supplier|vendor|outstanding.*creditor)\b'],
+        'Inventories': [r'\b(stock|inventory|goods|raw\s*material|wip|work.*progress)\b'],
+        'Property, Plant and Equipment': [r'\b(land|building|plant|machinery|equipment|furniture|vehicle|depreciation)\b'],
+        'Equity Share Capital': [r'\b(capital|share.*capital|paid.*up|equity)\b'],
+        'Revenue from Operations': [r'\b(sales?|revenue|turnover|service.*income)\b'],
+        'Employee Benefits Expense': [r'\b(salary|wages?|staff|employee|pf|provident|gratuity)\b'],
+        'Finance Costs': [r'\b(interest|finance.*cost|bank.*charge)\b'],
+        'Other Current Liabilities': [r'\b(tds|gst|vat|tax.*payable|service.*tax)\b']
+    }
+
+def parse_amount(amount_str: Any) -> float:
+    """
+    Parses an amount string and returns a float.
+    Returns 0.0 if invalid.
+    """
+    if pd.isna(amount_str) or amount_str == '':
+        return 0.0
+    amount_str = str(amount_str).strip()
+    is_credit = amount_str.lower().endswith('cr')
+    amount_str = re.sub(r'[^\d\.\-\+]', '', amount_str)
+    if not amount_str or amount_str in ['-', '+']:
+        return 0.0
+    try:
+        amount = float(amount_str)
+        if is_credit and amount > 0:
+            amount = -amount
+        return amount
+    except ValueError:
+        return 0.0
+
+def classify_account(
+    account_name: str,
+    exact_mappings: Dict[str, Any],
+    keyword_rules: Dict[str, Any],
+    smart_rules: Dict[str, List[str]],
+    llm_model: str = "qwen/qwen3-30b-a3b"
+) -> Tuple[str, str]:
+    """
+    Classifies an account name into a category using mappings, rules, and smart patterns.
+    Returns (group, mapped_by).
+    """
+    account_name_clean = account_name.strip().lower()
+    if account_name in exact_mappings:
+        return exact_mappings[account_name], "mapping.json"
+    for mapped_name, group in exact_mappings.items():
+        if mapped_name.lower() == account_name_clean:
+            return group, "mapping.json"
+    for group, keywords in keyword_rules.items():
+        for keyword in keywords:
+            if keyword.lower() in account_name_clean.split():
+                return group, "rules.json"
+    for group, patterns in smart_rules.items():
+        for pattern in patterns:
+            if re.search(pattern, account_name_clean):
+                return group, "smart_rules"
+    # LLM Fallback (commented out, enable if needed)
+    # load_dotenv()
+    # api_key = os.getenv("OPENROUTER_API_KEY")
+    # if api_key:
+    #     try:
+    #         response = requests.post(
+    #             "https://openrouter.ai/api/v1/chat/completions",
+    #             headers={
+    #                 "Authorization": f"Bearer {api_key}",
+    #                 "Content-Type": "application/json"
+    #             },
+    #             json={
+    #                 "model": "mistralai/mixtral-8x7b-instruct",
+    #                 "messages": [
+    #                     {
+    #                         "role": "system",
+    #                         "content": "You are a financial expert. Classify the following account name into one of these categories: Equity, Non-Current Liability, Current Liability, Non-Current Asset, Current Asset, Revenue from Operations, Cost of Materials Consumed, Direct Expenses, Other Income, Other Expenses, Employee Benefits Expense, Finance Cost, Accumulated Depreciation, Deferred Tax Liability, Profit and Loss Account. Respond only with the category name."
+    #                     },
+    #                     {
+    #                         "role": "user",
+    #                         "content": account_name
+    #                     }
+    #                 ]
+    #             },
+    #             timeout=10
+    #         )
+    #         response.raise_for_status()
+    #         llm_response = response.json()
+    #         llm_suggestion = llm_response['choices'][0]['message']['content'].strip()
+    #         return llm_suggestion, "llm_fallback"
+    #     except requests.exceptions.RequestException as e:
+    #         logger.error(f"LLM fallback failed: {e}")
+    #     except Exception as e:
+    #         logger.error(f"Unexpected error in LLM fallback: {e}")
+    return 'Unmapped', 'Unmapped'
+
+def extract_trial_balance_data(
+    file_path: str,
+    sheet_name: int = 0,
+    header_row: int = 0
+) -> List[TrialBalanceRecord]:
+    """
+    Extracts trial balance data from an Excel file.
+    Returns a list of validated TrialBalanceRecord objects.
+    """
+    try:
+        df_raw = pd.read_excel(file_path, sheet_name=sheet_name, header=header_row)
+    except Exception as e:
+        logger.error(f"Error reading Excel file: {e}")
+        return []
+    exact_mappings, keyword_rules = load_mappings()
+    smart_rules = get_smart_rules()
+    structured_data: List[TrialBalanceRecord] = []
+    source_file = Path(file_path).name
+    for idx, row in df_raw.iterrows():
+        account_name = row.iloc[0] if len(row) > 0 else None
+        if pd.isna(account_name) or str(account_name).strip() == '':
+            continue
+        account_name = str(account_name).strip()
+        if len(account_name) <= 2 or account_name.replace('.', '').replace('-', '').isdigit():
+            continue
+        amount = 0.0
+        if len(row) > 3 and not pd.isna(row.iloc[3]):
+            amount = parse_amount(row.iloc[3])
+        elif len(row) > 2:
+            debit = parse_amount(row.iloc[1]) if len(row) > 1 else 0.0
+            credit = parse_amount(row.iloc[2]) if len(row) > 2 else 0.0
+            amount = debit - credit
+        group, mapped_by = classify_account(account_name, exact_mappings, keyword_rules, smart_rules)
+        try:
+            record = TrialBalanceRecord(
+                account_name=account_name,
+                group=group,
+                amount=amount,
+                mapped_by=mapped_by,
+                source_file=source_file
+            )
+            structured_data.append(record)
+        except ValidationError as ve:
+            logger.error(f"Validation error for record {account_name}: {ve}")
+    return structured_data
+
+def analyze_and_save_results(structured_data: List[TrialBalanceRecord], output_file: str) -> List[TrialBalanceRecord]:
+    """
+    Analyzes and saves the extracted data to a JSON file.
+    Returns the structured data.
+    """
+    total_records = len(structured_data)
+    mapped_records = [r for r in structured_data if r.mapped_by != 'Unmapped']
+    unmapped_records = [r for r in structured_data if r.mapped_by == 'Unmapped']
+    success_rate = (len(mapped_records) / total_records * 100) if total_records > 0 else 0
+    total_amount = sum(abs(r.amount) for r in mapped_records)
+    mapping_methods: Dict[str, int] = {}
+    for record in mapped_records:
+        method = record.mapped_by
+        mapping_methods[method] = mapping_methods.get(method, 0) + 1
+    account_groups: Dict[str, Dict[str, Any]] = {}
+    for record in mapped_records:
+        group = record.group
+        if group not in account_groups:
+            account_groups[group] = {'count': 0, 'total_amount': 0}
+        account_groups[group]['count'] += 1
+        account_groups[group]['total_amount'] += abs(record.amount)
+    os.makedirs(settings.OUTPUT_DIR, exist_ok=True)
+    try:
+        with open(output_file, 'w', encoding='utf-8') as f:
+            json.dump([r.dict() for r in structured_data], f, indent=2, ensure_ascii=False)
+    except Exception as e:
+        logger.error(f"Error saving results to JSON: {e}")
+    return structured_data
+
+def find_file(filename: str) -> Optional[str]:
+    """
+    Finds a file with a given name in the current directory and the input directory.
+    Returns the file path if found, else None.
+    """
+    possible_paths = [
+        filename,
+        f"input/{filename}",
+        f"./{filename}",
+    ]
+    for path in possible_paths:
+        if Path(path).exists():
+            return path
+    filename_lower = filename.lower()
+    all_files = glob.glob("*.xlsx") + glob.glob("input/*.xlsx")
+    for file_path in all_files:
+        file_name_lower = Path(file_path).name.lower()
+        if filename_lower in file_name_lower:
+            return file_path
+    return None

app/json_xlsx.py

@@ -0,0 +1,321 @@
+import os
+import json
+import logging
+from typing import Any, Dict, List, Optional
+from pydantic import BaseModel, ValidationError
+from pydantic_settings import BaseSettings
+import pandas as pd
+from openpyxl import Workbook
+from openpyxl.styles import Font, PatternFill, Alignment, Border, Side
+from openpyxl.utils import get_column_letter
+
+# Configure logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+class Settings(BaseSettings):
+    """Application settings loaded from environment variables or .env file."""
+    input_file: str = "output2/notes_output.json"
+    output_folder: str = "output3"
+    output_file: str = "final_notes_output.xlsx"
+
+settings = Settings()
+
+class BreakdownItem(BaseModel):
+    description: str
+    amount: float
+    amount_lakhs: Optional[float] = None
+
+class MatchedAccount(BaseModel):
+    account: str
+    amount: float
+    amount_lakhs: Optional[float] = None
+    group: Optional[str] = None
+
+class NoteData(BaseModel):
+    note_number: Optional[str] = None
+    note_title: Optional[str] = None
+    full_title: Optional[str] = None
+    table_data: Optional[List[Dict[str, Any]]] = []
+    breakdown: Optional[Dict[str, BreakdownItem]] = {}
+    matched_accounts: Optional[List[MatchedAccount]] = []
+    total_amount: Optional[float] = None
+    total_amount_lakhs: Optional[float] = None
+    matched_accounts_count: Optional[int] = None
+    comparative_data: Optional[Dict[str, Any]] = {}
+    notes_and_disclosures: Optional[List[str]] = []
+    markdown_content: Optional[str] = ""
+
+def create_output_folder(folder_path: str) -> None:
+    """Create output folder if it doesn't exist."""
+    if not os.path.exists(folder_path):
+        os.makedirs(folder_path)
+        logger.info(f"Created folder: {folder_path}")
+
+def read_json_file(file_path: str) -> Optional[Dict[str, Any]]:
+    """Read and parse JSON file."""
+    try:
+        with open(file_path, 'r', encoding='utf-8') as file:
+            data = json.load(file)
+        logger.info(f"Successfully read JSON file: {file_path}")
+        return data
+    except FileNotFoundError:
+        logger.error(f"File '{file_path}' not found.")
+        return None
+    except json.JSONDecodeError as e:
+        logger.error(f"Invalid JSON format in '{file_path}': {e}")
+        return None
+    except Exception as e:
+        logger.error(f"Error reading file '{file_path}': {e}")
+        return None
+
+def normalize_llm_note_json(llm_json: Dict[str, Any]) -> Dict[str, Any]:
+    """
+    Convert LLM note JSON (single note, custom structure) to the standard notes_output.json format.
+    """
+    if "note_number" in llm_json or "full_title" in llm_json or "table_data" in llm_json:
+        return llm_json
+
+    normalized = {
+        "note_number": llm_json.get("metadata", {}).get("note_number", ""),
+        "note_title": llm_json.get("title", ""),
+        "full_title": llm_json.get("full_title", ""),
+        "table_data": [],
+        "breakdown": {},
+        "matched_accounts": [],
+        "total_amount": None,
+        "total_amount_lakhs": None,
+        "matched_accounts_count": None,
+        "comparative_data": {},
+        "notes_and_disclosures": [],
+        "markdown_content": "",
+    }
+    if "structure" in llm_json:
+        for item in llm_json["structure"]:
+            if "category" in item and "subcategories" in item:
+                for sub in item["subcategories"]:
+                    row = {
+                        "particulars": sub.get("label", ""),
+                        "current_year": sub.get("value", ""),
+                        "previous_year": ""
+                    }
+                    normalized["table_data"].append(row)
+    return normalized
+
+def create_financial_table_sheet(workbook: Workbook, sheet_name: str, note_data: Dict[str, Any]) -> None:
+    """Create a properly formatted financial table sheet."""
+    ws = workbook.create_sheet(title=sheet_name)
+    header_font = Font(bold=True, color="FFFFFF")
+    header_fill = PatternFill(start_color="366092", end_color="366092", fill_type="solid")
+    bold_font = Font(bold=True)
+    center_alignment = Alignment(horizontal="center", vertical="center")
+    right_alignment = Alignment(horizontal="right", vertical="center")
+    thin_border = Border(
+        left=Side(style='thin'),
+        right=Side(style='thin'),
+        top=Side(style='thin'),
+        bottom=Side(style='thin')
+    )
+    current_row = 1
+
+    # Add Note Title
+    note_title = note_data.get('full_title', note_data.get('note_title', 'Note'))
+    ws.cell(row=current_row, column=1, value=note_title)
+    ws.cell(row=current_row, column=1).font = Font(bold=True, size=14)
+    current_row += 2
+
+    # Process table_data if available
+    if 'table_data' in note_data and note_data['table_data']:
+        table_data = note_data['table_data']
+        df = pd.DataFrame(table_data)
+        for col_num, column_name in enumerate(df.columns, 1):
+            cell = ws.cell(row=current_row, column=col_num, value=column_name.replace('_', ' ').title())
+            cell.font = header_font
+            cell.fill = header_fill
+            cell.alignment = center_alignment
+            cell.border = thin_border
+        current_row += 1
+        for _, row in df.iterrows():
+            for col_num, value in enumerate(row, 1):
+                cell = ws.cell(row=current_row, column=col_num, value=value)
+                cell.border = thin_border
+                if col_num > 1:
+                    cell.alignment = right_alignment
+                if isinstance(value, str) and ('**' in value or 'Total' in value or 'Particulars' in value):
+                    cell.font = bold_font
+                    cell.value = value.replace('**', '')
+            current_row += 1
+        current_row += 1
+
+    # Add breakdown information if available
+    if 'breakdown' in note_data and note_data['breakdown']:
+        ws.cell(row=current_row, column=1, value="Breakdown Details:")
+        ws.cell(row=current_row, column=1).font = bold_font
+        current_row += 1
+        ws.cell(row=current_row, column=1, value="Description")
+        ws.cell(row=current_row, column=2, value="Amount")
+        ws.cell(row=current_row, column=3, value="Amount (Lakhs)")
+        for col in range(1, 4):
+            cell = ws.cell(row=current_row, column=col)
+            cell.font = header_font
+            cell.fill = header_fill
+            cell.alignment = center_alignment
+            cell.border = thin_border
+        current_row += 1
+        for key, value in note_data['breakdown'].items():
+            if isinstance(value, dict):
+                desc = value.get('description', key)
+                amount = value.get('amount', 0)
+                amount_lakhs = value.get('amount_lakhs', 0)
+                ws.cell(row=current_row, column=1, value=desc).border = thin_border
+                ws.cell(row=current_row, column=2, value=amount).border = thin_border
+                ws.cell(row=current_row, column=3, value=amount_lakhs).border = thin_border
+                ws.cell(row=current_row, column=2).alignment = right_alignment
+                ws.cell(row=current_row, column=3).alignment = right_alignment
+                current_row += 1
+        current_row += 1
+
+    # Add matched accounts if available
+    if 'matched_accounts' in note_data and note_data['matched_accounts']:
+        ws.cell(row=current_row, column=1, value="Account-wise Breakdown:")
+        ws.cell(row=current_row, column=1).font = bold_font
+        current_row += 1
+        headers = ["Account", "Amount", "Amount (Lakhs)", "Group"]
+        for col_num, header in enumerate(headers, 1):
+            cell = ws.cell(row=current_row, column=col_num, value=header)
+            cell.font = header_font
+            cell.fill = header_fill
+            cell.alignment = center_alignment
+            cell.border = thin_border
+        current_row += 1
+        for account in note_data['matched_accounts']:
+            ws.cell(row=current_row, column=1, value=account.get('account', '')).border = thin_border
+            ws.cell(row=current_row, column=2, value=account.get('amount', 0)).border = thin_border
+            ws.cell(row=current_row, column=3, value=account.get('amount_lakhs', 0)).border = thin_border
+            ws.cell(row=current_row, column=4, value=account.get('group', '')).border = thin_border
+            ws.cell(row=current_row, column=2).alignment = right_alignment
+            ws.cell(row=current_row, column=3).alignment = right_alignment
+            current_row += 1
+        current_row += 1
+
+    # Add summary information
+    if 'total_amount' in note_data:
+        ws.cell(row=current_row, column=1, value="Summary:")
+        ws.cell(row=current_row, column=1).font = bold_font
+        current_row += 1
+        ws.cell(row=current_row, column=1, value="Total Amount:")
+        ws.cell(row=current_row, column=2, value=note_data.get('total_amount', 0))
+        ws.cell(row=current_row, column=2).alignment = right_alignment
+        current_row += 1
+        ws.cell(row=current_row, column=1, value="Total Amount (Lakhs):")
+        ws.cell(row=current_row, column=2, value=note_data.get('total_amount_lakhs', 0))
+        ws.cell(row=current_row, column=2).alignment = right_alignment
+        current_row += 1
+        ws.cell(row=current_row, column=1, value="Matched Accounts Count:")
+        ws.cell(row=current_row, column=2, value=note_data.get('matched_accounts_count', 0))
+        ws.cell(row=current_row, column=2).alignment = right_alignment
+        current_row += 1
+
+    # Auto-adjust column widths
+    for column in ws.columns:
+        max_length = 0
+        column_letter = get_column_letter(column[0].column)
+        for cell in column:
+            try:
+                if len(str(cell.value)) > max_length:
+                    max_length = len(str(cell.value))
+            except Exception:
+                pass
+        adjusted_width = min(max_length + 2, 60)
+        ws.column_dimensions[column_letter].width = adjusted_width
+
+def convert_json_to_excel(input_file: str, output_file: str) -> bool:
+    """Main function to convert JSON to Excel."""
+    json_data = read_json_file(input_file)
+    if json_data is None:
+        return False
+
+    # Normalize if needed
+    if isinstance(json_data, dict) and "notes" not in json_data:
+        normalized_note = normalize_llm_note_json(json_data)
+        json_data = {"notes": [normalized_note]}
+    elif isinstance(json_data, list):
+        json_data = {"notes": json_data}
+
+    workbook = Workbook()
+    default_sheet = workbook.active
+    workbook.remove(default_sheet)
+
+    if 'notes' in json_data:
+        notes_data = json_data['notes']
+        for note in notes_data:
+            try:
+                validated_note = NoteData(**note)
+            except ValidationError as ve:
+                logger.warning(f"Validation error for note: {ve}")
+                validated_note = note  # fallback to raw dict
+            note_title = note.get('full_title', note.get('note_title', f"Note {note.get('note_number', '')}"))
+            clean_sheet_name = str(note_title).replace('/', '_').replace('\\', '_').replace('*', '_')
+            clean_sheet_name = clean_sheet_name.replace('?', '_').replace('[', '_').replace(']', '_')
+            clean_sheet_name = clean_sheet_name[:31]
+            logger.info(f"Processing: {clean_sheet_name}")
+            create_financial_table_sheet(workbook, clean_sheet_name, note)
+    else:
+        for note_key, note_data in json_data.items():
+            clean_sheet_name = str(note_key).replace('/', '_').replace('\\', '_').replace('*', '_')
+            clean_sheet_name = clean_sheet_name.replace('?', '_').replace('[', '_').replace(']', '_')
+            clean_sheet_name = clean_sheet_name[:31]
+            logger.info(f"Processing: {clean_sheet_name}")
+            if isinstance(note_data, dict):
+                create_financial_table_sheet(workbook, clean_sheet_name, note_data)
+            else:
+                simple_data = {"value": note_data}
+                create_financial_table_sheet(workbook, clean_sheet_name, simple_data)
+
+    try:
+        workbook.save(output_file)
+        logger.info(f"Successfully saved Excel file: {output_file}")
+        return True
+    except Exception as e:
+        logger.error(f"Error saving Excel file: {e}")
+        return False
+
+def json_to_xlsx(input_json: str, output_xlsx: str) -> None:
+    """
+    Convert the given JSON file to Excel using the existing logic.
+    """
+    convert_json_to_excel(input_json, output_xlsx)
+
+def main() -> None:
+    """Main execution function."""
+    input_file = settings.input_file
+    output_folder = settings.output_folder
+    output_file = os.path.join(output_folder, settings.output_file)
+    create_output_folder(output_folder)
+
+    if not os.path.exists(input_file):
+        logger.error(f"Input file '{input_file}' not found. Please ensure the file exists in the correct location.")
+        return
+
+    success = convert_json_to_excel(input_file, output_file)
+
+    if success:
+        logger.info("=" * 50)
+        logger.info("CONVERSION COMPLETED SUCCESSFULLY!")
+        logger.info("=" * 50)
+        logger.info(f"Input file: {input_file}")
+        logger.info(f"Output file: {output_file}")
+        logger.info("The Excel file has been created with:")
+        logger.info("- Each note as a separate sheet")
+        logger.info("- Proper financial table formatting")
+        logger.info("- Table data displayed in tabular format")
+        logger.info("- Breakdown and account details included")
+        logger.info("- Professional styling and formatting")
+    else:
+        logger.error("=" * 50)
+        logger.error("CONVERSION FAILED!")
+        logger.error("=" * 50)
+        logger.error("Please check the error messages above.")
+
+if __name__ == "__main__":
+    main()

app/loader.py

@@ -0,0 +1,57 @@
+import os
+import json
+import logging
+import pandas as pd
+from typing import Any
+from pydantic import BaseModel, ValidationError
+from pydantic_settings import BaseSettings
+from app.utils import clean_value
+
+# Configure logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+class Settings(BaseSettings):
+    """Application settings loaded from environment variables or .env file."""
+    trial_balance_json: str = "output1/parsed_trial_balance.json"
+
+settings = Settings()
+
+class TrialBalanceRecord(BaseModel):
+    account_name: str
+    amount: float
+    group: str
+
+def load_trial_balance() -> pd.DataFrame:
+    """
+    Load trial balance data from a JSON file, validate with Pydantic, and return as a cleaned DataFrame.
+    Raises FileNotFoundError if the file does not exist.
+    """
+    json_file = settings.trial_balance_json
+    if not os.path.exists(json_file):
+        logger.error(f"{json_file} not found! Please run the data extraction step first.")
+        raise FileNotFoundError(f"{json_file} not found! Please run the data extraction step first.")
+
+    with open(json_file, "r", encoding="utf-8") as f:
+        parsed_data = json.load(f)
+
+    # Determine the structure and load into DataFrame
+    if isinstance(parsed_data, list):
+        records = parsed_data
+    else:
+        records = parsed_data.get("trial_balance", parsed_data)
+
+    validated_records = []
+    for record in records:
+        try:
+            validated = TrialBalanceRecord(**record)
+            validated_dict = validated.dict()
+        except ValidationError as ve:
+            logger.warning(f"Validation error for record: {ve}")
+            validated_dict = record  # fallback to raw dict
+        validated_records.append(validated_dict)
+
+    tb_df = pd.DataFrame(validated_records)
+    tb_df['amount'] = tb_df['amount'].apply(clean_value)
+    logger.info(f"Loaded trial balance with {len(tb_df)} records.")
+    return tb_df

app/main.py

@@ -0,0 +1,23 @@
+from fastapi import FastAPI
+from app.api import router
+import logging
+
+# Configure logging for the application
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger("financial_notes_api")
+
+app = FastAPI(
+    title="Financial Notes Generator API",
+    description="API for generating financial notes, balance sheets, cash flow statements, and P&L reports.",
+    version="1.0.0"
+)
+
+app.include_router(router)
+
+@app.on_event("startup")
+async def startup_event():
+    logger.info("Financial Notes Generator API has started.")
+
+@app.on_event("shutdown")
+async def shutdown_event():
+    logger.info("Financial Notes Generator API is shutting down.")

app/main16_23.py

@@ -0,0 +1,906 @@
+import os
+import json
+import logging
+from datetime import datetime
+from typing import Any, Dict, List, Optional
+import pandas as pd
+from pydantic import BaseModel, ValidationError
+from pydantic_settings import BaseSettings
+
+# Configure logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+class Settings(BaseSettings):
+    """Application settings loaded from environment variables or .env file."""
+    trial_balance_json: str = "output1/parsed_trial_balance.json"
+    output_json: str = "output2/notes_output.json"
+    output_md: str = "output2/financial_notes_all.md"
+    company_name: str = "Company Name"
+    financial_year: str = "2024-03-31"
+
+settings = Settings()
+
+class MatchedAccount(BaseModel):
+    account: str
+    amount: float
+    amount_lakhs: float
+    group: str
+
+class NoteStructure(BaseModel):
+    note_number: str
+    note_title: str
+    full_title: str
+    total_amount: float
+    total_amount_lakhs: float
+    matched_accounts_count: int
+    matched_accounts: List[MatchedAccount]
+    breakdown: Dict[str, Any]
+    table_data: List[Dict[str, Any]]
+    comparative_data: Dict[str, Any]
+    notes_and_disclosures: List[str]
+    markdown_content: str
+
+def clean_value(value: Any) -> float:
+    """Clean and convert value to float."""
+    try:
+        if isinstance(value, str):
+            value = value.replace(',', '').strip()
+        return float(value) if value else 0.0
+    except (ValueError, TypeError):
+        return 0.0
+
+def to_lakhs(value: float) -> float:
+    """Convert value to lakhs."""
+    return round(value / 100000, 2)
+
+def find_account_col(df: pd.DataFrame) -> str:
+    """Find the account column in DataFrame."""
+    for col in df.columns:
+        if df[col].astype(str).str.contains('account|particulars|name', case=False, na=False).any():
+            return col
+    return df.columns[0]
+
+def find_balance_col(df: pd.DataFrame) -> Optional[str]:
+    """Find the balance column in DataFrame."""
+    for col in df.columns:
+        if df[col].dtype in [float, int] and df[col].notna().any():
+            return col
+    return df.columns[1] if len(df.columns) > 1 else None
+
+def calculate_note(
+    df: pd.DataFrame,
+    note_name: str,
+    keywords: List[str],
+    exclude: Optional[List[str]] = None
+) -> Dict[str, Any]:
+    """Calculate total and matched accounts for a note."""
+    account_col = 'account_name' if 'account_name' in df.columns else find_account_col(df)
+    balance_col = 'amount' if 'amount' in df.columns else find_balance_col(df)
+    if not balance_col:
+        return {'total': 0, 'matched_accounts': []}
+    df = df.fillna(0)
+    total = 0
+    matched_accounts = []
+    for idx, row in df.iterrows():
+        account_name = str(row[account_col]).strip().lower()
+        if any(kw.lower() in account_name for kw in keywords) and (not exclude or not any(ex.lower() in account_name for ex in exclude)):
+            amount = clean_value(row[balance_col])
+            total += amount
+            matched_accounts.append({
+                'account': str(row[account_col]),
+                'amount': amount,
+                'amount_lakhs': to_lakhs(amount),
+                'group': row.get('group', 'Unknown') if 'group' in df.columns else 'Unknown'
+            })
+    return {'total': total, 'matched_accounts': matched_accounts}
+
+def parse_markdown_table(content: str) -> List[Dict[str, Any]]:
+    """Parse markdown table content into list of dicts."""
+    lines = [line.strip() for line in content.strip().splitlines() if line.strip()]
+    table_lines = [line for line in lines if "|" in line and not line.startswith("|--")]
+    if not table_lines:
+        return []
+    table_data = []
+    for line in table_lines:
+        cells = [cell.strip() for cell in line.split("|") if cell.strip()]
+        if len(cells) >= 2:
+            row_data = {
+                "particulars": cells[0],
+                "current_year": cells[1] if len(cells) > 1 else "",
+                "previous_year": cells[2] if len(cells) > 2 else ""
+            }
+            table_data.append(row_data)
+    return table_data
+
+def create_detailed_note_structure(
+    note_name: str,
+    result: Dict[str, Any],
+    content: str,
+    special_data: Optional[Dict[str, Any]] = None
+) -> Dict[str, Any]:
+    """Create detailed note structure for output."""
+    note_number = note_name.split('.')[0] if '.' in note_name else note_name
+    note_title = note_name.split('.', 1)[1].strip() if '.' in note_name else note_name
+    table_data = parse_markdown_table(content)
+    matched_accounts = []
+    for acc in result.get('matched_accounts', []):
+        matched_accounts.append({
+            "account": acc['account'],
+            "amount": acc['amount'],
+            "amount_lakhs": to_lakhs(acc['amount']),
+            "group": acc.get('group', 'Unknown')
+        })
+    note_structure = {
+        "note_number": note_number,
+        "note_title": note_title,
+        "full_title": note_name,
+        "total_amount": result['total'],
+        "total_amount_lakhs": to_lakhs(result['total']),
+        "matched_accounts_count": len(matched_accounts),
+        "matched_accounts": matched_accounts,
+        "breakdown": special_data.get('breakdown', {}) if special_data else {},
+        "table_data": table_data,
+        "comparative_data": {
+            "current_year": {"year": settings.financial_year, "amount": result['total'], "amount_lakhs": to_lakhs(result['total'])},
+            "previous_year": {"year": "2023-03-31", "amount": 0, "amount_lakhs": 0}
+        },
+        "notes_and_disclosures": [],
+        "markdown_content": f"### {note_name}\n\n{content}\n\n**Account-wise breakdown:**\n"
+    }
+    for acc in matched_accounts:
+        note_structure["markdown_content"] += f"- {acc['account']}: ₹{acc['amount']:,.2f} ({acc['amount_lakhs']} Lakhs)\n"
+    if special_data:
+        note_structure.update(special_data)
+    return note_structure
+
+def generate_notes(tb_df: pd.DataFrame) -> Dict[str, Any]:
+    """
+    Generate notes 16-26 from parsed trial balance data.
+    Returns a dict with metadata and notes.
+    """
+    notes = []
+    note_mappings = {
+        '2. Share Capital': {'keywords': ['Share Capital', 'share capital', 'equity share', 'paid up']},
+        '3. Reserves and Surplus': {'keywords': ['Reserves', 'Surplus', 'reserves', 'surplus', 'retained earnings']},
+        '4. Long Term Borrowings': {'keywords': ['loan', 'borrowing', 'term loan'], 'exclude': ['current maturities', 'short term']},
+        '5. Deferred Tax Liability': {'keywords': ['Deferred Tax', 'deferred tax']},
+        '6. Trade Payables': {'keywords': ['Creditors', 'creditors', 'trade payable', 'suppliers']},
+        '7. Other Current Liabilities': {'keywords': ['Expenses Payable', 'Current Maturities', 'payable', 'accrued']},
+        '8. Short Term Provisions': {'keywords': ['Provision', 'provision', 'taxation']},
+        '9. Fixed Assets': {'keywords': ['Equipment', 'Furniture', 'Building', 'Vehicle', 'Motor', 'Asset', 'plant', 'machinery']},
+        '10. Long Term Loans and Advances': {'keywords': ['Long Term', 'Security Deposits', 'advances', 'deposits']},
+        '11. Inventories': {'keywords': ['Stock', 'Inventory', 'stock', 'inventory', 'goods']},
+        '12. Trade Receivables': {'keywords': ['Receivables', 'receivables', 'debtors', 'trade receivable']},
+        '13. Cash and Bank Balances': {'keywords': ['Cash-in-hand', 'Bank accounts', 'Deposits']},
+        '14. Short Term Loans and Advances': {'keywords': ['Prepaid Expenses', 'TDS Receivables', 'Loans & Advances', 'TCS RECEIVABLES', 'TDS Advance Tax Paid', 'Advance to Perennail']},
+        '15. Other Current Assets': {'keywords': ['Interest accrued', 'accrued', 'current asset']},
+        '16. Revenue from Operations': {
+            'keywords': ['Revenue', 'Sales', 'Service', 'Income', 'Consultancy', 'Gain / Loss on Sales of Fixed Assets', 'Income Tax',
+                         'Servicing of BA/BE PROJECTS', 'Working Standards - Export', 'SERVICING OF BA PROJECTS', 'SERVICING OF ONLY CLINICAL']
+        },
+        '17. Other Income': {
+            'keywords': ['Interest on FD', 'Interest on Income Tax Refund', 'Unadjusted Forex Gain/Loss', 'Forex Gain / Loss', 'Interest']
+        },
+        '18. Cost of Materials Consumed': {
+            'keywords': ['Opening Stock', 'Bio Lab Consumables', 'Non GST', 'Purchase GST', 'Closing Stock']
+        },
+        '19. Employee Benefit Expense': {
+            'keywords': ['Salary', 'Wages', 'Bonus', 'Employee', 'Remuneration', 'Comp Offs', 'Retainership', 
+                         'Employees Group Life Insurance', 'Employees Health & Personal Accident Insurance', 
+                         'Prepaid - Employees Group Life Insurance', 'Prepaid Insurance - Employees Health & Personal Accident', 
+                         'Staff Welfare Expenses', 'Employees Expenses Reimbursement', 'Contribution to PF', 'Contribution to ESI']
+        },
+        '20. Other Expenses': {
+            'keywords': ['BA / BE NOC', 'BA Expenses', 'Payments to Volunteers', 'Other Operating Expenses', 'Laboratory testing', 
+                         'Rent', 'Rates & Taxes', 'Fees & licenses', 'Insurance', 'Membership & Subscription', 
+                         'Postage & Communication', 'Printing and Stationery', 'CSR Fund', 'Telephone & Internet', 
+                         'Travelling and Conveyance', 'Translation Charges', 'Electricity Charges', 'Security Charges', 
+                         'Annual Maintenance', 'Repairs and maintenance', 'Business Development', 'Professional & Consultancy', 
+                         'Payment to Auditors', 'Bad Debts', 'Fire Extinguishers', 'Food Expenses', 'Diesel Expenses', 
+                         'Interest Under 234 C', 'Loan Processing Charges', 'Sitting Fee of Directors', 'Customs Duty', 
+                         'Transportation and Unloading', 'Software Equipment', 'Miscellaneous expenses', 'Laptop Accessories', 
+                         'Professional Fee', 'Office Rent', 'Security Deposit']
+        },
+        '21. Depreciation and Amortisation Expense': {
+            'keywords': ['Depreciation', 'Amortization', 'Accumulated Depreciation', 'Depreciation And Amortisation']
+        },
+        '22. Loss on Sale of Assets & Investments': {
+            'keywords': ['Short Term Loss', 'Long term loss', 'Loss on Sale of Fixed Assets', 'Loss on Sale of Investments']
+        },
+        '23. Finance Costs': {
+            'keywords': ['Bank Charges', 'Finance Charges', 'Interest', 'Loan Processing', 'Interest and penalty', 'Interest on TDS']
+        },
+        '24. Payment to Auditor': {
+            'keywords': ['Payment to Auditors', 'Audit Fee', 'Tax Audit', 'Certification Fees']
+        },
+        '25. Earnings in Foreign Currency': {
+            'keywords': ['Income from export of services', 'Servicing of BA/BE PROJECTS EXPORT', 'Working Standards - Export']
+        },
+        '26. Particulars of Un-hedged Foreign Currency Exposure': {
+            'keywords': ['Income from export of services', 'Servicing of BA/BE PROJECTS EXPORT', 'Working Standards - Export']
+        }
+    }
+
+    logger.info("Generating notes 16-26 from parsed trial balance data...")
+    logger.info(f"Total records in trial balance: {len(tb_df)}")
+    
+    for note_name, mapping in note_mappings.items():
+        keywords = mapping['keywords']
+        result = calculate_note(tb_df, note_name, keywords)
+
+        if result['matched_accounts']:
+            logger.info(f"\n{note_name}:")
+            logger.info(f"   Total: ₹{result['total']:,.2f} ({to_lakhs(result['total'])} Lakhs)")
+            logger.info(f"   Matched {len(result['matched_accounts'])} accounts:")
+            for acc in result['matched_accounts'][:3]:
+                logger.info(f"      • {acc['account']}: ₹{acc['amount']:,.2f}")
+            if len(result['matched_accounts']) > 3:
+                logger.info(f"      ... and {len(result['matched_accounts']) - 3} more")
+        else:
+            logger.warning(f"\n{note_name}: No matching accounts found")
+
+        content = ""
+        special_data = {}
+        
+        if note_name == '2. Share Capital':
+            content = """
+| Particulars                  | 2024-03-31 | 2023-03-31 |
+|------------------------------|------------|------------|
+| **Authorised shares**        |            |            |
+| 75,70,000 equity shares of ₹ 10/- each | 757.0 | 757.0 |
+| **Issued, subscribed and fully paid-up shares** | | |
+| 54,25,210 equity shares of ₹ 10/- each | {total_lakhs} | 542.52 |
+| **Total issued, subscribed and fully paid-up share capital** | {total_lakhs} | 542.52 |
+""".format(total_lakhs=to_lakhs(result['total']))
+            special_data = {
+                "breakdown": {
+                    "authorised_shares": {"description": "75,70,000 equity shares of ₹ 10/- each", "amount": 75700000, "amount_lakhs": 757.0},
+                    "issued_subscribed_paid_up": {"description": "54,25,210 equity shares of ₹ 10/- each", "amount": result['total'], "amount_lakhs": to_lakhs(result['total'])}
+                }
+            }
+        
+        elif note_name == '3. Reserves and Surplus':
+            content = """
+| Particulars                  | March 31, 2024 | March 31, 2023 |
+|------------------------------|----------------|----------------|
+| Reserves and Surplus         | {total_lakhs} | - |
+""".format(total_lakhs=to_lakhs(result['total']))
+        
+        elif note_name == '4. Long Term Borrowings':
+            content = """
+| Particulars                  | March 31, 2024 | March 31, 2023 |
+|------------------------------|----------------|----------------|
+| Long Term Borrowings         | {total_lakhs} | - |
+""".format(total_lakhs=to_lakhs(result['total']))
+        
+        elif note_name == '5. Deferred Tax Liability':
+            content = """
+| Particulars                  | March 31, 2024 | March 31, 2023 |
+|------------------------------|----------------|----------------|
+| Deferred Tax Liability       | {total_lakhs} | - |
+""".format(total_lakhs=to_lakhs(result['total']))
+        
+        elif note_name == '6. Trade Payables':
+            content = """
+| Particulars                  | March 31, 2024 | March 31, 2023 |
+|------------------------------|----------------|----------------|
+| Trade Payables               | {total_lakhs} | - |
+""".format(total_lakhs=to_lakhs(result['total']))
+        
+        elif note_name == '7. Other Current Liabilities':
+            expenses_payable = calculate_note(tb_df, note_name, ['Expenses Payable', 'payable', 'accrued'])['total']
+            current_maturities = calculate_note(tb_df, note_name, ['Current Maturities', 'current portion'])['total']
+            statutory_dues = 7935166.72
+            content = """
+| Particulars                  | March 31, 2024 | March 31, 2023 |
+|------------------------------|----------------|----------------|
+| Current Maturities of Long Term Borrowings | {cm_lakhs} | 139.20 |
+| Outstanding Liabilities for Expenses | {ep_lakhs} | 156.88 |
+| Statutory dues               | {sd_lakhs} | 48.03 |
+| **Total**                    | {total_lakhs} | 344.12 |
+""".format(cm_lakhs=to_lakhs(current_maturities), ep_lakhs=to_lakhs(expenses_payable), sd_lakhs=to_lakhs(statutory_dues), total_lakhs=to_lakhs(current_maturities + expenses_payable + statutory_dues))
+            special_data = {
+                "breakdown": {
+                    "current_maturities": {"description": "Current Maturities of Long Term Borrowings", "amount": current_maturities, "amount_lakhs": to_lakhs(current_maturities)},
+                    "expenses_payable": {"description": "Outstanding Liabilities for Expenses", "amount": expenses_payable, "amount_lakhs": to_lakhs(expenses_payable)},
+                    "statutory_dues": {"description": "Statutory dues", "amount": statutory_dues, "amount_lakhs": to_lakhs(statutory_dues)}
+                }
+            }
+        
+        elif note_name == '8. Short Term Provisions':
+            content = """
+| Particulars                  | March 31, 2024 | March 31, 2023 |
+|------------------------------|----------------|----------------|
+| Short Term Provisions        | {total_lakhs} | - |
+""".format(total_lakhs=to_lakhs(result['total']))
+        
+        elif note_name == '9. Fixed Assets':
+            equipments = calculate_note(tb_df, note_name, ['Equipment', 'equipment'])['total']
+            furniture = calculate_note(tb_df, note_name, ['Furniture', 'furniture', 'fixture'])['total']
+            building = calculate_note(tb_df, note_name, ['Building', 'building'])['total']
+            vehicle = calculate_note(tb_df, note_name, ['Vehicle', 'vehicle', 'car'])['total']
+            content = """
+| Particulars                  | Gross Carrying Value | Accumulated Depreciation | Net Carrying Value |
+|------------------------------|----------------------|--------------------------|--------------------|
+| As at 1st April 2023 | Additions | Deletion | As at 31st March 2024 | As at 1st April 2023 | For the year | Deletion | As at 31st March 2024 | As at 31st March 2024 | As at 1st April 2023 |
+|------------------------------|----------------------|--------------------------|--------------------|
+| Tangible Assets              |                      |                          |                    |
+| Buildings                    | 312.66 | {bldg_add} | 0 | {bldg_gcv} | 312.65 | 1478.81 | 0 | 1791.46 | {bldg_ncv} | 1.00 |
+| Equipments                   | {eq_gcv} | 0 | 0 | {eq_gcv} | 0 | 0 | 0 | 0 | {eq_ncv} | {eq_ncv} |
+| Furniture & Fixtures         | {fur_gcv} | 0 | 0 | {fur_gcv} | 0 | 0 | 0 | 0 | {fur_ncv} | {fur_ncv} |
+| Motor Vehicle                | {veh_gcv} | 0 | 0 | {veh_gcv} | 0 | 752.98 | 0 | 752.98 | {veh_ncv} | {veh_gcv} |
+""".format(bldg_add=to_lakhs(building), bldg_gcv=to_lakhs(312655 + building), bldg_ncv=to_lakhs(building), eq_gcv=to_lakhs(equipments), eq_ncv=to_lakhs(equipments), fur_gcv=to_lakhs(furniture), fur_ncv=to_lakhs(furniture), veh_gcv=to_lakhs(vehicle), veh_ncv=to_lakhs(vehicle - 752982.45))
+            special_data = {
+                "breakdown": {
+                    "buildings": {"gross_value": 312655 + building, "net_value": building, "accumulated_depreciation": 1791462},
+                    "equipments": {"gross_value": equipments, "net_value": equipments, "accumulated_depreciation": 0},
+                    "furniture_fixtures": {"gross_value": furniture, "net_value": furniture, "accumulated_depreciation": 0},
+                    "motor_vehicle": {"gross_value": vehicle, "net_value": vehicle - 752982.45, "accumulated_depreciation": 752982.45}
+                }
+            }
+        
+        elif note_name == '10. Long Term Loans and Advances':
+            content = """
+| Particulars                  | March 31, 2024 | March 31, 2023 |
+|------------------------------|----------------|----------------|
+| Long Term Loans and Advances | {total_lakhs} | - |
+""".format(total_lakhs=to_lakhs(result['total']))
+        
+        elif note_name == '11. Inventories':
+            content = """
+| Particulars                  | March 31, 2024 | March 31, 2023 |
+|------------------------------|----------------|----------------|
+| Consumables                  | {total_lakhs} | - |
+""".format(total_lakhs=to_lakhs(result['total']))
+        
+        elif note_name == '12. Trade Receivables':
+            over_6m = result.get('over_6m', 0)
+            content = """
+| Particulars                  | 2024-03-31 | 2023-03-31 |
+|------------------------------|------------|------------|
+| Unsecured, considered good   |            |            |
+| Outstanding for a period exceeding six months | {over_6m} | 104.65 |
+| Total                        | {total_lakhs} | 1037.59 |
+""".format(over_6m=to_lakhs(over_6m), total_lakhs=to_lakhs(result['total']))
+            special_data = {
+                "breakdown": {
+                    "over_six_months": {"description": "Outstanding for a period exceeding six months", "amount": over_6m, "amount_lakhs": to_lakhs(over_6m)},
+                    "total_receivables": {"description": "Total Trade Receivables", "amount": result['total'], "amount_lakhs": to_lakhs(result['total'])}
+                }
+            }
+        
+        elif note_name == '13. Cash and Bank Balances':
+            cash_in_hand = calculate_note(tb_df, note_name, ['Cash-in-hand'])['total']
+            bank_accounts = calculate_note(tb_df, note_name, ['Bank accounts'])['total']
+            fixed_deposit = calculate_note(tb_df, note_name, ['Deposits'])['total']
+            total = cash_in_hand + bank_accounts + fixed_deposit
+            content = """
+| Particulars                  | March 31, 2024 | March 31, 2023 |
+|------------------------------|----------------|----------------|
+| **Cash and cash equivalents**|                |                |
+| Balances with banks in current accounts | {ba_lakhs} | - |
+| Cash in hand                 | {cih_lakhs} | - |
+| **Other Bank Balances**      |                |                |
+| Fixed Deposit                | {fd_lakhs} | - |
+| **Total**                    | {total_lakhs} | - |
+""".format(ba_lakhs=to_lakhs(bank_accounts), cih_lakhs=to_lakhs(cash_in_hand), fd_lakhs=to_lakhs(fixed_deposit), total_lakhs=to_lakhs(total))
+            result['total'] = total
+            special_data = {
+                "breakdown": {
+                    "cash_in_hand": {"description": "Cash in hand", "amount": cash_in_hand, "amount_lakhs": to_lakhs(cash_in_hand)},
+                    "bank_balances": {"description": "Balances with banks in current accounts", "amount": bank_accounts, "amount_lakhs": to_lakhs(bank_accounts)},
+                    "fixed_deposits": {"description": "Fixed Deposit", "amount": fixed_deposit, "amount_lakhs": to_lakhs(fixed_deposit)}
+                }
+            }
+        
+        elif note_name == '14. Short Term Loans and Advances':
+            other_advances = calculate_note(tb_df, note_name, ['Loans & Advances'])['total']
+            prepaid_expenses = calculate_note(tb_df, note_name, ['Prepaid Expenses'])['total']
+            advance_tax = calculate_note(tb_df, note_name, ['TDS Advance Tax Paid'])['total']
+            balances = calculate_note(tb_df, note_name, ['TDS Receivables'])['total']
+            total = other_advances + prepaid_expenses + advance_tax + balances
+            content = """
+| Particulars                  | March 31, 2024 | March 31, 2023 |
+|------------------------------|----------------|----------------|
+| **Unsecured, considered good**|                |                |
+| Prepaid Expenses             | {pe_lakhs} | - |
+| Other Advances               | {oa_lakhs} | - |
+| **Other loans and advances** |                |                |
+| Advance tax                  | {at_lakhs} | - |
+| Balances with statutory/government authorities | {bs_lakhs} | - |
+| **Total**                    | {total_lakhs} | - |
+""".format(pe_lakhs=to_lakhs(prepaid_expenses), oa_lakhs=to_lakhs(other_advances), at_lakhs=to_lakhs(advance_tax), bs_lakhs=to_lakhs(balances), total_lakhs=to_lakhs(total))
+            result['total'] = total
+            special_data = {
+                "breakdown": {
+                    "prepaid_expenses": {"description": "Prepaid Expenses", "amount": prepaid_expenses, "amount_lakhs": to_lakhs(prepaid_expenses)},
+                    "other_advances": {"description": "Other Advances", "amount": other_advances, "amount_lakhs": to_lakhs(other_advances)},
+                    "advance_tax": {"description": "Advance tax", "amount": advance_tax, "amount_lakhs": to_lakhs(advance_tax)},
+                    "statutory_balances": {"description": "Balances with statutory/government authorities", "amount": balances, "amount_lakhs": to_lakhs(balances)}
+                }
+            }
+        
+        elif note_name == '15. Other Current Assets':
+            content = """
+| Particulars                  | March 31, 2024 | March 31, 2023 |
+|------------------------------|----------------|----------------|
+| Other Current Assets         | {total_lakhs} | - |
+""".format(total_lakhs=to_lakhs(result['total']))
+            
+        elif note_name == '16. Revenue from Operations':
+            servicing_babe_export = calculate_note(tb_df, note_name, ['Servicing of BA/BE PROJECTS EXPORT'])['total']
+            working_standards_export = calculate_note(tb_df, note_name, ['Working Standards - Export'])['total']
+            exports = servicing_babe_export + working_standards_export
+            servicing_babe_inter_state = calculate_note(tb_df, note_name, ['Servicing of BA/BE PROJECTS-Inter State'])['total']
+            servicing_babe_intra_state = calculate_note(tb_df, note_name, ['Servicing of BA/BE PROJECTS-Intra State'])['total']
+            servicing_ba_intra_state = calculate_note(tb_df, note_name, ['SERVICING OF BA PROJECTS-Intra State'])['total']
+            servicing_clinical_intra_state = calculate_note(tb_df, note_name, ['SERVICING OF ONLY CLINICAL INTRA STATE'])['total']
+            domestic = servicing_babe_inter_state + servicing_babe_intra_state + servicing_ba_intra_state + servicing_clinical_intra_state
+            sales_other = calculate_note(tb_df, note_name, ['Sales', 'Gain / Loss on Sales of Fixed Assets', 'Consultancy & Service Fee', 'Income', 'Income Tax'])['total']
+            total = result['total']  # Use total from calculate_note
+            content = """
+| Particulars                  | March 31, 2024 | March 31, 2023 |
+|------------------------------|----------------|----------------|
+| **Sale of Services**         |                |                |
+| Domestic                     | {dom_lakhs}    | -              |
+| Exports                      | {exp_lakhs}    | -              |
+| Sales and Other Income       | {sales_lakhs}  | -              |
+| **Total**                    | {total_lakhs}  | -              |
+""".format(dom_lakhs=to_lakhs(domestic), exp_lakhs=to_lakhs(exports), sales_lakhs=to_lakhs(sales_other), total_lakhs=to_lakhs(total))
+            special_data = {
+                "breakdown": {
+                    "domestic_revenue": {"description": "Domestic Sales", "amount": domestic, "amount_lakhs": to_lakhs(domestic), "components": {
+                        "ba_be_interstate": servicing_babe_inter_state,
+                        "ba_be_intrastate": servicing_babe_intra_state,
+                        "ba_intrastate": servicing_ba_intra_state,
+                        "clinical_intrastate": servicing_clinical_intra_state
+                    }},
+                    "export_revenue": {"description": "Export Sales", "amount": exports, "amount_lakhs": to_lakhs(exports), "components": {
+                        "ba_be_export": servicing_babe_export,
+                        "working_standards_export": working_standards_export
+                    }},
+                    "sales_and_other": {"description": "Sales and Other Income", "amount": sales_other, "amount_lakhs": to_lakhs(sales_other)}
+                }
+            }
+        
+        elif note_name == '17. Other Income':
+            interest_income = calculate_note(tb_df, note_name, ['Interest on FD', 'Interest on Income Tax Refund', 'Interest'])['total']
+            forex_gain = calculate_note(tb_df, note_name, ['Unadjusted Forex Gain/Loss', 'Forex Gain / Loss'])['total']
+            total = result['total']  # Use total from calculate_note
+            content = """
+| Particulars                  | March 31, 2024 | March 31, 2023 |
+|------------------------------|----------------|----------------|
+| Interest income              | {ii_lakhs}     | -              |
+| Foreign exchange gain (Net)  | {fg_lakhs}     | -              |
+| **Total**                    | {total_lakhs}  | -              |
+""".format(ii_lakhs=to_lakhs(interest_income), fg_lakhs=to_lakhs(forex_gain), total_lakhs=to_lakhs(total))
+            special_data = {
+                "breakdown": {
+                    "interest_income": {"description": "Interest income", "amount": interest_income, "amount_lakhs": to_lakhs(interest_income)},
+                    "forex_gain": {"description": "Foreign exchange gain (Net)", "amount": forex_gain, "amount_lakhs": to_lakhs(forex_gain)}
+                }
+            }
+        
+        elif note_name == '18. Cost of Materials Consumed':
+            opening_stock = calculate_note(tb_df, note_name, ['Opening Stock'])['total']
+            purchases = calculate_note(tb_df, note_name, ['Bio Lab Consumables', 'Non GST', 'Purchase GST'])['total']
+            closing_stock = calculate_note(tb_df, note_name, ['Closing Stock'])['total']
+            total = opening_stock + purchases - closing_stock  # As per note structure
+            content = """
+| Particulars                  | March 31, 2024 | March 31, 2023 |
+|------------------------------|----------------|----------------|
+| Opening Stock                | {os_lakhs}     | -              |
+| Add: Purchases               | {pur_lakhs}    | -              |
+|                              | {subtotal_lakhs}| -             |
+| Less: Closing Stock          | {cs_lakhs}     | -              |
+| Cost of materials consumed   | {total_lakhs}  | -              |
+""".format(os_lakhs=to_lakhs(opening_stock), pur_lakhs=to_lakhs(purchases), subtotal_lakhs=to_lakhs(opening_stock + purchases), 
+           cs_lakhs=to_lakhs(closing_stock), total_lakhs=to_lakhs(total))
+            special_data = {
+                "breakdown": {
+                    "opening_stock": {"description": "Opening Stock", "amount": opening_stock, "amount_lakhs": to_lakhs(opening_stock)},
+                    "purchases": {"description": "Purchases", "amount": purchases, "amount_lakhs": to_lakhs(purchases)},
+                    "closing_stock": {"description": "Closing Stock", "amount": closing_stock, "amount_lakhs": to_lakhs(closing_stock)},
+                    "cost_consumed": {"description": "Cost of materials consumed", "amount": total, "amount_lakhs": to_lakhs(total)}
+                }
+            }
+        
+        elif note_name == '19. Employee Benefit Expense':
+            salaries_wages_bonus = calculate_note(tb_df, note_name, ['Salary', 'Wages', 'Bonus', 'Remuneration', 'Comp Offs', 'Retainership'])['total']
+            pf_esi = calculate_note(tb_df, note_name, ['Contribution to PF', 'Contribution to ESI'])['total']
+            staff_welfare = calculate_note(tb_df, note_name, ['Staff Welfare Expenses', 'Employees Expenses Reimbursement'])['total']
+            insurance = calculate_note(tb_df, note_name, ['Employees Group Life Insurance', 'Employees Health & Personal Accident Insurance', 
+                                                         'Prepaid - Employees Group Life Insurance', 'Prepaid Insurance - Employees Health & Personal Accident'])['total']
+            total = result['total']  # Use total from calculate_note
+            content = """
+| Particulars                  | March 31, 2024 | March 31, 2023 |
+|------------------------------|----------------|----------------|
+| Salaries, wages and bonus    | {swb_lakhs}    | -              |
+| Contribution to PF & ESI     | {pf_esi_lakhs} | -              |
+| Staff welfare expenses       | {sw_lakhs}     | -              |
+| **Total**                    | {total_lakhs}  | -              |
+""".format(swb_lakhs=to_lakhs(salaries_wages_bonus), pf_esi_lakhs=to_lakhs(pf_esi), sw_lakhs=to_lakhs(staff_welfare), 
+           ins_lakhs=to_lakhs(insurance), total_lakhs=to_lakhs(total))
+            special_data = {
+                "breakdown": {
+                    "salaries_wages_bonus": {"description": "Salaries, wages and bonus", "amount": salaries_wages_bonus, "amount_lakhs": to_lakhs(salaries_wages_bonus)},
+                    "pf_esi": {"description": "Contribution to PF & ESI", "amount": pf_esi, "amount_lakhs": to_lakhs(pf_esi)},
+                    "staff_welfare": {"description": "Staff welfare expenses", "amount": staff_welfare, "amount_lakhs": to_lakhs(staff_welfare)},
+                    "insurance": {"description": "Insurance Expenses", "amount": insurance, "amount_lakhs": to_lakhs(insurance)}
+                }
+            }
+        
+        elif note_name == '20. Other Expenses':
+            ba_be_noc = calculate_note(tb_df, note_name, ['BA / BE NOC Charges'])['total']
+            ba_expenses = calculate_note(tb_df, note_name, ['BA Expenses'])['total']
+            volunteers = calculate_note(tb_df, note_name, ['Payments to Volunteers'])['total']
+            other_operating = calculate_note(tb_df, note_name, ['Other Operating Expenses'])['total']
+            lab_testing = calculate_note(tb_df, note_name, ['Laboratory testing charges'])['total']
+            rent = calculate_note(tb_df, note_name, ['Rent', 'Office Rent'])['total']
+            rates_taxes = calculate_note(tb_df, note_name, ['Rates & Taxes'])['total']
+            fees_licenses = calculate_note(tb_df, note_name, ['Fees & licenses'])['total']
+            insurance = calculate_note(tb_df, note_name, ['Insurance'])['total']
+            membership = calculate_note(tb_df, note_name, ['Membership & Subscription Charges'])['total']
+            postage = calculate_note(tb_df, note_name, ['Postage & Communication Cost'])['total']
+            printing = calculate_note(tb_df, note_name, ['Printing and Stationery'])['total']
+            csr = calculate_note(tb_df, note_name, ['CSR Fund Expenses'])['total']
+            telephone = calculate_note(tb_df, note_name, ['Telephone & Internet', 'Telephone Expense'])['total']
+            travelling = calculate_note(tb_df, note_name, ['Travelling and Conveyance'])['total']
+            translation = calculate_note(tb_df, note_name, ['Translation Charges'])['total']
+            electricity = calculate_note(tb_df, note_name, ['Electricity Charges'])['total']
+            security = calculate_note(tb_df, note_name, ['Security Charges', 'Security Deposit', 'Security Deposit - ESIC', 
+                                                        'Security Deposits - Awfis Space Solutions Private Limited', 
+                                                        'Security Deposits - Concept Classic Converge', 'Security Deposit - Hive Space'])['total']
+            maintenance = calculate_note(tb_df, note_name, ['Annual Maintenance Charges', 'Laptop Accessories and Maintenance', 
+                                                           'Laptop Annual Maintenance Charges'])['total']
+            repairs_electrical = calculate_note(tb_df, note_name, ['Repairs and maintenance - Electrical'])['total']
+            repairs_office = calculate_note(tb_df, note_name, ['Repairs and maintenance - Office'])['total']
+            repairs_machinery = calculate_note(tb_df, note_name, ['Repairs and maintenance - Machinery'])['total']
+            repairs_vehicles = calculate_note(tb_df, note_name, ['Repairs and maintenance - Vehicles'])['total']
+            repairs_others = calculate_note(tb_df, note_name, ['Repairs and maintenance - Others'])['total']
+            business_dev = calculate_note(tb_df, note_name, ['Business Development Expenses'])['total']
+            professional = calculate_note(tb_df, note_name, ['Professional & Consultancy', 'Professional Fee', 
+                                                            'Provision for Professional Fee', 'Professional Fee (Transfer Pricing)'])['total']
+            auditors = calculate_note(tb_df, note_name, ['Payment to Auditors'])['total']
+            bad_debts = calculate_note(tb_df, note_name, ['Bad Debts Written Off'])['total']
+            fire_extinguishers = calculate_note(tb_df, note_name, ['Fire Extinguishers Refilling Charges'])['total']
+            food_guests = calculate_note(tb_df, note_name, ['Food Expenses for Guests'])['total']
+            diesel = calculate_note(tb_df, note_name, ['Diesel Expenses'])['total']
+            interest_234c = calculate_note(tb_df, note_name, ['Interest Under 234 C'])['total']
+            loan_processing = calculate_note(tb_df, note_name, ['Loan Processing Charges'])['total']
+            sitting_fee = calculate_note(tb_df, note_name, ['Sitting Fee of Directors'])['total']
+            customs_duty = calculate_note(tb_df, note_name, ['Customs Duty Payment'])['total']
+            transportation = calculate_note(tb_df, note_name, ['Transportation and Unloading Charges'])['total']
+            software = calculate_note(tb_df, note_name, ['Software Equipment'])['total']
+            misc = calculate_note(tb_df, note_name, ['Miscellaneous expenses'])['total']
+            total = result['total']  # Use total from calculate_note
+            content = """
+| Particulars                  | March 31, 2024 | March 31, 2023 |
+|------------------------------|----------------|----------------|
+| BA / BE NOC Charges          | {ba_be_noc_lakhs} | -           |
+| BA Expenses                  | {ba_exp_lakhs} | -             |
+| Payments to Volunteers       | {vol_lakhs}    | -             |
+| Other Operating Expenses     | {oo_lakhs}     | -             |
+| Laboratory testing charges   | {lab_lakhs}    | -             |
+| Rent                         | {rent_lakhs}   | -             |
+| Rates & Taxes                | {rt_lakhs}     | -             |
+| Fees & licenses              | {fl_lakhs}     | -             |
+| Insurance                    | {ins_lakhs}    | -             |
+| Membership & Subscription Charges | {mem_lakhs}| -             |
+| Postage & Communication Cost | {post_lakhs}   | -             |
+| Printing and stationery      | {print_lakhs}  | -             |
+| CSR Fund Expenses            | {csr_lakhs}    | -             |
+| Telephone & Internet         | {tel_lakhs}    | -             |
+| Travelling and Conveyance    | {trav_lakhs}   | -             |
+| Translation Charges          | {tl_lakhs}     | -             |
+| Electricity Charges          | {elec_lakhs}   | -             |
+| Security Charges             | {sec_lakhs}    | -             |
+| Annual Maintenance Charges   | {maint_lakhs}  | -             |
+| Repairs and maintenance      |                |                |
+| - Electrical                 | {relec_lakhs}  | -             |
+| - Office                     | {roff_lakhs}   | -             |
+| - Machinery                  | {rmach_lakhs}  | -             |
+| - Vehicles                   | {rveh_lakhs}   | -             |
+| - Others                     | {roth_lakhs}   | -             |
+| Business Development Expenses| {bd_lakhs}     | -             |
+| Professional & Consultancy Fees | {prof_lakhs}| -             |
+| Payment to Auditors          | {aud_lakhs}    | -             |
+| Bad Debts Written Off        | {bd_debts_lakhs}| -            |
+| Fire Extinguishers Refilling Charges | {fire_lakhs} | -          |
+| Food Expenses for Guests     | {food_lakhs}   | -             |
+| Diesel Expenses              | {diesel_lakhs} | -             |
+| Interest Under 234 C Fy 2021-22 | {int234c_lakhs} | -         |
+| Loan Processing Charges      | {loan_lakhs}   | -             |
+| Sitting Fee of Directors     | {sit_lakhs}    | -             |
+| Customs Duty Payment         | {cust_lakhs}   | -             |
+| Transportation and Unloading Charges | {trans_lakhs} | -        |
+| Software Equipment           | {soft_lakhs}   | -             |
+| Miscellaneous expenses       | {misc_lakhs}   | -             |
+| **Total**                    | {total_lakhs}  | -             |
+""".format(ba_be_noc_lakhs=to_lakhs(ba_be_noc), ba_exp_lakhs=to_lakhs(ba_expenses), vol_lakhs=to_lakhs(volunteers), 
+           oo_lakhs=to_lakhs(other_operating), lab_lakhs=to_lakhs(lab_testing), rent_lakhs=to_lakhs(rent), 
+           rt_lakhs=to_lakhs(rates_taxes), fl_lakhs=to_lakhs(fees_licenses), ins_lakhs=to_lakhs(insurance), 
+           mem_lakhs=to_lakhs(membership), post_lakhs=to_lakhs(postage), print_lakhs=to_lakhs(printing), 
+           csr_lakhs=to_lakhs(csr), tel_lakhs=to_lakhs(telephone), trav_lakhs=to_lakhs(travelling), 
+           tl_lakhs=to_lakhs(translation), elec_lakhs=to_lakhs(electricity), sec_lakhs=to_lakhs(security), 
+           maint_lakhs=to_lakhs(maintenance), relec_lakhs=to_lakhs(repairs_electrical), roff_lakhs=to_lakhs(repairs_office), 
+           rmach_lakhs=to_lakhs(repairs_machinery), rveh_lakhs=to_lakhs(repairs_vehicles), roth_lakhs=to_lakhs(repairs_others), 
+           bd_lakhs=to_lakhs(business_dev), prof_lakhs=to_lakhs(professional), aud_lakhs=to_lakhs(auditors), 
+           bd_debts_lakhs=to_lakhs(bad_debts), fire_lakhs=to_lakhs(fire_extinguishers), food_lakhs=to_lakhs(food_guests), 
+           diesel_lakhs=to_lakhs(diesel), int234c_lakhs=to_lakhs(interest_234c), loan_lakhs=to_lakhs(loan_processing), 
+           sit_lakhs=to_lakhs(sitting_fee), cust_lakhs=to_lakhs(customs_duty), trans_lakhs=to_lakhs(transportation), 
+           soft_lakhs=to_lakhs(software), misc_lakhs=to_lakhs(misc), total_lakhs=to_lakhs(total))
+            special_data = {
+                "breakdown": {
+                    "ba_be_noc": {"description": "BA / BE NOC Charges", "amount": ba_be_noc, "amount_lakhs": to_lakhs(ba_be_noc)},
+                    "ba_expenses": {"description": "BA Expenses", "amount": ba_expenses, "amount_lakhs": to_lakhs(ba_expenses)},
+                    "volunteers": {"description": "Payments to Volunteers", "amount": volunteers, "amount_lakhs": to_lakhs(volunteers)},
+                    "other_operating": {"description": "Other Operating Expenses", "amount": other_operating, "amount_lakhs": to_lakhs(other_operating)},
+                    "lab_testing": {"description": "Laboratory testing charges", "amount": lab_testing, "amount_lakhs": to_lakhs(lab_testing)},
+                    "rent": {"description": "Rent", "amount": rent, "amount_lakhs": to_lakhs(rent)},
+                    "rates_taxes": {"description": "Rates & Taxes", "amount": rates_taxes, "amount_lakhs": to_lakhs(rates_taxes)},
+                    "fees_licenses": {"description": "Fees & licenses", "amount": fees_licenses, "amount_lakhs": to_lakhs(fees_licenses)},
+                    "insurance": {"description": "Insurance", "amount": insurance, "amount_lakhs": to_lakhs(insurance)},
+                    "membership": {"description": "Membership & Subscription Charges", "amount": membership, "amount_lakhs": to_lakhs(membership)},
+                    "postage": {"description": "Postage & Communication Cost", "amount": postage, "amount_lakhs": to_lakhs(postage)},
+                    "printing": {"description": "Printing and stationery", "amount": printing, "amount_lakhs": to_lakhs(printing)},
+                    "csr": {"description": "CSR Fund Expenses", "amount": csr, "amount_lakhs": to_lakhs(csr)},
+                    "telephone": {"description": "Telephone & Internet", "amount": telephone, "amount_lakhs": to_lakhs(telephone)},
+                    "travelling": {"description": "Travelling and Conveyance", "amount": travelling, "amount_lakhs": to_lakhs(travelling)},
+                    "translation": {"description": "Translation Charges", "amount": translation, "amount_lakhs": to_lakhs(translation)},
+                    "electricity": {"description": "Electricity Charges", "amount": electricity, "amount_lakhs": to_lakhs(electricity)},
+                    "security": {"description": "Security Charges", "amount": security, "amount_lakhs": to_lakhs(security)},
+                    "maintenance": {"description": "Annual Maintenance Charges", "amount": maintenance, "amount_lakhs": to_lakhs(maintenance)},
+                    "repairs_electrical": {"description": "Repairs and maintenance - Electrical", "amount": repairs_electrical, "amount_lakhs": to_lakhs(repairs_electrical)},
+                    "repairs_office": {"description": "Repairs and maintenance - Office", "amount": repairs_office, "amount_lakhs": to_lakhs(repairs_office)},
+                    "repairs_machinery": {"description": "Repairs and maintenance - Machinery", "amount": repairs_machinery, "amount_lakhs": to_lakhs(repairs_machinery)},
+                    "repairs_vehicles": {"description": "Repairs and maintenance - Vehicles", "amount": repairs_vehicles, "amount_lakhs": to_lakhs(repairs_vehicles)},
+                    "repairs_others": {"description": "Repairs and maintenance - Others", "amount": repairs_others, "amount_lakhs": to_lakhs(repairs_others)},
+                    "business_dev": {"description": "Business Development Expenses", "amount": business_dev, "amount_lakhs": to_lakhs(business_dev)},
+                    "professional": {"description": "Professional & Consultancy Fees", "amount": professional, "amount_lakhs": to_lakhs(professional)},
+                    "auditors": {"description": "Payment to Auditors", "amount": auditors, "amount_lakhs": to_lakhs(auditors)},
+                    "bad_debts": {"description": "Bad Debts Written Off", "amount": bad_debts, "amount_lakhs": to_lakhs(bad_debts)},
+                    "fire_extinguishers": {"description": "Fire Extinguishers Refilling Charges", "amount": fire_extinguishers, "amount_lakhs": to_lakhs(fire_extinguishers)},
+                    "food_guests": {"description": "Food Expenses for Guests", "amount": food_guests, "amount_lakhs": to_lakhs(food_guests)},
+                    "diesel": {"description": "Diesel Expenses", "amount": diesel, "amount_lakhs": to_lakhs(diesel)},
+                    "interest_234c": {"description": "Interest Under 234 C Fy 2021-22", "amount": interest_234c, "amount_lakhs": to_lakhs(interest_234c)},
+                    "loan_processing": {"description": "Loan Processing Charges", "amount": loan_processing, "amount_lakhs": to_lakhs(loan_processing)},
+                    "sitting_fee": {"description": "Sitting Fee of Directors", "amount": sitting_fee, "amount_lakhs": to_lakhs(sitting_fee)},
+                    "customs_duty": {"description": "Customs Duty Payment", "amount": customs_duty, "amount_lakhs": to_lakhs(customs_duty)},
+                    "transportation": {"description": "Transportation and Unloading Charges", "amount": transportation, "amount_lakhs": to_lakhs(transportation)},
+                    "software": {"description": "Software Equipment", "amount": software, "amount_lakhs": to_lakhs(software)},
+                    "misc": {"description": "Miscellaneous expenses", "amount": misc, "amount_lakhs": to_lakhs(misc)}
+                }
+            }
+            content += "\n* Fees is net of GST which is taken as input tax credit."
+        
+        elif note_name == '21. Depreciation and Amortisation Expense':
+            depreciation = calculate_note(tb_df, note_name, ['Depreciation', 'Accumulated Depreciation', 'Depreciation And Amortisation'])['total']
+            amortization = calculate_note(tb_df, note_name, ['Amortization'])['total']
+            total = result['total']  # Use total from calculate_note
+            content = """
+| Particulars                  | March 31, 2024 | March 31, 2023 |
+|------------------------------|----------------|----------------|
+| Depreciation and amortisation  | {total_lakhs}  | -              |
+| **Total**                    | {total_lakhs}  | -              |
+""".format(total_lakhs=to_lakhs(total))
+            special_data = {
+                "breakdown": {
+                    "depreciation": {"description": "Depreciation", "amount": depreciation, "amount_lakhs": to_lakhs(depreciation)},
+                    "amortization": {"description": "Amortization", "amount": amortization, "amount_lakhs": to_lakhs(amortization)}
+                }
+            }
+        
+        elif note_name == '22. Loss on Sale of Assets & Investments':
+            short_term_loss = calculate_note(tb_df, note_name, ['Short Term Loss on Sale of Investments'])['total']
+            long_term_loss = calculate_note(tb_df, note_name, ['Long term loss on sale of investments'])['total']
+            fixed_assets_loss = calculate_note(tb_df, note_name, ['Loss on Sale of Fixed Assets'])['total']
+            total = result['total']  # Use total from calculate_note
+            content = """
+| Particulars                  | March 31, 2024 | March 31, 2023 |
+|------------------------------|----------------|----------------|
+| Short Term Loss on Sale of Investments (Non Derivative Loss) | {stl_lakhs} | - |
+| Long term loss on sale of investments | {ltl_lakhs} | -             |
+| Loss on Sale of Fixed Assets | {fal_lakhs}   | -              |
+| **Total**                    | {total_lakhs} | -              |
+""".format(stl_lakhs=to_lakhs(short_term_loss), ltl_lakhs=to_lakhs(long_term_loss), fal_lakhs=to_lakhs(fixed_assets_loss), total_lakhs=to_lakhs(total))
+            special_data = {
+                "breakdown": {
+                    "short_term_loss": {"description": "Short Term Loss on Sale of Investments", "amount": short_term_loss, "amount_lakhs": to_lakhs(short_term_loss)},
+                    "long_term_loss": {"description": "Long term loss on sale of investments", "amount": long_term_loss, "amount_lakhs": to_lakhs(long_term_loss)},
+                    "fixed_assets_loss": {"description": "Loss on Sale of Fixed Assets", "amount": fixed_assets_loss, "amount_lakhs": to_lakhs(fixed_assets_loss)}
+                }
+            }
+        
+        elif note_name == '23. Finance Costs':
+            bank_finance = calculate_note(tb_df, note_name, ['Bank Charges', 'Finance Charges', 'Interest', 'Interest and penalty', 'Interest on TDS'])['total']
+            loan_processing = calculate_note(tb_df, note_name, ['Loan Processing'])['total']
+            total = result['total']  # Use total from calculate_note
+            content = """
+| Particulars                  | March 31, 2024 | March 31, 2023 |
+|------------------------------|----------------|----------------|
+| Bank and Finance Charges       | {bf_lakhs}     | -              |
+| **Total**                    | {total_lakhs}  | -              |
+""".format(bf_lakhs=to_lakhs(bank_finance), lp_lakhs=to_lakhs(loan_processing), total_lakhs=to_lakhs(total))
+            special_data = {
+                "breakdown": {
+                    "bank_finance": {"description": "Bank & Finance Charges", "amount": bank_finance, "amount_lakhs": to_lakhs(bank_finance)},
+                    "loan_processing": {"description": "Loan Processing Charges", "amount": loan_processing, "amount_lakhs": to_lakhs(loan_processing)}
+                }
+            }
+        
+        elif note_name == '24. Payment to Auditor':
+            audit_fee = calculate_note(tb_df, note_name, ['Audit Fee', 'Payment to Auditors'])['total']
+            tax_audit = calculate_note(tb_df, note_name, ['Tax Audit', 'Certification Fees'])['total']
+            total = result['total']  # Use total from calculate_note
+            content = """
+| Particulars                  | March 31, 2024 | March 31, 2023 |
+|------------------------------|----------------|----------------|
+| - For Audit fee             | {audit_lakhs}  | -              |
+| - For Tax Audit / Certification Fees | {tax_lakhs} | -         |
+| **Total**                    | {total_lakhs}  | -              |
+""".format(audit_lakhs=to_lakhs(audit_fee), tax_lakhs=to_lakhs(tax_audit), total_lakhs=to_lakhs(total))
+            special_data = {
+                "breakdown": {
+                    "audit_fee": {"description": "For Audit fee", "amount": audit_fee, "amount_lakhs": to_lakhs(audit_fee)},
+                    "tax_audit": {"description": "For Tax Audit / Certification Fees", "amount": tax_audit, "amount_lakhs": to_lakhs(tax_audit)}
+                }
+            }
+        
+        elif note_name == '25. Earnings in Foreign Currency':
+            export_income = calculate_note(tb_df, note_name, ['Income from export of services', 'Servicing of BA/BE PROJECTS EXPORT', 'Working Standards - Export'])['total']
+            total = result['total']  # Use total from calculate_note
+            content = """
+| Particulars                  | March 31, 2024 | March 31, 2023 |
+|------------------------------|----------------|----------------|
+| **Inflow :**                 |                |                |
+| Income from export of services | {exp_lakhs}  | -              |
+| **Total**                    | {total_lakhs}  | -              |
+""".format(exp_lakhs=to_lakhs(export_income), total_lakhs=to_lakhs(total))
+            special_data = {
+                "breakdown": {
+                    "export_income": {"description": "Income from export of services", "amount": export_income, "amount_lakhs": to_lakhs(export_income)}
+                }
+            }
+        
+        elif note_name == '26. Particulars of Un-hedged Foreign Currency Exposure':
+            export_income = calculate_note(tb_df, note_name, ['Income from export of services', 'Servicing of BA/BE PROJECTS EXPORT', 'Working Standards - Export'])['total']
+            total = result['total']  # Use total from calculate_note
+            content = """
+"(i) There is no derivate contract outstanding as at the Balance Sheet date.
+(ii) Particulars of un-hedged foreign currency exposure as at the Balance Sheet date"
+
+| Particulars                  | March 31, 2024 | March 31, 2023 |
+|------------------------------|----------------|----------------|
+| **Inflow :**                 |                |                |
+| Income from export of services | {exp_lakhs}  | -              |
+| **Total**                    | {total_lakhs}  | -              |
+""".format(exp_lakhs=to_lakhs(export_income), total_lakhs=to_lakhs(total))
+            special_data = {
+                "breakdown": {
+                    "export_income": {"description": "Income from export of services", "amount": export_income, "amount_lakhs": to_lakhs(export_income)}
+                }
+            }
+        elif note_name == '28. Earnings per Share':
+            content = """
+| Particulars                  | March 31, 2024 | March 31, 2023 |
+|------------------------------|----------------|----------------|
+| Earnings per Share           | {total_lakhs} | - |
+""".format(total_lakhs=to_lakhs(result['total']))
+        
+        elif note_name == '29. Related Party Disclosures':
+            content = """
+| Particulars                  | March 31, 2024 | March 31, 2023 |
+|------------------------------|----------------|----------------|
+| Related Party Disclosures    | {total_lakhs} | - |
+""".format(total_lakhs=to_lakhs(result['total']))
+        
+        elif note_name == '30. Financial Ratios':
+            current_assets = sum(calculate_note(tb_df, note_name, [kw])['total'] for kw in ['Stock', 'Cash', 'Bank', 'Receivables', 'Prepaid'])
+            current_liabilities = sum(calculate_note(tb_df, note_name, [kw])['total'] for kw in ['Creditors', 'Payable'])
+            current_ratio = current_assets / abs(current_liabilities) if current_liabilities != 0 else 0
+            content = """
+| Particulars                  | 2024-03-31 | 2023-03-31 |
+|------------------------------|------------|------------|
+| Current Ratio                | {cr} | 2.52 |
+| Current Assets               | {ca_lakhs} | - |
+| Current Liabilities          | {cl_lakhs} | - |
+""".format(cr=round(current_ratio, 2), ca_lakhs=to_lakhs(current_assets), cl_lakhs=to_lakhs(abs(current_liabilities)))
+            special_data = {
+                "breakdown": {
+                    "current_assets": {"description": "Current Assets", "amount": current_assets, "amount_lakhs": to_lakhs(current_assets)},
+                    "current_liabilities": {"description": "Current Liabilities", "amount": abs(current_liabilities), "amount_lakhs": to_lakhs(abs(current_liabilities))},
+                    "current_ratio": {"description": "Current Ratio", "value": round(current_ratio, 2)}
+                }
+            }
+        
+        else:
+            content = """
+| Particulars                  | March 31, 2024 | March 31, 2023 |
+|------------------------------|----------------|----------------|
+| {title}                      | {total_lakhs} | - |
+""".format(title=note_name.split('.', 1)[1].strip() if '.' in note_name else note_name, total_lakhs=to_lakhs(result['total']))
+
+
+        detailed_note = create_detailed_note_structure(note_name, result, content, special_data)
+        notes.append(detailed_note)
+    
+    return {
+        "metadata": {
+            "generated_on": datetime.now().isoformat(),
+            "financial_year": settings.financial_year,
+            "company_name": settings.company_name,
+            "total_notes": len(notes)
+        },
+        "notes": notes
+    }
+
+def process_json(json_path: str) -> None:
+    """
+    Loads the JSON file, processes it, and writes the output as in your main().
+    """
+    if not os.path.exists(json_path):
+        logger.error(f"{json_path} not found!")
+        raise FileNotFoundError(f"{json_path} not found!")
+    with open(json_path, "r", encoding="utf-8") as f:
+        parsed_data = json.load(f)
+    if isinstance(parsed_data, list):
+        tb_df = pd.DataFrame(parsed_data)
+    else:
+        tb_records = parsed_data.get("trial_balance", parsed_data)
+        tb_df = pd.DataFrame(tb_records)
+    if 'amount' in tb_df.columns:
+        tb_df['amount'] = tb_df['amount'].apply(clean_value)
+    notes_data = generate_notes(tb_df)
+    os.makedirs(os.path.dirname(settings.output_json), exist_ok=True)
+    with open(settings.output_json, "w", encoding="utf-8") as f:
+        json.dump(notes_data, f, ensure_ascii=False, indent=2)
+    logger.info(f"Notes output written to {settings.output_json}")
+
+def main() -> None:
+    """Main execution function."""
+    try:
+        json_file = settings.trial_balance_json
+        if not os.path.exists(json_file):
+            logger.error(f"{json_file} not found! Please run test_mapping.py first.")
+            raise FileNotFoundError(f"{json_file} not found! Please run test_mapping.py first.")
+        logger.info(f"Loading data from {json_file}...")
+        with open(json_file, "r", encoding="utf-8") as f:
+            parsed_data = json.load(f)
+        if isinstance(parsed_data, list):
+            tb_df = pd.DataFrame(parsed_data)
+        else:
+            tb_records = parsed_data.get("trial_balance", parsed_data)
+            tb_df = pd.DataFrame(tb_records)
+        logger.info(f"Loaded {len(tb_df)} records from trial balance")
+        logger.info(f"Columns available: {tb_df.columns.tolist()}")
+        if 'account_name' not in tb_df.columns or 'amount' not in tb_df.columns:
+            logger.error("JSON must have 'account_name' and 'amount' columns")
+            raise ValueError("JSON must have 'account_name' and 'amount' columns")
+        tb_df['amount'] = tb_df['amount'].apply(clean_value)
+        notes_data = generate_notes(tb_df)
+        os.makedirs(os.path.dirname(settings.output_md), exist_ok=True)
+        output_md = "# Notes to Financial Statements for the Year Ended March 31, 2024\n\n"
+        logger.info(f"Generated {len(notes_data['notes'])} notes")
+        for note in notes_data['notes']:
+            output_md += f"{note['markdown_content']}\n"
+            if note['total_amount'] != 0:
+                logger.info(f"{note['full_title']}: ₹{note['total_amount']:,.2f} ({note['matched_accounts_count']} accounts)")
+            else:
+                logger.warning(f"{note['full_title']}: No matching accounts found")
+        with open(settings.output_md, "w", encoding="utf-8") as f:
+            f.write(output_md)
+        with open(settings.output_json, "w", encoding="utf-8") as f:
+            json.dump(notes_data, f, ensure_ascii=False, indent=2)
+        logger.info("Notes generated successfully!")
+        logger.info(f"Markdown: {settings.output_md}")
+        logger.info(f"JSON: {settings.output_json}")
+    except Exception as e:
+        logger.error(f"Error: {str(e)}")
+        if 'tb_df' in locals():
+            logger.info("Sample trial balance data:")
+            logger.info(tb_df.head().to_string())
+
+if __name__ == "__main__":
+    main()

app/new.py

@@ -0,0 +1,1799 @@
+import json
+import logging
+from datetime import datetime
+from typing import Dict, Any, List, Optional
+from pydantic import BaseModel, Field, ValidationError
+from pydantic_settings import BaseSettings
+
+# Configure logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+class Settings(BaseSettings):
+    """Application settings loaded from environment variables or .env file."""
+    generated_on: str = datetime.now().isoformat()
+
+settings = Settings()
+
+class Subcategory(BaseModel):
+    label: str
+    value: Optional[str] = None
+    previous_value: Optional[str] = None
+    sub_label: Optional[str] = None
+    columns: Optional[List[Dict[str, Any]]] = None
+    values: Optional[List[Dict[str, Any]]] = None
+
+class Category(BaseModel):
+    category: str
+    subcategories: List[Subcategory]
+    total: Optional[str] = None
+    previous_total: Optional[str] = None
+
+class NoteMetadata(BaseModel):
+    note_number: str
+    generated_on: str
+
+class NoteTemplate(BaseModel):
+    title: str
+    full_title: str
+    structure: List[Category]
+    metadata: NoteMetadata
+    notes_and_disclosures: Optional[List[str]] = None
+
+def validate_note_templates(note_templates: Dict[str, Any]) -> Dict[str, NoteTemplate]:
+    """
+    Validate and parse note_templates dict into Pydantic models.
+    Returns a dict of validated NoteTemplate objects.
+    """
+    validated_templates = {}
+    for key, value in note_templates.items():
+        try:
+            # Ensure generated_on is set from settings if not present
+            if "metadata" in value and "generated_on" in value["metadata"]:
+                value["metadata"]["generated_on"] = settings.generated_on
+            validated_templates[key] = NoteTemplate(**value)
+        except ValidationError as ve:
+            logger.warning(f"Validation error for note {key}: {ve}")
+    return validated_templates
+
+# The original note_templates dict (unchanged, but can be loaded from a JSON file if preferred)
+note_templates = {
+    "2": {
+        "title": "Share Capital",
+        "full_title": "2. Share Capital",
+        "structure": [
+            {
+                "category": "In Lakhs",
+                "subcategories": [
+                    {
+                        "label": "March 31, 2024",
+                        "value": "{march_2024_total}"
+                    },
+                    {
+                        "label": "March 31, 2023",
+                        "value": "{march_2023_total}"
+                    }
+                ]
+            },
+            {
+                "category": "Authorised Share Capital",
+                "subcategories": [
+                    {
+                        "label": "Equity Shares of ₹10 each",
+                        "value": "{authorised_equity_2024}",
+                        "previous_value": "{authorised_equity_2023}"
+                    }
+                ],
+                "total": "{authorised_total_2024}",
+                "previous_total": "{authorised_total_2023}"
+            },
+            {
+                "category": "Issued, Subscribed and Paid-up Share Capital",
+                "subcategories": [
+                    {
+                        "label": "Equity Shares of ₹10 each fully paid up",
+                        "value": "{issued_equity_2024}",
+                        "previous_value": "{issued_equity_2023}"
+                    }
+                ],
+                "total": "{issued_total_2024}",
+                "previous_total": "{issued_total_2023}"
+            },
+            {
+                "category": "Reconciliation of Shares",
+                "subcategories": [
+                    {
+                        "label": "Number of Shares at the beginning",
+                        "value": "{shares_beginning_2024}",
+                        "previous_value": "{shares_beginning_2023}"
+                    },
+                    {
+                        "label": "Changes during the year",
+                        "value": "{shares_changes_2024}",
+                        "previous_value": "{shares_changes_2023}"
+                    },
+                    {
+                        "label": "Number of Shares at the end",
+                        "value": "{shares_end_2024}",
+                        "previous_value": "{shares_end_2023}"
+                    }
+                ]
+            }
+        ],
+        "metadata": {
+            "note_number": "2",
+            "generated_on": "{generated_on}"
+        }
+    },
+    "3": {
+        "title": "Reserves and Surplus",
+        "full_title": "3. Reserves and Surplus",
+        "structure": [
+            {
+                "category": "In Lakhs",
+                "subcategories": [
+                    {
+                        "label": "March 31, 2024",
+                        "value": "{march_2024_total}"
+                    },
+                    {
+                        "label": "March 31, 2023",
+                        "value": "{march_2023_total}"
+                    }
+                ]
+            },
+            {
+                "category": "",
+                "subcategories": [
+                    {
+                        "label": "Share Premium Account",
+                        "value": "{share_premium_2024}",
+                        "previous_value": "{share_premium_2023}"
+                    },
+                    {
+                        "label": "Surplus in Statement of Profit and Loss",
+                        "value": "{surplus_profit_loss_2024}",
+                        "previous_value": "{surplus_profit_loss_2023}"
+                    }
+                ],
+                "total": "{total_2024}",
+                "previous_total": "{total_2023}"
+            }
+        ],
+        "metadata": {
+            "note_number": "3",
+            "generated_on": "{generated_on}"
+        }
+    },
+    "4": {
+        "title": "Long Term Borrowings",
+        "full_title": "4. Long Term Borrowings",
+        "structure": [
+            {
+                "category": "In Lakhs",
+                "subcategories": [
+                    {
+                        "label": "March 31, 2024",
+                        "value": "{march_2024_total}"
+                    },
+                    {
+                        "label": "March 31, 2023",
+                        "value": "{march_2023_total}"
+                    }
+                ]
+            },
+            {
+                "category": "Secured",
+                "subcategories": [
+                    {
+                        "label": "Term Loans from Banks",
+                        "value": "{term_loans_banks_2024}",
+                        "previous_value": "{term_loans_banks_2023}"
+                    }
+                ],
+                "total": "{secured_total_2024}",
+                "previous_total": "{secured_total_2023}"
+            }
+        ],
+        "metadata": {
+            "note_number": "4",
+            "generated_on": "{generated_on}"
+        }
+    },
+    "5": {
+        "title": "Deferred Tax Liability (Net)",
+        "full_title": "5. Deferred Tax Liability (Net)",
+        "structure": [
+            {
+                "category": "In Lakhs",
+                "subcategories": [
+                    {
+                        "label": "March 31, 2024",
+                        "value": "{march_2024_total}"
+                    },
+                    {
+                        "label": "March 31, 2023",
+                        "value": "{march_2023_total}"
+                    }
+                ]
+            },
+            {
+                "category": "",
+                "subcategories": [
+                    {
+                        "label": "Deferred Tax Liability",
+                        "value": "{deferred_tax_liability_2024}",
+                        "previous_value": "{deferred_tax_liability_2023}"
+                    }
+                ],
+                "total": "{total_2024}",
+                "previous_total": "{total_2023}"
+            }
+        ],
+        "metadata": {
+            "note_number": "5",
+            "generated_on": "{generated_on}"
+        }
+    },
+    "6": {
+        "title": "Trade Payables",
+        "full_title": "6. Trade Payables",
+        "structure": [
+            {
+                "category": "In Lakhs",
+                "subcategories": [
+                    {
+                        "label": "March 31, 2024",
+                        "value": "{march_2024_total}"
+                    },
+                    {
+                        "label": "March 31, 2023",
+                        "value": "{march_2023_total}"
+                    }
+                ]
+            },
+            {
+                "category": "Unsecured, considered good",
+                "subcategories": [
+                    {
+                        "label": "Outstanding for a period exceeding six months from the date they are due for payment",
+                        "value": "{over_six_months_2024}",
+                        "previous_value": "{over_six_months_2023}"
+                    },
+                    {
+                        "label": "Other payables",
+                        "value": "{other_payables_2024}",
+                        "previous_value": "{other_payables_2023}"
+                    }
+                ],
+                "total": "{unsecured_total_2024}",
+                "previous_total": "{unsecured_total_2023}"
+            },
+            {
+                "category": "Age wise analysis of Trade payables as on 31.03.2024",
+                "subcategories": [
+                    {
+                        "label": "Particulars",
+                        "sub_label": "Outstanding for following periods from due date of payment",
+                        "columns": [
+                            {"header": "0 - 6 months", "value": "{zero_six_2024}"},
+                            {"header": "6 months - 1 Year", "value": "{six_one_2024}"},
+                            {"header": "1 - 2 Years", "value": "{one_two_2024}"},
+                            {"header": "2 - 3 Years", "value": "{two_three_2024}"},
+                            {"header": "More than 3 Years", "value": "{more_three_2024}"},
+                            {"header": "Total", "value": "{age_total_2024}"}
+                        ]
+                    },
+                    {
+                        "label": "Undisputed",
+                        "sub_label": "- Considered good",
+                        "values": [
+                            {"period": "0 - 6 months", "value": "{undisputed_good_zero_six_2024}"},
+                            {"period": "6 months - 1 Year", "value": "{undisputed_good_six_one_2024}"},
+                            {"period": "1 - 2 Years", "value": "{undisputed_good_one_two_2024}"},
+                            {"period": "2 - 3 Years", "value": "{undisputed_good_two_three_2024}"},
+                            {"period": "More than 3 Years", "value": "{undisputed_good_more_three_2024}"},
+                            {"period": "Total", "value": "{undisputed_good_total_2024}"}
+                        ]
+                    },
+                    {
+                        "label": "Disputed",
+                        "sub_label": "- Considered good",
+                        "values": [
+                            {"period": "0 - 6 months", "value": "{disputed_good_zero_six_2024}"},
+                            {"period": "6 months - 1 Year", "value": "{disputed_good_six_one_2024}"},
+                            {"period": "1 - 2 Years", "value": "{disputed_good_one_two_2024}"},
+                            {"period": "2 - 3 Years", "value": "{disputed_good_two_three_2024}"},
+                            {"period": "More than 3 Years", "value": "{disputed_good_more_three_2024}"},
+                            {"period": "Total", "value": "{disputed_good_total_2024}"}
+                        ]
+                    },
+                    {
+                        "label": "Total",
+                        "values": [
+                            {"period": "0 - 6 months", "value": "{total_zero_six_2024}"},
+                            {"period": "6 months - 1 Year", "value": "{total_six_one_2024}"},
+                            {"period": "1 - 2 Years", "value": "{total_one_two_2024}"},
+                            {"period": "2 - 3 Years", "value": "{total_two_three_2024}"},
+                            {"period": "More than 3 Years", "value": "{total_more_three_2024}"},
+                            {"period": "Total", "value": "{age_total_2024}"}
+                        ]
+                    }
+                ]
+            },
+            {
+                "category": "Age wise analysis of Trade payables as on 31.03.2023",
+                "subcategories": [
+                    {
+                        "label": "Particulars",
+                        "sub_label": "Outstanding for following periods from due date of payment",
+                        "columns": [
+                            {"header": "0 - 6 months", "value": "{zero_six_2023}"},
+                            {"header": "6 months - 1 Year", "value": "{six_one_2023}"},
+                            {"header": "1 - 2 Years", "value": "{one_two_2023}"},
+                            {"header": "2 - 3 Years", "value": "{two_three_2023}"},
+                            {"header": "More than 3 Years", "value": "{more_three_2023}"},
+                            {"header": "Total", "value": "{age_total_2023}"}
+                        ]
+                    },
+                    {
+                        "label": "Undisputed",
+                        "sub_label": "- Considered good",
+                        "values": [
+                            {"period": "0 - 6 months", "value": "{undisputed_good_zero_six_2023}"},
+                            {"period": "6 months - 1 Year", "value": "{undisputed_good_six_one_2023}"},
+                            {"period": "1 - 2 Years", "value": "{undisputed_good_one_two_2023}"},
+                            {"period": "2 - 3 Years", "value": "{undisputed_good_two_three_2023}"},
+                            {"period": "More than 3 Years", "value": "{undisputed_good_more_three_2023}"},
+                            {"period": "Total", "value": "{undisputed_good_total_2023}"}
+                        ]
+                    },
+                    {
+                        "label": "Disputed",
+                        "sub_label": "- Considered good",
+                        "values": [
+                            {"period": "0 - 6 months", "value": "{disputed_good_zero_six_2023}"},
+                            {"period": "6 months - 1 Year", "value": "{disputed_good_six_one_2023}"},
+                            {"period": "1 - 2 Years", "value": "{disputed_good_one_two_2023}"},
+                            {"period": "2 - 3 Years", "value": "{disputed_good_two_three_2023}"},
+                            {"period": "More than 3 Years", "value": "{disputed_good_more_three_2023}"},
+                            {"period": "Total", "value": "{disputed_good_total_2023}"}
+                        ]
+                    },
+                    {
+                        "label": "Total",
+                        "values": [
+                            {"period": "0 - 6 months", "value": "{total_zero_six_2023}"},
+                            {"period": "6 months - 1 Year", "value": "{total_six_one_2023}"},
+                            {"period": "1 - 2 Years", "value": "{total_one_two_2023}"},
+                            {"period": "2 - 3 Years", "value": "{total_two_three_2023}"},
+                            {"period": "More than 3 Years", "value": "{total_more_three_2023}"},
+                            {"period": "Total", "value": "{age_total_2023}"}
+                        ]
+                    }
+                ]
+            }
+        ],
+        "metadata": {
+            "note_number": "6",
+            "generated_on": "{generated_on}"
+        }
+    },
+    "7": {
+        "title": "Other Current Liabilities",
+        "full_title": "7. Other Current Liabilities",
+        "structure": [
+            {
+                "category": "In Lakhs",
+                "subcategories": [
+                    {
+                        "label": "March 31, 2024",
+                        "value": "{march_2024_total}"
+                    },
+                    {
+                        "label": "March 31, 2023",
+                        "value": "{march_2023_total}"
+                    }
+                ]
+            },
+            {
+                "category": "",
+                "subcategories": [
+                    {
+                        "label": "Current Maturities of Long Term Borrowings",
+                        "value": "{current_maturities_2024}",
+                        "previous_value": "{current_maturities_2023}"
+                    },
+                    {
+                        "label": "Outstanding Liabilities for Expenses",
+                        "value": "{outstanding_liabilities_2024}",
+                        "previous_value": "{outstanding_liabilities_2023}"
+                    }
+                ],
+                "total": "{total_2024}",
+                "previous_total": "{total_2023}"
+            }
+        ],
+        "metadata": {
+            "note_number": "7",
+            "generated_on": "{generated_on}"
+        }
+    },
+    "8": {
+        "title": "Short Term Provisions",
+        "full_title": "8. Short Term Provisions",
+        "structure": [
+            {
+                "category": "In Lakhs",
+                "subcategories": [
+                    {
+                        "label": "March 31, 2024",
+                        "value": "{march_2024_total}"
+                    },
+                    {
+                        "label": "March 31, 2023",
+                        "value": "{march_2023_total}"
+                    }
+                ]
+            },
+            {
+                "category": "",
+                "subcategories": [
+                    {
+                        "label": "Provision for Taxation",
+                        "value": "{provision_taxation_2024}",
+                        "previous_value": "{provision_taxation_2023}"
+                    }
+                ],
+                "total": "{total_2024}",
+                "previous_total": "{total_2023}"
+            }
+        ],
+        "metadata": {
+            "note_number": "8",
+            "generated_on": "{generated_on}"
+        }
+    },
+    "9": {
+        "title": "Fixed Assets",
+        "full_title": "9. Fixed Assets",
+        "structure": [
+            {
+                "category": "In Lakhs",
+                "subcategories": [
+                    {
+                        "label": "March 31, 2024",
+                        "value": "{march_2024_total}"
+                    },
+                    {
+                        "label": "March 31, 2023",
+                        "value": "{march_2023_total}"
+                    }
+                ]
+            },
+            {
+                "category": "Tangible Assets",
+                "subcategories": [
+                    {
+                        "label": "Gross Block",
+                        "value": "{gross_block_2024}",
+                        "previous_value": "{gross_block_2023}"
+                    },
+                    {
+                        "label": "Accumulated Depreciation",
+                        "value": "{accumulated_depreciation_2024}",
+                        "previous_value": "{accumulated_depreciation_2023}"
+                    },
+                    {
+                        "label": "Net Block",
+                        "value": "{net_block_2024}",
+                        "previous_value": "{net_block_2023}"
+                    }
+                ],
+                "total": "{tangible_total_2024}",
+                "previous_total": "{tangible_total_2023}"
+            },
+            {
+                "category": "Intangible Assets",
+                "subcategories": [
+                    {
+                        "label": "Gross Block",
+                        "value": "{intangible_gross_block_2024}",
+                        "previous_value": "{intangible_gross_block_2023}"
+                    },
+                    {
+                        "label": "Accumulated Amortisation",
+                        "value": "{accumulated_amortisation_2024}",
+                        "previous_value": "{accumulated_amortisation_2023}"
+                    },
+                    {
+                        "label": "Net Block",
+                        "value": "{intangible_net_block_2024}",
+                        "previous_value": "{intangible_net_block_2023}"
+                    }
+                ],
+                "total": "{intangible_total_2024}",
+                "previous_total": "{intangible_total_2023}"
+            },
+            {
+                "category": "Capital Work-in-Progress",
+                "subcategories": [
+                    {
+                        "label": "Capital Work-in-Progress",
+                        "value": "{cwip_2024}",
+                        "previous_value": "{cwip_2023}"
+                    }
+                ],
+                "total": "{cwip_total_2024}",
+                "previous_total": "{cwip_total_2023}"
+            }
+        ],
+        "metadata": {
+            "note_number": "9",
+            "generated_on": "{generated_on}"
+        }
+    },
+    "10": {
+        "title": "Long Term Loans and Advances",
+        "full_title": "10. Long Term Loans and Advances",
+        "structure": [
+            {
+                "category": "In Lakhs",
+                "subcategories": [
+                    {
+                        "label": "March 31, 2024",
+                        "value": "{march_2024_total}"
+                    },
+                    {
+                        "label": "March 31, 2023",
+                        "value": "{march_2023_total}"
+                    }
+                ]
+            },
+            {
+                "category": "Unsecured, considered good",
+                "subcategories": [
+                    {
+                        "label": "Long Term - Security Deposits",
+                        "value": "{security_deposits_2024}",
+                        "previous_value": "{security_deposits_2023}"
+                    }
+                ],
+                "total": "{unsecured_total_2024}",
+                "previous_total": "{unsecured_total_2023}"
+            }
+        ],
+        "metadata": {
+            "note_number": "10",
+            "generated_on": "{generated_on}"
+        }
+    },
+    "11": {
+        "title": "Inventories",
+        "full_title": "11. Inventories",
+        "structure": [
+            {
+                "category": "",
+                "subcategories": [
+                    {
+                        "label": "March 31, 2024",
+                        "value": "{march_2024_total}"
+                    },
+                    {
+                        "label": "March 31, 2023",
+                        "value": "{march_2023_total}"
+                    }
+                ]
+            },
+            {
+                "category": "Consumables",
+                "subcategories": [],
+                "total": "{consumables_2024}",
+                "previous_total": "{consumables_2023}"
+            }
+        ],
+        "metadata": {
+            "note_number": "11",
+            "generated_on": "{generated_on}"
+        }
+    },
+    "12": {
+        "title": "Trade Receivables",
+        "full_title": "12. Trade Receivables",
+        "structure": [
+            {
+                "category": "",
+                "subcategories": [
+                    {
+                        "label": "March 31, 2024",
+                        "value": "{march_2024_total}"
+                    },
+                    {
+                        "label": "March 31, 2023",
+                        "value": "{march_2023_total}"
+                    }
+                ]
+            },
+            {
+                "category": "Unsecured, considered good",
+                "subcategories": [
+                    {
+                        "label": "Outstanding for a period exceeding six months from the date they are due for payment",
+                        "value": "{over_six_months_2024}",
+                        "previous_value": "{over_six_months_2023}"
+                    },
+                    {
+                        "label": "Other receivables",
+                        "value": "{other_receivables_2024}",
+                        "previous_value": "{other_receivables_2023}"
+                    }
+                ],
+                "total": "{unsecured_total_2024}",
+                "previous_total": "{unsecured_total_2023}"
+            },
+            {
+                "category": "Age wise analysis of Trade receivables as on 31.03.2024",
+                "subcategories": [
+                    {
+                        "label": "Particulars",
+                        "sub_label": "Outstanding for following periods from due date of payment",
+                        "columns": [
+                            {"header": "0 - 6 months", "value": "{zero_six_2024}"},
+                            {"header": "6 months - 1 Year", "value": "{six_one_2024}"},
+                            {"header": "1 - 2 Years", "value": "{one_two_2024}"},
+                            {"header": "2 - 3 Years", "value": "{two_three_2024}"},
+                            {"header": "More than 3 Years", "value": "{more_three_2024}"},
+                            {"header": "Total", "value": "{age_total_2024}"}
+                        ]
+                    },
+                    {
+                        "label": "Undisputed",
+                        "sub_label": "- Considered good",
+                        "values": [
+                            {"period": "0 - 6 months", "value": "{undisputed_good_zero_six_2024}"},
+                            {"period": "6 months - 1 Year", "value": "{undisputed_good_six_one_2024}"},
+                            {"period": "1 - 2 Years", "value": "{undisputed_good_one_two_2024}"},
+                            {"period": "2 - 3 Years", "value": "{undisputed_good_two_three_2024}"},
+                            {"period": "More than 3 Years", "value": "{undisputed_good_more_three_2024}"},
+                            {"period": "Total", "value": "{undisputed_good_total_2024}"}
+                        ]
+                    },
+                    {
+                        "label": "Undisputed",
+                        "sub_label": "- Considered doubtful",
+                        "values": [
+                            {"period": "0 - 6 months", "value": "{undisputed_doubtful_zero_six_2024}"},
+                            {"period": "6 months - 1 Year", "value": "{undisputed_doubtful_six_one_2024}"},
+                            {"period": "1 - 2 Years", "value": "{undisputed_doubtful_one_two_2024}"},
+                            {"period": "2 - 3 Years", "value": "{undisputed_doubtful_two_three_2024}"},
+                            {"period": "More than 3 Years", "value": "{undisputed_doubtful_more_three_2024}"},
+                            {"period": "Total", "value": "{undisputed_doubtful_total_2024}"}
+                        ]
+                    },
+                    {
+                        "label": "Disputed",
+                        "sub_label": "- Considered good",
+                        "values": [
+                            {"period": "0 - 6 months", "value": "{disputed_good_zero_six_2024}"},
+                            {"period": "6 months - 1 Year", "value": "{disputed_good_six_one_2024}"},
+                            {"period": "1 - 2 Years", "value": "{disputed_good_one_two_2024}"},
+                            {"period": "2 - 3 Years", "value": "{disputed_good_two_three_2024}"},
+                            {"period": "More than 3 Years", "value": "{disputed_good_more_three_2024}"},
+                            {"period": "Total", "value": "{disputed_good_total_2024}"}
+                        ]
+                    },
+                    {
+                        "label": "Disputed",
+                        "sub_label": "- Considered doubtful",
+                        "values": [
+                            {"period": "0 - 6 months", "value": "{disputed_doubtful_zero_six_2024}"},
+                            {"period": "6 months - 1 Year", "value": "{disputed_doubtful_six_one_2024}"},
+                            {"period": "1 - 2 Years", "value": "{disputed_doubtful_one_two_2024}"},
+                            {"period": "2 - 3 Years", "value": "{disputed_doubtful_two_three_2024}"},
+                            {"period": "More than 3 Years", "value": "{disputed_doubtful_more_three_2024}"},
+                            {"period": "Total", "value": "{disputed_doubtful_total_2024}"}
+                        ]
+                    },
+                    {
+                        "label": "Total",
+                        "values": [
+                            {"period": "0 - 6 months", "value": "{total_zero_six_2024}"},
+                            {"period": "6 months - 1 Year", "value": "{total_six_one_2024}"},
+                            {"period": "1 - 2 Years", "value": "{total_one_two_2024}"},
+                            {"period": "2 - 3 Years", "value": "{total_two_three_2024}"},
+                            {"period": "More than 3 Years", "value": "{total_more_three_2024}"},
+                            {"period": "Total", "value": "{age_total_2024}"}
+                        ]
+                    }
+                ]
+            },
+            {
+                "category": "Age wise analysis of Trade receivables as on 31.03.2023",
+                "subcategories": [
+                    {
+                        "label": "Particulars",
+                        "sub_label": "Outstanding for following periods from due date of payment",
+                        "columns": [
+                            {"header": "0 - 6 months", "value": "{zero_six_2023}"},
+                            {"header": "6 months - 1 Year", "value": "{six_one_2023}"},
+                            {"header": "1 - 2 Years", "value": "{one_two_2023}"},
+                            {"header": "2 - 3 Years", "value": "{two_three_2023}"},
+                            {"header": "More than 3 Years", "value": "{more_three_2023}"},
+                            {"header": "Total", "value": "{age_total_2023}"}
+                        ]
+                    },
+                    {
+                        "label": "Undisputed",
+                        "sub_label": "- Considered good",
+                        "values": [
+                            {"period": "0 - 6 months", "value": "{undisputed_good_zero_six_2023}"},
+                            {"period": "6 months - 1 Year", "value": "{undisputed_good_six_one_2023}"},
+                            {"period": "1 - 2 Years", "value": "{undisputed_good_one_two_2023}"},
+                            {"period": "2 - 3 Years", "value": "{undisputed_good_two_three_2023}"},
+                            {"period": "More than 3 Years", "value": "{undisputed_good_more_three_2023}"},
+                            {"period": "Total", "value": "{undisputed_good_total_2023}"}
+                        ]
+                    },
+                    {
+                        "label": "Undisputed",
+                        "sub_label": "- Considered doubtful",
+                        "values": [
+                            {"period": "0 - 6 months", "value": "{undisputed_doubtful_zero_six_2023}"},
+                            {"period": "6 months - 1 Year", "value": "{undisputed_doubtful_six_one_2023}"},
+                            {"period": "1 - 2 Years", "value": "{undisputed_doubtful_one_two_2023}"},
+                            {"period": "2 - 3 Years", "value": "{undisputed_doubtful_two_three_2023}"},
+                            {"period": "More than 3 Years", "value": "{undisputed_doubtful_more_three_2023}"},
+                            {"period": "Total", "value": "{undisputed_doubtful_total_2023}"}
+                        ]
+                    },
+                    {
+                        "label": "Disputed",
+                        "sub_label": "- Considered good",
+                        "values": [
+                            {"period": "0 - 6 months", "value": "{disputed_good_zero_six_2023}"},
+                            {"period": "6 months - 1 Year", "value": "{disputed_good_six_one_2023}"},
+                            {"period": "1 - 2 Years", "value": "{disputed_good_one_two_2023}"},
+                            {"period": "2 - 3 Years", "value": "{disputed_good_two_three_2023}"},
+                            {"period": "More than 3 Years", "value": "{disputed_good_more_three_2023}"},
+                            {"period": "Total", "value": "{disputed_good_total_2023}"}
+                        ]
+                    },
+                    {
+                        "label": "Disputed",
+                        "sub_label": "- Considered doubtful",
+                        "values": [
+                            {"period": "0 - 6 months", "value": "{disputed_doubtful_zero_six_2023}"},
+                            {"period": "6 months - 1 Year", "value": "{disputed_doubtful_six_one_2023}"},
+                            {"period": "1 - 2 Years", "value": "{disputed_doubtful_one_two_2023}"},
+                            {"period": "2 - 3 Years", "value": "{disputed_doubtful_two_three_2023}"},
+                            {"period": "More than 3 Years", "value": "{disputed_doubtful_more_three_2023}"},
+                            {"period": "Total", "value": "{disputed_doubtful_total_2023}"}
+                        ]
+                    },
+                    {
+                        "label": "Total",
+                        "values": [
+                            {"period": "0 - 6 months", "value": "{total_zero_six_2023}"},
+                            {"period": "6 months - 1 Year", "value": "{total_six_one_2023}"},
+                            {"period": "1 - 2 Years", "value": "{total_one_two_2023}"},
+                            {"period": "2 - 3 Years", "value": "{total_two_three_2023}"},
+                            {"period": "More than 3 Years", "value": "{total_more_three_2023}"},
+                            {"period": "Total", "value": "{age_total_2023}"}
+                        ]
+                    }
+                ]
+            }
+        ],
+        "metadata": {
+            "note_number": "12",
+            "generated_on": "{generated_on}"
+        }
+    },
+    "13": {
+        "title": "Cash and Bank Balances",
+        "full_title": "13. Cash and Bank Balances",
+        "structure": [
+            {
+                "category": "",
+                "subcategories": [
+                    {
+                        "label": "March 31, 2024",
+                        "value": "{march_2024_total}"
+                    },
+                    {
+                        "label": "March 31, 2023",
+                        "value": "{march_2023_total}"
+                    }
+                ]
+            },
+            {
+                "category": "Cash and cash equivalents",
+                "subcategories": [
+                    {
+                        "label": "Balances with banks in current accounts",
+                        "value": "{bank_balances_2024}",
+                        "previous_value": "{bank_balances_2023}"
+                    },
+                    {
+                        "label": "Cash on hand",
+                        "value": "{cash_on_hand_2024}",
+                        "previous_value": "{cash_on_hand_2023}"
+                    }
+                ]
+            },
+            {
+                "category": "Other Bank Balances",
+                "subcategories": [
+                    {
+                        "label": "Fixed Deposits with ICICI Bank",
+                        "value": "{fixed_deposits_2024}",
+                        "previous_value": "{fixed_deposits_2023}"
+                    }
+                ]
+            },
+            {
+                "category": "Total",
+                "subcategories": [],
+                "total": "{total_2024}",
+                "previous_total": "{total_2023}"
+            }
+        ],
+        "metadata": {
+            "note_number": "13",
+            "generated_on": "{generated_on}"
+        }
+    },
+    "14": {
+        "title": "Short Term Loans and Advances",
+        "full_title": "14. Short Term Loans and Advances",
+        "structure": [
+            {
+                "category": "",
+                "subcategories": [
+                    {
+                        "label": "March 31, 2024",
+                        "value": "{march_2024_total}"
+                    },
+                    {
+                        "label": "March 31, 2023",
+                        "value": "{march_2023_total}"
+                    }
+                ]
+            },
+            {
+                "category": "Unsecured, considered good",
+                "subcategories": [
+                    {
+                        "label": "Prepaid Expenses",
+                        "value": "{prepaid_expenses_2024}",
+                        "previous_value": "{prepaid_expenses_2023}"
+                    },
+                    {
+                        "label": "Other Advances",
+                        "value": "{other_advances_2024}",
+                        "previous_value": "{other_advances_2023}"
+                    }
+                ]
+            },
+            {
+                "category": "Other loans and advances",
+                "subcategories": [
+                    {
+                        "label": "Advance tax",
+                        "value": "{advance_tax_2024}",
+                        "previous_value": "{advance_tax_2023}"
+                    },
+                    {
+                        "label": "Balances with statutory/government authorities",
+                        "value": "{statutory_balances_2024}",
+                        "previous_value": "{statutory_balances_2023}"
+                    }
+                ]
+            },
+            {
+                "category": "Total",
+                "subcategories": [],
+                "total": "{total_2024}",
+                "previous_total": "{total_2023}"
+            }
+        ],
+        "metadata": {
+            "note_number": "14",
+            "generated_on": "{generated_on}"
+        }
+    },
+    "15": {
+        "title": "Other Current Assets",
+        "full_title": "15. Other Current Assets",
+        "structure": [
+            {
+                "category": "",
+                "subcategories": [
+                    {
+                        "label": "March 31, 2024",
+                        "value": "{march_2024_total}"
+                    },
+                    {
+                        "label": "March 31, 2023",
+                        "value": "{march_2023_total}"
+                    }
+                ]
+            },
+            {
+                "category": "Interest accrued on fixed deposits",
+                "subcategories": [],
+                "total": "{interest_accrued_2024}",
+                "previous_total": "{interest_accrued_2023}"
+            }
+        ],
+        "metadata": {
+            "note_number": "15",
+            "generated_on": "{generated_on}"
+        }
+    },
+    "16": {
+        "title": "Revenue from Operations",
+        "full_title": "16. Revenue from Operations",
+        "structure": [
+            {
+                "category": "In Lakhs",
+                "subcategories": [
+                    {
+                        "label": "March 31, 2024",
+                        "value": "{march_2024_total}"
+                    },
+                    {
+                        "label": "March 31, 2023",
+                        "value": "{march_2023_total}"
+                    }
+                ]
+            },
+            {
+                "category": "Sale of Services",
+                "subcategories": [
+                    {
+                        "label": "Domestic",
+                        "value": "{domestic_2024}",
+                        "previous_value": "{domestic_2023}"
+                    },
+                    {
+                        "label": "Exports",
+                        "value": "{exports_2024}",
+                        "previous_value": "{exports_2023}"
+                    }
+                ],
+                "total": "{total_2024}",
+                "previous_total": "{total_2023}"
+            }
+        ],
+        "metadata": {
+            "note_number": "16",
+            "generated_on": "{generated_on}"
+        }
+    },
+    "17": {
+        "title": "Other Income",
+        "full_title": "17. Other Income",
+        "structure": [
+            {
+                "category": "",
+                "subcategories": [
+                    {
+                        "label": "March 31, 2024",
+                        "value": "{march_2024_total}"
+                    },
+                    {
+                        "label": "March 31, 2023",
+                        "value": "{march_2023_total}"
+                    }
+                ]
+            },
+            {
+                "category": "",
+                "subcategories": [
+                    {
+                        "label": "Interest income",
+                        "value": "{interestincome_2024}",
+                        "previous_value": "{interestincome_2023}"
+                    },
+                    {
+                        "label": "Foreign exchange gain (Net)",
+                        "value": "{foreignexchangegainnet_2024}",
+                        "previous_value": "{foreignexchangegainnet_2023}"
+                    }
+                ],
+                "total": "{total_2024}",
+                "previous_total": "{total_2023}"
+            }
+        ],
+        "metadata": {
+            "note_number": "17",
+            "generated_on": "{generated_on}"
+        }
+    },
+    "18": {
+        "title": "Cost of Materials Consumed",
+        "full_title": "18. Cost of Materials Consumed",
+        "structure": [
+            {
+                "category": "",
+                "subcategories": [
+                    {
+                        "label": "March 31, 2024",
+                        "value": "{march_2024_total}"
+                    },
+                    {
+                        "label": "March 31, 2023",
+                        "value": "{march_2023_total}"
+                    }
+                ]
+            },
+            {
+                "category": "",
+                "subcategories": [
+                    {
+                        "label": "Opening Stock",
+                        "value": "{openingstock_2024}",
+                        "previous_value": "{openingstock_2023}"
+                    },
+                    {
+                        "label": "Add: Purchases",
+                        "value": "{purchases_2024}",
+                        "previous_value": "{purchases_2023}"
+                    },
+                    {
+                        "label": "",
+                        "value": "{subtotal_2024}",
+                        "previous_value": "{subtotal_2023}"
+                    },
+                    {
+                        "label": "Less: Closing Stock",
+                        "value": "{closingstock_2024}",
+                        "previous_value": "{closingstock_2023}"
+                    }
+                ],
+                "total": "{costmaterialsconsumed_2024}",
+                "previous_total": "{costmaterialsconsumed_2023}"
+            }
+        ],
+        "metadata": {
+            "note_number": "18",
+            "generated_on": "{generated_on}"
+        }
+    },
+    "19": {
+        "title": "Employee Benefit Expense",
+        "full_title": "19. Employee Benefit Expense",
+        "structure": [
+            {
+                "category": "",
+                "subcategories": [
+                    {
+                        "label": "March 31, 2024",
+                        "value": "{march_2024_total}"
+                    },
+                    {
+                        "label": "March 31, 2023",
+                        "value": "{march_2023_total}"
+                    }
+                ]
+            },
+            {
+                "category": "",
+                "subcategories": [
+                    {
+                        "label": "Salaries, wages and bonus",
+                        "value": "{salarieswagesandbonus_2024}",
+                        "previous_value": "{salarieswagesandbonus_2023}"
+                    },
+                    {
+                        "label": "Contribution to PF & ESI",
+                        "value": "{contributiontopfesi_2024}",
+                        "previous_value": "{contributiontopfesi_2023}"
+                    },
+                    {
+                        "label": "Staff welfare expenses",
+                        "value": "{staffwelfareexpenses_2024}",
+                        "previous_value": "{staffwelfareexpenses_2023}"
+                    }
+                ],
+                "total": "{total_2024}",
+                "previous_total": "{total_2023}"
+            }
+        ],
+        "metadata": {
+            "note_number": "19",
+            "generated_on": "{generated_on}"
+        }
+    },
+    "20": {
+        "title": "Other Expenses",
+        "full_title": "20. Other Expenses",
+        "structure": [
+            {
+                "category": "",
+                "subcategories": [
+                    {
+                        "label": "March 31, 2024",
+                        "value": "{march_2024_total}"
+                    },
+                    {
+                        "label": "March 31, 2023",
+                        "value": "{march_2023_total}"
+                    }
+                ]
+            },
+            {
+                "category": "",
+                "subcategories": [
+                    {
+                        "label": "BA / BE NOC Charges",
+                        "value": "{babenoccharges_2024}",
+                        "previous_value": "{babenoccharges_2023}"
+                    },
+                    {
+                        "label": "BA Expenses",
+                        "value": "{baexpenses_2024}",
+                        "previous_value": "{baexpenses_2023}"
+                    },
+                    {
+                        "label": "Payments to Volunteers",
+                        "value": "{paymentstovolunteers_2024}",
+                        "previous_value": "{paymentstovolunteers_2023}"
+                    },
+                    {
+                        "label": "Other Operating Expenses",
+                        "value": "{otheroperatingexpenses_2024}",
+                        "previous_value": "{otheroperatingexpenses_2023}"
+                    },
+                    {
+                        "label": "Laboratory testing charges",
+                        "value": "{laboratorytestingcharges_2024}",
+                        "previous_value": "{laboratorytestingcharges_2023}"
+                    },
+                    {
+                        "label": "Rent",
+                        "value": "{rent_2024}",
+                        "previous_value": "{rent_2023}"
+                    },
+                    {
+                        "label": "Rates & Taxes",
+                        "value": "{ratesandtaxes_2024}",
+                        "previous_value": "{ratesandtaxes_2023}"
+                    },
+                    {
+                        "label": "Fees & licenses",
+                        "value": "{feesandlicenses_2024}",
+                        "previous_value": "{feesandlicenses_2023}"
+                    },
+                    {
+                        "label": "Insurance",
+                        "value": "{insurance_2024}",
+                        "previous_value": "{insurance_2023}"
+                    },
+                    {
+                        "label": "Membership & Subscription Charges",
+                        "value": "{membershipandsubscriptioncharges_2024}",
+                        "previous_value": "{membershipandsubscriptioncharges_2023}"
+                    },
+                    {
+                        "label": "Postage & Communication Cost",
+                        "value": "{postageandcommunicationcost_2024}",
+                        "previous_value": "{postageandcommunicationcost_2023}"
+                    },
+                    {
+                        "label": "Printing and stationery",
+                        "value": "{printingandstationery_2024}",
+                        "previous_value": "{printingandstationery_2023}"
+                    },
+                    {
+                        "label": "CSR Fund Expenses",
+                        "value": "{csrfundexpenses_2024}",
+                        "previous_value": "{csrfundexpenses_2023}"
+                    },
+                    {
+                        "label": "Telephone & Internet",
+                        "value": "{telephoneandinternet_2024}",
+                        "previous_value": "{telephoneandinternet_2023}"
+                    },
+                    {
+                        "label": "Travelling and Conveyance",
+                        "value": "{travellingandconveyance_2024}",
+                        "previous_value": "{travellingandconveyance_2023}"
+                    },
+                    {
+                        "label": "Translation Charges",
+                        "value": "{translationcharges_2024}",
+                        "previous_value": "{translationcharges_2023}"
+                    },
+                    {
+                        "label": "Electricity Charges",
+                        "value": "{electricitycharges_2024}",
+                        "previous_value": "{electricitycharges_2023}"
+                    },
+                    {
+                        "label": "Security Charges",
+                        "value": "{securitycharges_2024}",
+                        "previous_value": "{securitycharges_2023}"
+                    },
+                    {
+                        "label": "Annual Maintenance Charges",
+                        "value": "{annualmaintenancecharges_2024}",
+                        "previous_value": "{annualmaintenancecharges_2023}"
+                    },
+                    {
+                        "label": "Repairs and maintenance - Electrical",
+                        "value": "{repairsandmaintenanceelectrical_2024}",
+                        "previous_value": "{repairsandmaintenanceelectrical_2023}"
+                    },
+                    {
+                        "label": "Repairs and maintenance - Office",
+                        "value": "{repairsandmaintenanceoffice_2024}",
+                        "previous_value": "{repairsandmaintenanceoffice_2023}"
+                    },
+                    {
+                        "label": "Repairs and maintenance - Machinery",
+                        "value": "{repairsandmaintenancemachinery_2024}",
+                        "previous_value": "{repairsandmaintenancemachinery_2023}"
+                    },
+                    {
+                        "label": "Repairs and maintenance - Vehicles",
+                        "value": "{repairsandmaintenancevehicles_2024}",
+                        "previous_value": "{repairsandmaintenancevehicles_2023}"
+                    },
+                    {
+                        "label": "Repairs and maintenance - Others",
+                        "value": "{repairsandmaintenanceothers_2024}",
+                        "previous_value": "{repairsandmaintenanceothers_2023}"
+                    },
+                    {
+                        "label": "Business Development Expenses",
+                        "value": "{businessdevelopmentexpenses_2024}",
+                        "previous_value": "{businessdevelopmentexpenses_2023}"
+                    },
+                    {
+                        "label": "Professional & Consultancy Fees",
+                        "value": "{professionalandconsultancyfees_2024}",
+                        "previous_value": "{professionalandconsultancyfees_2023}"
+                    },
+                    {
+                        "label": "Payment to Auditors",
+                        "value": "{paymenttoauditors_2024}",
+                        "previous_value": "{paymenttoauditors_2023}"
+                    },
+                    {
+                        "label": "Bad Debts Written Off",
+                        "value": "{baddebtswrittenoff_2024}",
+                        "previous_value": "{baddebtswrittenoff_2023}"
+                    },
+                    {
+                        "label": "Fire Extinguishers Refilling Charges",
+                        "value": "{fireextinguishersrefillingcharges_2024}",
+                        "previous_value": "{fireextinguishersrefillingcharges_2023}"
+                    },
+                    {
+                        "label": "Food Expenses for Guests",
+                        "value": "{foodexpensesforguests_2024}",
+                        "previous_value": "{foodexpensesforguests_2023}"
+                    },
+                    {
+                        "label": "Diesel Expenses",
+                        "value": "{dieselexpenses_2024}",
+                        "previous_value": "{dieselexpenses_2023}"
+                    },
+                    {
+                        "label": "Interest Under 234 C Fy 2021-22",
+                        "value": "{interestunder234cfy202122_2024}",
+                        "previous_value": "{interestunder234cfy202122_2023}"
+                    },
+                    {
+                        "label": "Loan Processing Charges",
+                        "value": "{loanprocessingcharges_2024}",
+                        "previous_value": "{loanprocessingcharges_2023}"
+                    },
+                    {
+                        "label": "Sitting Fee of Directors",
+                        "value": "{sittingfeeofdirectors_2024}",
+                        "previous_value": "{sittingfeeofdirectors_2023}"
+                    },
+                    {
+                        "label": "Customs Duty Payment",
+                        "value": "{customsdutypayment_2024}",
+                        "previous_value": "{customsdutypayment_2023}"
+                    },
+                    {
+                        "label": "Transportation and Unloading Charges",
+                        "value": "{transportationandunloadingcharges_2024}",
+                        "previous_value": "{transportationandunloadingcharges_2023}"
+                    },
+                    {
+                        "label": "Software Equipment",
+                        "value": "{softwareequipment_2024}",
+                        "previous_value": "{softwareequipment_2023}"
+                    },
+                    {
+                        "label": "Miscellaneous expenses",
+                        "value": "{miscellaneousexpenses_2024}",
+                        "previous_value": "{miscellaneousexpenses_2023}"
+                    }
+                ],
+                "total": "{total_2024}",
+                "previous_total": "{total_2023}"
+            }
+        ],
+        "metadata": {
+            "note_number": "20",
+            "generated_on": "{generated_on}"
+        },
+        "notes_and_disclosures": [
+            "* Fees is net of GST which is taken as input tax credit."
+        ]
+    },
+    "21": {
+        "title": "Depreciation and Amortisation Expense",
+        "full_title": "21. Depreciation and Amortisation Expense",
+        "structure": [
+            {
+                "category": "",
+                "subcategories": [
+                    {
+                        "label": "March 31, 2024",
+                        "value": "{march_2024_total}"
+                    },
+                    {
+                        "label": "March 31, 2023",
+                        "value": "{march_2023_total}"
+                    }
+                ]
+            },
+            {
+                "category": "",
+                "subcategories": [
+                    {
+                        "label": "Depreciation & amortisation",
+                        "value": "{depreciationamortisation_2024}",
+                        "previous_value": "{depreciationamortisation_2023}"
+                    }
+                ],
+                "total": "{total_2024}",
+                "previous_total": "{total_2023}"
+            }
+        ],
+        "metadata": {
+            "note_number": "21",
+            "generated_on": "{generated_on}"
+        }
+    },
+    "22": {
+        "title": "Loss on Sale of Assets & Investments",
+        "full_title": "22. Loss on Sale of Assets & Investments",
+        "structure": [
+            {
+                "category": "",
+                "subcategories": [
+                    {
+                        "label": "March 31, 2024",
+                        "value": "{march_2024_total}"
+                    },
+                    {
+                        "label": "March 31, 2023",
+                        "value": "{march_2023_total}"
+                    }
+                ]
+            },
+            {
+                "category": "",
+                "subcategories": [
+                    {
+                        "label": "Short Term Loss on Sale of Investments (Non Derivative Loss)",
+                        "value": "{shorttermlossonSaleofinvestmentsnonderivativeLoss_2024}",
+                        "previous_value": "{shorttermlossonSaleofinvestmentsnonderivativeLoss_2023}"
+                    },
+                    {
+                        "label": "Long term loss on sale of investments",
+                        "value": "{longtermlossonSaleofinvestments_2024}",
+                        "previous_value": "{longtermlossonSaleofinvestments_2023}"
+                    },
+                    {
+                        "label": "Loss on Sale of Fixed Assets",
+                        "value": "{lossonSaleoffixedassets_2024}",
+                        "previous_value": "{lossonSaleoffixedassets_2023}"
+                    }
+                ],
+                "total": "{total_2024}",
+                "previous_total": "{total_2023}"
+            }
+        ],
+        "metadata": {
+            "note_number": "22",
+            "generated_on": "{generated_on}"
+        }
+    },
+    "23": {
+        "title": "Finance Costs",
+        "full_title": "23. Finance Costs",
+        "structure": [
+            {
+                "category": "",
+                "subcategories": [
+                    {
+                        "label": "March 31, 2024",
+                        "value": "{march_2024_total}"
+                    },
+                    {
+                        "label": "March 31, 2023",
+                        "value": "{march_2023_total}"
+                    }
+                ]
+            },
+            {
+                "category": "",
+                "subcategories": [
+                    {
+                        "label": "Bank & Finance Charges",
+                        "value": "{bankfinancecharges_2024}",
+                        "previous_value": "{bankfinancecharges_2023}"
+                    }
+                ],
+                "total": "{total_2024}",
+                "previous_total": "{total_2023}"
+            }
+        ],
+        "metadata": {
+            "note_number": "23",
+            "generated_on": "{generated_on}"
+        }
+    },
+    "24": {
+        "title": "Payment to Auditor",
+        "full_title": "24. Payment to Auditor",
+        "structure": [
+            {
+                "category": "",
+                "subcategories": [
+                    {
+                        "label": "March 31, 2024",
+                        "value": "{march_2024_total}"
+                    },
+                    {
+                        "label": "March 31, 2023",
+                        "value": "{march_2023_total}"
+                    }
+                ]
+            },
+            {
+                "category": "",
+                "subcategories": [
+                    {
+                        "label": "For Audit fee",
+                        "value": "{forauditfee_2024}",
+                        "previous_value": "{forauditfee_2023}"
+                    },
+                    {
+                        "label": "For Tax Audit / Certification Fees",
+                        "value": "{fortaxauditcertificationfees_2024}",
+                        "previous_value": "{fortaxauditcertificationfees_2023}"
+                    }
+                ],
+                "total": "{total_2024}",
+                "previous_total": "{total_2023}"
+            }
+        ],
+        "metadata": {
+            "note_number": "24",
+            "generated_on": "{generated_on}"
+        }
+    },
+    "25": {
+        "title": "Earnings in Foreign Currency",
+        "full_title": "25. Earnings in Foreign Currency",
+        "structure": [
+            {
+                "category": "",
+                "subcategories": [
+                    {
+                        "label": "March 31, 2024",
+                        "value": "{march_2024_total}"
+                    },
+                    {
+                        "label": "March 31, 2023",
+                        "value": "{march_2023_total}"
+                    }
+                ]
+            },
+            {
+                "category": "Inflow",
+                "subcategories": [
+                    {
+                        "label": "Income from export of services",
+                        "value": "{incomefromexportofservices_2024}",
+                        "previous_value": "{incomefromexportofservices_2023}"
+                    }
+                ],
+                "total": "{total_2024}",
+                "previous_total": "{total_2023}"
+            }
+        ],
+        "metadata": {
+            "note_number": "25",
+            "generated_on": "{generated_on}"
+        }
+    },
+    "26": {
+        "title": "Particulars of Un-hedged Foreign Currency Exposure",
+        "full_title": "26. Particulars of Un-hedged Foreign Currency Exposure",
+        "structure": [
+            {
+                "category": "",
+                "subcategories": [
+                    {
+                        "label": "March 31, 2024",
+                        "value": "{march_2024_total}"
+                    },
+                    {
+                        "label": "March 31, 2023",
+                        "value": "{march_2023_total}"
+                    }
+                ]
+            },
+            {
+                "category": "Inflow",
+                "subcategories": [
+                    {
+                        "label": "Income from export of services",
+                        "value": "{incomefromexportofservices_2024}",
+                        "previous_value": "{incomefromexportofservices_2023}"
+                    }
+                ],
+                "total": "{total_2024}",
+                "previous_total": "{total_2023}"
+            }
+        ],
+        "metadata": {
+            "note_number": "26",
+            "generated_on": "{generated_on}"
+        },
+        "notes_and_disclosures": [
+            "(i) There is no derivate contract outstanding as at the Balance Sheet date.",
+            "(ii) Particulars of un-hedged foreign currency exposure as at the Balance Sheet date"
+        ]
+    },
+    "27": {
+        "title": "Contingent Liabilities",
+        "full_title": "27. Contingent Liabilities",
+        "structure": [
+            {
+                "category": "In Lakhs",
+                "subcategories": [
+                    {
+                        "label": "March 31, 2024",
+                        "value": "{march_2024_total}"
+                    },
+                    {
+                        "label": "March 31, 2023",
+                        "value": "{march_2023_total}"
+                    }
+                ]
+            },
+            {
+                "category": "",
+                "subcategories": [
+                    {
+                        "label": "Claims against the company not acknowledged as debts",
+                        "value": "{claims_not_acknowledged_2024}",
+                        "previous_value": "{claims_not_acknowledged_2023}"
+                    }
+                ],
+                "total": "{total_2024}",
+                "previous_total": "{total_2023}"
+            }
+        ],
+        "metadata": {
+            "note_number": "27",
+            "generated_on": "{generated_on}"
+        }
+    },
+    "28": {
+        "title": "Commitments",
+        "full_title": "28. Commitments",
+        "structure": [
+            {
+                "category": "In Lakhs",
+                "subcategories": [
+                    {
+                        "label": "March 31, 2024",
+                        "value": "{march_2024_total}"
+                    },
+                    {
+                        "label": "March 31, 2023",
+                        "value": "{march_2023_total}"
+                    }
+                ]
+            },
+            {
+                "category": "",
+                "subcategories": [
+                    {
+                        "label": "Capital Commitments",
+                        "value": "{capital_commitments_2024}",
+                        "previous_value": "{capital_commitments_2023}"
+                    }
+                ],
+                "total": "{total_2024}",
+                "previous_total": "{total_2023}"
+            }
+        ],
+        "metadata": {
+            "note_number": "28",
+            "generated_on": "{generated_on}"
+        }
+    },
+    "29": {
+        "title": "Related Party Disclosures",
+        "full_title": "29. Related Party Disclosures",
+        "structure": [
+            {
+                "category": "",
+                "subcategories": [
+                    {
+                        "label": "March 31, 2024",
+                        "value": "{march_2024_total}"
+                    },
+                    {
+                        "label": "March 31, 2023",
+                        "value": "{march_2023_total}"
+                    }
+                ]
+            },
+            {
+                "category": "Key Management Personnel",
+                "subcategories": [
+                    {
+                        "label": "Remuneration",
+                        "value": "{remuneration_kmp_2024}",
+                        "previous_value": "{remuneration_kmp_2023}"
+                    }
+                ],
+                "total": "{total_kmp_2024}",
+                "previous_total": "{total_kmp_2023}"
+            }
+        ],
+        "metadata": {
+            "note_number": "29",
+            "generated_on": "{generated_on}"
+        }
+    },
+    "30": {
+        "title": "Segment Reporting",
+        "full_title": "30. Segment Reporting",
+        "structure": [
+            {
+                "category": "In Lakhs",
+                "subcategories": [
+                    {
+                        "label": "March 31, 2024",
+                        "value": "{march_2024_total}"
+                    },
+                    {
+                        "label": "March 31, 2023",
+                        "value": "{march_2023_total}"
+                    }
+                ]
+            },
+            {
+                "category": "Segment Revenue",
+                "subcategories": [
+                    {
+                        "label": "Segment A",
+                        "value": "{segment_a_revenue_2024}",
+                        "previous_value": "{segment_a_revenue_2023}"
+                    },
+                    {
+                        "label": "Segment B",
+                        "value": "{segment_b_revenue_2024}",
+                        "previous_value": "{segment_b_revenue_2023}"
+                    }
+                ],
+                "total": "{segment_total_2024}",
+                "previous_total": "{segment_total_2023}"
+            }
+        ],
+        "metadata": {
+            "note_number": "30",
+            "generated_on": "{generated_on}"
+        }
+    },
+    "31": {
+        "title": "Earnings Per Share (EPS)",
+        "full_title": "31. Earnings Per Share (EPS)",
+        "structure": [
+            {
+                "category": "",
+                "subcategories": [
+                    {
+                        "label": "March 31, 2024",
+                        "value": "{march_2024_total}"
+                    },
+                    {
+                        "label": "March 31, 2023",
+                        "value": "{march_2023_total}"
+                    }
+                ]
+            },
+            {
+                "category": "",
+                "subcategories": [
+                    {
+                        "label": "Basic EPS",
+                        "value": "{basic_eps_2024}",
+                        "previous_value": "{basic_eps_2023}"
+                    },
+                    {
+                        "label": "Diluted EPS",
+                        "value": "{diluted_eps_2024}",
+                        "previous_value": "{diluted_eps_2023}"
+                    }
+                ],
+                "total": "{total_eps_2024}",
+                "previous_total": "{total_eps_2023}"
+            }
+        ],
+        "metadata": {
+            "note_number": "31",
+            "generated_on": "{generated_on}"
+        }
+    },
+    "32": {
+        "title": "Additional Disclosures",
+        "full_title": "32. Additional Disclosures",
+        "structure": [
+            {
+                "category": "",
+                "subcategories": [
+                    {
+                        "label": "March 31, 2024",
+                        "value": "{march_2024_total}"
+                    },
+                    {
+                        "label": "March 31, 2023",
+                        "value": "{march_2023_total}"
+                    }
+                ]
+            },
+            {
+                "category": "",
+                "subcategories": [
+                    {
+                        "label": "Additional Information A",
+                        "value": "{additional_info_a_2024}",
+                        "previous_value": "{additional_info_a_2023}"
+                    },
+                    {
+                        "label": "Additional Information B",
+                        "value": "{additional_info_b_2024}",
+                        "previous_value": "{additional_info_b_2023}"
+                    }
+                ],
+                "total": "{total_additional_2024}",
+                "previous_total": "{total_additional_2023}"
+            }
+        ],
+        "metadata": {
+            "note_number": "32",
+            "generated_on": "{generated_on}"
+        }
+    }
+}
+
+# Validate note_templates on import
+validated_note_templates = validate_note_templates(note_templates)
+
+# Optionally, expose validated_note_templates for import elsewhere
+__all__ = ["validated_note_templates"]
+
+# Example usage (for testing or debugging)
+if __name__ == "__main__":
+    logger.info(f"Loaded {len(validated_note_templates)} validated note templates.")
+    # Print one example note template structure
+    example_key = next(iter(validated_note_templates))
+    logger.info(f"Example Note Template [{example_key}]:\n{validated_note_templates[example_key].json(indent=2)}")

app/new_main.py

@@ -0,0 +1,517 @@
+import json
+import os
+import logging
+import requests
+from datetime import datetime
+from pathlib import Path
+from dotenv import load_dotenv
+import re
+import sys
+from typing import Dict, List, Any, Optional, Tuple
+import pandas as pd
+from pydantic import BaseModel, ValidationError
+from pydantic_settings import BaseSettings
+from app.utils import convert_note_json_to_lakhs
+
+
+# Load environment variables
+load_dotenv()
+
+# Configure logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+class Settings(BaseSettings):
+    """Application settings loaded from environment variables or .env file."""
+    openrouter_api_key: str = os.getenv('OPENROUTER_API_KEY', '')
+    api_url: str = "https://openrouter.ai/api/v1/chat/completions"
+    output_dir: str = "generated_notes"
+    trial_balance_json: str = "output1/parsed_trial_balance.json"
+
+settings = Settings()
+
+class Account(BaseModel):
+    account_name: str
+    amount: float
+    group: Optional[str] = None
+
+class NoteTemplate(BaseModel):
+    title: str
+    full_title: str
+    # Add other fields as needed for your template structure
+
+class GeneratedNote(BaseModel):
+    note_number: str
+    markdown_content: str
+    grand_total_lakhs: float
+    generated_on: str
+    assumptions: Optional[str] = None
+    # Add other fields as needed
+
+class FlexibleFinancialNoteGenerator:
+    def __init__(self):
+        self.openrouter_api_key = settings.openrouter_api_key
+        if not self.openrouter_api_key:
+            logger.error("OPENROUTER_API_KEY not found in .env file")
+            raise ValueError("OPENROUTER_API_KEY not found in .env file")
+        self.api_url = settings.api_url
+        self.headers = {
+            "Authorization": f"Bearer {self.openrouter_api_key}",
+            "Content-Type": "application/json",
+            "HTTP-Referer": "https://localhost:3000",
+            "X-Title": "Financial Note Generator"
+        }
+        self.note_templates = self.load_note_templates()
+        self.account_patterns = self._init_account_patterns()
+        self.recommended_models = [
+            "mistralai/mixtral-8x7b-instruct",
+            "mistralai/mistral-7b-instruct-v0.2"
+        ]
+
+    def _init_account_patterns(self) -> Dict[str, Dict[str, Any]]:
+        """Initialize account classification patterns."""
+        return {
+            "10": {
+                "keywords": ["security deposit", "long term advance", "deposit", "advance recoverable"],
+                "groups": ["Long Term Loans and Advances", "Non-Current Assets"],
+                "exclude_keywords": ["short term", "current", "trade"]
+            },
+            "11": {
+                "keywords": ["inventory", "stock", "raw material", "finished goods", "work in progress", "consumables"],
+                "groups": ["Inventories", "Current Assets"],
+                "exclude_keywords": ["advance", "deposit"]
+            },
+            "12": {
+                "keywords": ["trade receivable", "debtors", "accounts receivable", "sundry debtors"],
+                "groups": ["Trade Receivables", "Current Assets"],
+                "exclude_keywords": ["advance", "deposit"]
+            },
+            "13": {
+                "keywords": ["cash", "bank", "petty cash", "cash on hand", "current account", "savings account", "fixed deposit"],
+                "groups": ["Cash and Bank Balances", "Current Assets"],
+                "exclude_keywords": ["advance", "loan"]
+            },
+            "14": {
+                "keywords": ["prepaid", "advance", "short term", "employee advance", "supplier advance", "advance tax", "tds", "gst", "statutory"],
+                "groups": ["Short Term Loans and Advances", "Current Assets"],
+                "exclude_keywords": ["long term", "security deposit"]
+            },
+            "15": {
+                "keywords": ["interest accrued", "accrued income", "other current", "miscellaneous current"],
+                "groups": ["Other Current Assets", "Current Assets"],
+                "exclude_keywords": ["trade", "advance"]
+            }
+        }
+
+    def load_note_templates(self) -> Dict[str, Any]:
+        """Load note templates from app.new.py file."""
+        try:
+            from .new import note_templates
+            return note_templates
+        except ImportError as e:
+            logger.error(f"Error importing note_templates from app.new: {e}")
+            return {}
+        except Exception as e:
+            logger.error(f"Unexpected error loading note_templates: {e}")
+            return {}
+
+    def load_trial_balance(self, file_path: str = settings.trial_balance_json) -> Optional[Dict[str, Any]]:
+        """Load the classified trial balance from Excel or JSON."""
+        try:
+            if file_path.endswith('.json'):
+                with open(file_path, 'r', encoding='utf-8') as f:
+                    data = json.load(f)
+                    if isinstance(data, list):
+                        accounts = data
+                    elif isinstance(data, dict):
+                        accounts = data.get('accounts', [])
+                    else:
+                        logger.error(f"Unexpected trial balance format: {type(data)}")
+                        return None
+                    logger.info(f"Loaded trial balance with {len(accounts)} accounts")
+                    return {"accounts": accounts}
+            elif file_path.endswith('.xlsx'):
+                from app.extract import extract_trial_balance_data
+                accounts = extract_trial_balance_data(file_path)
+                logger.info(f"Extracted trial balance with {len(accounts)} accounts from Excel")
+                return {"accounts": accounts}
+            else:
+                logger.error(f"Unsupported file type: {file_path}")
+                return None
+        except FileNotFoundError:
+            logger.error(f"Trial balance file not found: {file_path}")
+            return None
+        except Exception as e:
+            logger.error(f"Error loading trial balance: {e}")
+            return None
+
+    def classify_accounts_by_note(self, trial_balance_data: Dict[str, Any], note_number: str) -> List[Dict[str, Any]]:
+        """Classify accounts based on note number and patterns"""
+        if not trial_balance_data or "accounts" not in trial_balance_data:
+            return []
+        
+        classified_accounts = []
+        patterns = self.account_patterns.get(note_number, {})
+        keywords = patterns.get("keywords", [])
+        groups = patterns.get("groups", [])
+        exclude_keywords = patterns.get("exclude_keywords", [])
+        
+        for account in trial_balance_data["accounts"]:
+            account_name = account.get("account_name", "").lower()
+            account_group = account.get("group", "")
+            
+            if any(exclude_word.lower() in account_name for exclude_word in exclude_keywords):
+                continue
+            
+            keyword_match = any(keyword.lower() in account_name for keyword in keywords)
+            group_match = account_group in groups
+            
+            if keyword_match or group_match:
+                classified_accounts.append(account)
+        
+        logger.info(f"Classified {len(classified_accounts)} accounts for Note {note_number}")
+        return classified_accounts
+    
+    def safe_amount_conversion(self, amount: Any, conversion_factor: float = 100000) -> float:
+        """Safely convert amount to lakhs"""
+        try:
+            if isinstance(amount, str):
+                cleaned = re.sub(r'[^\d.-]', '', amount)
+                amount_float = float(cleaned) if cleaned else 0.0
+            else:
+                amount_float = float(amount) if amount is not None else 0.0
+            return round(amount_float / conversion_factor, 2)
+        except (ValueError, TypeError):
+            return 0.0
+    
+    def calculate_totals(self, accounts: List[Dict[str, Any]], conversion_factor: float = 100000) -> Tuple[float, float]:
+        """Calculate totals with safe amount conversion"""
+        total_amount = 0.0
+        for account in accounts:
+            amount = self.safe_amount_conversion(account.get("amount", 0), 1)
+            total_amount += amount
+        total_lakhs = round(total_amount / conversion_factor, 2)
+        return total_amount, total_lakhs
+    
+    def categorize_accounts(self, accounts: List[Dict[str, Any]], note_number: str) -> Dict[str, List[Dict[str, Any]]]:
+        """Categorize accounts based on note-specific rules"""
+        categories = {
+            "prepaid_expenses": [],
+            "other_advances": [],
+            "advance_tax": [],
+            "statutory_balances": [],
+            "uncategorized": []
+        } if note_number == "14" else {}
+        
+        for account in accounts:
+            account_name = account.get("account_name", "").lower()
+            categorized = False
+            
+            if note_number == "14":
+                if "prepaid" in account_name:
+                    categories["prepaid_expenses"].append(account)
+                    categorized = True
+                elif any(word in account_name for word in ["advance tax", "tax advance", "income tax"]):
+                    categories["advance_tax"].append(account)
+                    categorized = True
+                elif any(word in account_name for word in ["tds", "gst", "statutory", "government", "vat", "pf", "esi"]):
+                    categories["statutory_balances"].append(account)
+                    categorized = True
+                elif any(word in account_name for word in ["advance", "deposit", "recoverable", "employee advance", "supplier advance"]):
+                    categories["other_advances"].append(account)
+                    categorized = True
+                
+                if not categorized:
+                    categories["uncategorized"].append(account)
+        
+        return categories
+    
+    def calculate_category_totals(self, categories: Dict[str, List[Dict[str, Any]]], conversion_factor: float = 100000) -> Tuple[Dict[str, Dict[str, Any]], float]:
+        """Calculate totals for each category"""
+        category_totals = {}
+        grand_total = 0.0
+        
+        for category_name, accounts in categories.items():
+            if not isinstance(accounts, list):
+                continue
+            total_amount = 0.0
+            for account in accounts:
+                amount = self.safe_amount_conversion(account.get("amount", 0), 1)
+                total_amount += amount
+            total_lakhs = round(total_amount / conversion_factor, 2)
+            category_totals[category_name] = {
+                "amount": total_amount,
+                "lakhs": total_lakhs,
+                "count": len(accounts),
+                "accounts": [acc.get("account_name", "") for acc in accounts]
+            }
+            grand_total += total_amount
+        
+        return category_totals, round(grand_total / conversion_factor, 2)
+    
+    def build_llm_prompt(self, note_number: str, trial_balance_data: Dict[str, Any], classified_accounts: List[Dict[str, Any]]) -> Optional[str]:
+        """Build dynamic LLM prompt based on note template and classified accounts"""
+        if note_number not in self.note_templates:
+            return None
+        
+        template = self.note_templates[note_number]
+        total_amount, total_lakhs = self.calculate_totals(classified_accounts)
+        categories = self.categorize_accounts(classified_accounts, note_number)
+        category_totals, grand_total_lakhs = self.calculate_category_totals(categories)
+        
+        context = {
+            "note_info": {
+                "number": note_number,
+                "title": template.get("title", ""),
+                "full_title": template.get("full_title", "")
+            },
+            "financial_data": {
+                "total_accounts": len(classified_accounts),
+                "total_amount": total_amount,
+                "total_lakhs": total_lakhs,
+                "grand_total_lakhs": grand_total_lakhs
+            },
+            "categories": category_totals,
+            "trial_balance": trial_balance_data,
+            "current_date": datetime.now().strftime("%Y-%m-%d"),
+            "financial_year": "2023-24"
+        }
+        
+        prompt = (
+            f"\nYou are a financial reporting AI system with two roles:\n"
+            f"1. ACCOUNTANT — You extract, compute, and classify data from the financial context and trial balance.\n"
+            f"2. AUDITOR — You review the Accountant’s output for accuracy, assumptions, and consistency with reporting standards.\n"
+            f"\nYour task is to generate a financial note titled: \"{template['full_title']}\" strictly following the JSON structure below, based on the provided financial context and trial balance data.\n"
+            f"\n---\n**CRITICAL RULES**\n"
+            f"- Respond ONLY with a valid JSON object (no markdown, no explanations).\n"
+            f"- If a value is unavailable or not calculable, use `0.0`.\n"
+            f"- Strictly Convert all ₹ amounts to lakhs by dividing by 100000 and round to 2 decimal places.\n"
+            f"- Ensure that category subtotals **match** the grand total.\n"
+            f"- Return a key `markdown_content` containing a markdown-formatted table for this note.\n"
+            f"- Validate that your JSON structure matches the `TEMPLATE STRUCTURE` exactly.\n"
+            f"- Perform intelligent classification: if an entry from the trial balance clearly fits a category, assign it logically.\n"
+            f"- If data is ambiguous, make a conservative estimate, and record it in an `assumptions` field inside the JSON.\n"
+            f"\n---\n**REFLECTION**\n"
+            f"- After generating the financial note, reflect on the process: Did you miss any data? Are there any uncertainties or assumptions that should be highlighted?\n"
+            f"- Explicitly mention any limitations, ambiguities, or areas where further information would improve accuracy in the `assumptions` field.\n"
+            f"\n**REFLEXION**\n"
+            f"- Before finalizing the output, review your own reasoning and calculations. Double-check that all ₹ amounts are converted to lakhs and that category subtotals match the grand total.\n"
+            f"- If you spot any inconsistencies or possible errors, correct them and note your corrections in the `assumptions` field.\n"
+            f"\n**TALES**\n"
+            f"- For each major category or unusual entry, briefly narrate (in the `assumptions` field) the story or logic behind its classification, especially if it required inference or was ambiguous.\n"
+            f"- Use the `assumptions` field to share any tales of how you mapped trial balance entries to categories, including any conservative estimates or judgment calls.\n"
+            f"\n---\n**TEMPLATE STRUCTURE**\n{json.dumps(template, indent=2)}\n"
+            f"\n---\n**TRIAL BALANCE & CONTEXT**\n{json.dumps(context, indent=2)}\n"
+            f"\n---\n**CATEGORY RULES FOR NOTE 14 (Short Term Loans and Advances):**\n"
+            f"- Categorize entries under:\n"
+            f"  - Unsecured, considered good:\n"
+            f"    - Prepaid Expenses\n"
+            f"    - Other Advances\n"
+            f"  - Other loans and advances:\n"
+            f"    - Advance Tax\n"
+            f"    - Balances with statutory/government authorities\n"
+            f"- Use logical inference to map trial balance entries into these subcategories\n"
+            f"- If values for March 31, 2023 are missing, default to 0\n"
+            f"- Ensure the sum of all subcategories = `Total`\n"
+            f"\n---\n**REQUIRED OUTPUT JSON FORMAT**\n"
+            f"- The JSON must include:\n"
+            f"  - All categories and subcategories with March 2024 and March 2023 values\n"
+            f"  - A computed `grand_total_lakhs`\n"
+            f"  - A `markdown_content` with the financial note table\n"
+            f"  - A `generated_on` timestamp\n"
+            f"  - An `assumptions` field (optional, if any data was inferred or missing)\n"
+            f"\n---\nGenerate the final JSON now:\n"
+        )
+        
+        return prompt
+    
+    def call_openrouter_api(self, prompt: str) -> Optional[str]:
+        """Make API call to OpenRouter with model fallback"""
+        for model in self.recommended_models:
+            logger.info(f"Trying model: {model}")
+            payload = {
+                "model": model,
+                "messages": [
+                    {"role": "system", "content": "You are a financial reporting expert. Always respond with valid JSON only."},
+                    {"role": "user", "content": prompt}
+                ],
+                "max_tokens": 8000,
+                "temperature": 0.1,
+                "top_p": 0.9
+            }
+            try:
+                response = requests.post(
+                    self.api_url,
+                    headers=self.headers,
+                    json=payload,
+                    timeout=30  # <-- Add timeout here!
+                )
+                response.raise_for_status()
+                result = response.json()
+                content = result['choices'][0]['message']['content']
+                logger.info(f"Successful response from {model}")
+                return content
+            except Exception as e:
+                logger.error(f"Failed with {model}: {e}")
+                continue
+        logger.error("All models failed")
+        return None
+    
+    def extract_json_from_markdown(self, response_text: str) -> Tuple[Optional[Dict[str, Any]], Optional[str]]:
+        """Extract JSON from response, handling markdown code blocks"""
+        response_text = response_text.strip()
+        json_patterns = [
+            r'```json\s*(.*?)\s*```',
+            r'```\s*(.*?)\s*```',
+            r'(\{.*\})'
+        ]
+        
+        for pattern in json_patterns:
+            match = re.search(pattern, response_text, re.DOTALL)
+            if match:
+                try:
+                    json_data = json.loads(match.group(1))
+                    return json_data, match.group(1)
+                except json.JSONDecodeError:
+                    continue
+        
+        try:
+            json_data = json.loads(response_text)
+            return json_data, response_text
+        except json.JSONDecodeError:
+            return None, None
+    
+    def save_generated_note(self, note_data: str, note_number: str, output_dir: str = settings.output_dir) -> bool:
+        """Save the generated note to file in both JSON and markdown formats"""
+        Path(output_dir).mkdir(parents=True, exist_ok=True)
+        json_output_path = f"{output_dir}/notes.json"
+        raw_output_path = f"{output_dir}/notes_raw.txt"
+        formatted_md_path = f"{output_dir}/notes_formatted.md"
+        
+        try:
+            with open(raw_output_path, 'w', encoding='utf-8') as f:
+                f.write(note_data)
+            json_data, json_string = self.extract_json_from_markdown(note_data)
+            if json_data:
+                json_data = convert_note_json_to_lakhs(json_data)
+                with open(json_output_path, 'w', encoding='utf-8') as f:
+                    json.dump(json_data, f, indent=2, ensure_ascii=False)
+                logger.info(f"JSON saved to {json_output_path}")
+                md_content = json_data.get('markdown_content')
+                if not md_content:
+                    md_content = f"# Note {note_number}\n\n```json\n{json.dumps(json_data, indent=2)}\n```"
+                with open(formatted_md_path, 'w', encoding='utf-8') as f:
+                    f.write(md_content)
+                return True
+            else:
+                fallback_json = {
+                    "note_number": note_number,
+                    "raw_response": note_data,
+                    "error": "Could not parse JSON from response",
+                    "generated_on": datetime.now().isoformat()
+                }
+                with open(json_output_path, 'w', encoding='utf-8') as f:
+                    json.dump(fallback_json, f, indent=2, ensure_ascii=False)
+                logger.warning(f"Fallback JSON saved to {json_output_path}")
+                return False
+        except Exception as e:
+            logger.error(f"Error saving files: {e}")
+            return False
+    
+    def generate_note(self, note_number: str, trial_balance_path: str = settings.trial_balance_json) -> bool:
+        """Generate a specific note based on note number"""
+        if note_number not in self.note_templates:
+            logger.error(f"Note template {note_number} not found")
+            return False
+        
+        logger.info(f"Starting Note {note_number} generation...")
+        trial_balance = self.load_trial_balance(trial_balance_path)
+        if not trial_balance:
+            return False
+        
+        classified_accounts = self.classify_accounts_by_note(trial_balance, note_number)
+        prompt = self.build_llm_prompt(note_number, trial_balance, classified_accounts)
+        if not prompt:
+            logger.error("Failed to build prompt")
+            return False
+        
+        response = self.call_openrouter_api(prompt)
+        if not response:
+            logger.error("Failed to get API response")
+            return False
+        
+        success = self.save_generated_note(response, note_number)
+        logger.info(f"Note {note_number} {'generated successfully' if success else 'generated with issues'}")
+        return success
+    
+    def generate_all_notes(self, trial_balance_path: str = settings.trial_balance_json) -> Dict[str, bool]:
+        """Generate all available notes and save them in a single notes.json file."""
+        logger.info(f"Starting generation of all {len(self.note_templates)} notes...")
+        results = {}
+        all_notes = []
+        for note_number in self.note_templates.keys():
+            logger.info(f"Processing Note {note_number}")
+            trial_balance = self.load_trial_balance(trial_balance_path)
+            if not trial_balance:
+                results[note_number] = False
+                continue
+            classified_accounts = self.classify_accounts_by_note(trial_balance, note_number)
+            prompt = self.build_llm_prompt(note_number, trial_balance, classified_accounts)
+            if not prompt:
+                results[note_number] = False
+                continue
+            response = self.call_openrouter_api(prompt)
+            if not response:
+                results[note_number] = False
+                continue
+            json_data, _ = self.extract_json_from_markdown(response)
+            if json_data:
+                all_notes.append(json_data)
+                results[note_number] = True
+            else:
+                results[note_number] = False
+            import time
+            time.sleep(1)
+        # Save all notes in one file
+        output_dir = settings.output_dir
+        Path(output_dir).mkdir(parents=True, exist_ok=True)
+        with open(f"{output_dir}/notes.json", "w", encoding="utf-8") as f:
+            json.dump({"notes": all_notes}, f, indent=2, ensure_ascii=False)
+        successful = sum(1 for success in results.values() if success)
+        total = len(results)
+        logger.info(f"GENERATION SUMMARY: {successful}/{total} notes generated successfully")
+        logger.info(f"All notes saved to {output_dir}/notes.json")
+        return results
+
+def main() -> None:
+    """Main function to run the flexible note generator"""
+    try:
+        generator = FlexibleFinancialNoteGenerator()
+        if not generator.note_templates:
+            logger.error("No note templates loaded. Check app/new.py")
+            return
+        
+        logger.info(f"Loaded {len(generator.note_templates)} note templates")
+        choice = input("\nGenerate (1) specific note or (2) all notes? Enter 1 or 2: ").strip()
+        
+        if choice == "1":
+            available_notes = list(generator.note_templates.keys())
+            print(f"Available notes: {', '.join(available_notes)}")
+            note_number = input("Enter note number: ").strip()
+            if note_number in available_notes:
+                success = generator.generate_note(note_number)
+                logger.info(f"Note {note_number} {'generated successfully' if success else 'generated with issues'}")
+            else:
+                logger.error(f"Note {note_number} not found")
+        elif choice == "2":
+            results = generator.generate_all_notes()
+            successful = sum(1 for success in results.values() if success)
+            total = len(results)
+            logger.info(f"{successful}/{total} notes generated successfully")
+        else:
+            logger.error("Invalid choice. Enter 1 or 2.")
+    except Exception as e:
+        logger.error(f"Error: {e}", exc_info=True)
+
+if __name__ == "__main__":
+    main()

app/notes.py

@@ -0,0 +1,303 @@
+import logging
+from typing import Any, Dict, List, Optional
+from pydantic import BaseModel, ValidationError
+from pydantic_settings import BaseSettings
+from app.utils import clean_value, to_lakhs
+
+# Configure logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+class Settings(BaseSettings):
+    """Application settings loaded from environment variables or .env file."""
+    statutory_dues: float = 7935166.72
+
+settings = Settings()
+
+class MatchedAccount(BaseModel):
+    account: str
+    amount: float
+    group: str
+
+class NoteResult(BaseModel):
+    total: float
+    matched_accounts: List[MatchedAccount]
+    over_6m: Optional[float] = None
+
+def calculate_note(
+    df: Any,
+    note_name: str,
+    keywords: List[str],
+    exclude: Optional[List[str]] = None,
+    other_df: Optional[Any] = None
+) -> Dict[str, Any]:
+    """
+    Calculate total and matched accounts for a note.
+    Handles special cases for Trade Receivables and Other Current Liabilities.
+    """
+    account_col = 'account_name' if 'account_name' in df.columns else df.columns[0]
+    balance_col = 'amount' if 'amount' in df.columns else (df.columns[1] if len(df.columns) > 1 else None)
+
+    if not balance_col:
+        return {'total': 0, 'matched_accounts': []}
+
+    df = df.fillna(0)
+    total = 0
+    matched_accounts = []
+
+    for idx, row in df.iterrows():
+        account_name = str(row[account_col]).strip().lower()
+        if any(kw.lower() in account_name for kw in keywords) and (not exclude or not any(ex.lower() in account_name for ex in exclude)):
+            amount = clean_value(row[balance_col])
+            matched = {
+                'account': str(row[account_col]),
+                'amount': amount,
+                'group': row.get('group', 'Unknown') if 'group' in df.columns else 'Unknown'
+            }
+            try:
+                validated = MatchedAccount(**matched)
+                matched_accounts.append(validated)
+            except ValidationError as ve:
+                logger.warning(f"Validation error for matched account: {ve}")
+                matched_accounts.append(matched)
+            total += amount
+
+    # Special case for Trade Receivables
+    if other_df is not None and note_name == '12. Trade Receivables':
+        if 'Pending' in other_df.columns:
+            total = other_df['Pending'].sum()
+            over_6m = other_df[['360 to 720 days', '720 to 1440 days', '(> 1440 days )']].sum().sum()
+        else:
+            over_6m = 0
+        return {'total': total, 'over_6m': over_6m, 'matched_accounts': matched_accounts}
+
+    # Special case for Other Current Liabilities
+    if note_name == '7. Other Current Liabilities' and other_df is None:
+        total += settings.statutory_dues
+
+    return {'total': total, 'matched_accounts': matched_accounts}
+
+def generate_notes(
+    tb_df: Any,
+    debtors_df: Optional[Any] = None,
+    creditors_df: Optional[Any] = None
+) -> List[Dict[str, Any]]:
+    """
+    Generate notes from trial balance DataFrame.
+    Returns a list of notes with content and matched account count.
+    """
+    notes = []
+    note_mappings: Dict[str, Dict[str, Any]] = {
+        '2. Share Capital': {'keywords': ['Share Capital', 'share capital', 'equity share', 'paid up']},
+        '3. Reserves and Surplus': {'keywords': ['Reserves', 'Surplus', 'reserves', 'surplus', 'retained earnings']},
+        '4. Long Term Borrowings': {'keywords': ['loan', 'borrowing', 'term loan'], 'exclude': ['current maturities', 'short term']},
+        '5. Deferred Tax Liability': {'keywords': ['Deferred Tax', 'deferred tax']},
+        '6. Trade Payables': {'keywords': ['Creditors', 'creditors', 'trade payable', 'suppliers']},
+        '7. Other Current Liabilities': {'keywords': ['Expenses Payable', 'Current Maturities', 'payable', 'accrued']},
+        '8. Short Term Provisions': {'keywords': ['Provision', 'provision', 'taxation']},
+        '9. Fixed Assets': {'keywords': ['Equipment', 'Furniture', 'Building', 'Vehicle', 'Motor', 'Asset', 'plant', 'machinery']},
+        '10. Long Term Loans and Advances': {'keywords': ['Long Term', 'Security Deposits', 'advances', 'deposits']},
+        '11. Inventories': {'keywords': ['Stock', 'Inventory', 'stock', 'inventory', 'goods']},
+        '12. Trade Receivables': {'keywords': ['Receivables', 'receivables', 'debtors', 'trade receivable']},
+        '13. Cash and Bank Balances': {'keywords': ['Cash-in-hand', 'Bank accounts','Deposits']},
+        '14. Short Term Loans and Advances': {'keywords': ['Prepaid Expenses', 'TDS Receivables', 'Loans & Advances', 'TCS RECEIVABLES', 'TDS Advance Tax Paid', 'Advance to Perennail']},
+        '15. Other Current Assets': {'keywords': ['Interest accrued', 'accrued', 'current asset']},
+        '16. Revenue from Operations': {'keywords': ['Revenue', 'Sales', 'Service', 'income', 'operations']},
+        '17. Other Income': {'keywords': ['Interest on FD', 'Interest on Income Tax Refund', 'Unadjusted Forex Gain/Loss', 'Forex Gain / Loss']},
+        '18. Cost of Materials Consumed': {'keywords': ['opening stock', 'Bio Lab Consumables', 'Non GST', 'Purchase GST','closing stock']},
+        '28. Earnings per Share': {'keywords': ['Profit', 'Loss', 'profit', 'loss']},
+        '29. Related Party Disclosures': {'keywords': []},
+        '30. Financial Ratios': {'keywords': ['Stock', 'Cash', 'Bank', 'Receivables', 'Creditors', 'Payable']}
+    }
+
+    for note_name, mapping in note_mappings.items():
+        keywords = mapping['keywords']
+        exclude = mapping.get('exclude', [])
+        other_df = debtors_df if note_name == '12. Trade Receivables' else creditors_df if note_name == '6. Trade Payables' else None
+        result = calculate_note(tb_df, note_name, keywords, exclude, other_df)
+
+        content = ""
+        if note_name == '2. Share Capital':
+            content = f"""
+| Particulars | 2024-03-31 | 2023-03-31 |
+|-------------|------------|------------|
+| Authorised shares | | |
+| 75,70,000 equity shares of ₹ 10/- each | {to_lakhs(75700000)} | {to_lakhs(75700000)} |
+| Issued, subscribed and fully paid-up shares | | |
+| 54,25,210 equity shares of ₹ 10/- each | {to_lakhs(result['total'])} | {to_lakhs(54252100)} |
+| Total issued, subscribed and fully paid-up share capital | {to_lakhs(result['total'])} | {to_lakhs(54252100)} |
+"""
+        elif note_name == '3. Reserves and Surplus':
+            content = f"""
+                                                 | March,31 2024  | March,31 2023    
+| {note_name.split('.', 1)[1].strip() if '.' in note_name else note_name}                           | {to_lakhs(result['total'])}  
+"""
+        elif note_name == '4. Long Term Borrowings':
+            content = f"""
+                                                 | March,31 2024  | March,31 2023    
+| {note_name.split('.', 1)[1].strip() if '.' in note_name else note_name}                           | {to_lakhs(result['total'])}  
+"""
+        elif note_name == '5. Deferred Tax Liability':
+            content = f"""
+                                                 | March,31 2024  | March,31 2023    
+| {note_name.split('.', 1)[1].strip() if '.' in note_name else note_name}                         | {to_lakhs(result['total'])}  
+"""
+        elif note_name == '6. Trade Payables':
+            content = f"""
+                                                 | March,31 2024  | March,31 2023    
+| {note_name.split('.', 1)[1].strip() if '.' in note_name else note_name}                                 | {to_lakhs(result['total'])}  
+"""
+        elif note_name == '7. Other Current Liabilities':
+            expenses_payable = calculate_note(tb_df, note_name, ['Expenses Payable', 'payable', 'accrued'])['total']
+            current_maturities = calculate_note(tb_df, note_name, ['Current Maturities', 'current portion'])['total']
+            statutory_dues = 7935166.72  # Static value
+            content = f"""
+                                             | March,31 2024  | March,31 2023         
+
+| Current Maturities of Long Term Borrowings | {to_lakhs(current_maturities)}          | {to_lakhs(13920441)} 
+| Outstanding Liabilities for Expenses       | {to_lakhs(expenses_payable)}         | {to_lakhs(15688272)} 
+| Statutory dues                             | {to_lakhs(statutory_dues)}          | {to_lakhs(4803131.66)} 
+                                             | {to_lakhs(current_maturities + expenses_payable + statutory_dues)}         | {to_lakhs(34411844.66)} 
+"""
+        elif note_name == '8. Short Term Provisions':
+            content = f"""
+                                                 | March,31 2024  | March,31 2023    
+| {note_name.split('.', 1)[1].strip() if '.' in note_name else note_name}                          | {to_lakhs(result['total'])}  
+"""
+        elif note_name == '9. Fixed Assets':
+            equipments = calculate_note(tb_df, note_name, ['Equipment', 'equipment'])['total']
+            furniture = calculate_note(tb_df, note_name, ['Furniture', 'furniture', 'fixture'])['total']
+            building = calculate_note(tb_df, note_name, ['Building', 'building'])['total']
+            vehicle = calculate_note(tb_df, note_name, ['Vehicle', 'vehicle', 'car'])['total']
+            content = f"""
+| Particulars | Gross Carrying Value | Accumulated Depreciation | Net Carrying Value |
+|-------------|----------------------|--------------------------|--------------------|
+| As at 1st April 2023 | Additions | Deletion | As at 31st March 2024 | As at 1st April 2023 | For the year | Deletion | As at 31st March 2024 | As at 31st March 2024 | As at 1st April 2023 |
+| Tangible Assets | | | | | | | | | |
+| Buildings | {to_lakhs(312655)} | {to_lakhs(building)} | 0 | {to_lakhs(312655 + building)} | {to_lakhs(312654)} | {to_lakhs(1478808)} | 0 | {to_lakhs(1791462)} | {to_lakhs(building)} | {to_lakhs(1)} |
+| Equipments | {to_lakhs(equipments)} | {to_lakhs(0)} | 0 | {to_lakhs(equipments)} | {to_lakhs(0)} | {to_lakhs(0)} | 0 | {to_lakhs(0)} | {to_lakhs(equipments)} | {to_lakhs(equipments)} |
+| Furniture & Fixtures | {to_lakhs(furniture)} | {to_lakhs(0)} | 0 | {to_lakhs(furniture)} | {to_lakhs(0)} | {to_lakhs(0)} | 0 | {to_lakhs(0)} | {to_lakhs(furniture)} | {to_lakhs(furniture)} |
+| Motor Vehicle | {to_lakhs(vehicle)} | 0 | 0 | {to_lakhs(vehicle)} | {to_lakhs(0)} | {to_lakhs(752982.45)} | 0 | {to_lakhs(752982.45)} | {to_lakhs(vehicle - 752982.45)} | {to_lakhs(vehicle)} |
+"""
+        elif note_name == '11. Inventories':
+            content = f"""
+                                                 | March,31 2024  | March,31 2023    
+| Consumables                                    | {to_lakhs(result['total'])}  
+"""
+        elif note_name == '12. Trade Receivables':
+            over_6m = result.get('over_6m', 0)
+            content = f"""
+| Particulars | 2024-03-31 | 2023-03-31 |
+|-------------|------------|------------|
+| Unsecured, considered good | | |
+| Outstanding for a period exceeding six months | {to_lakhs(over_6m)} | {to_lakhs(10465395)} |
+| Total | {to_lakhs(result['total'])} | {to_lakhs(103758506)} |
+"""
+        elif note_name == '13. Cash and Bank Balances':
+            cash_in_hand = calculate_note(tb_df, note_name, ['Cash-in-hand'])['total']
+            bank_accounts = calculate_note(tb_df, note_name, ['Bank accounts'])['total']
+            fixed_deposit = calculate_note(tb_df, note_name, ['Deposits'])['total']
+            total = cash_in_hand + bank_accounts + fixed_deposit
+            content = f"""
+| Particulars      | March 31, 2024 | March 31, 2023 |
+|------------------|----------------|----------------|
+| Cash in hand     | {to_lakhs(cash_in_hand)}        | -              |
+| Bank accounts    | {to_lakhs(bank_accounts)}       | -              |
+| Fixed Deposit    | {to_lakhs(fixed_deposit)}       | -              |
+| **Total**        | **{to_lakhs(total)}**           | -              |
+"""
+            result['total'] = total
+        elif note_name == '14. Short Term Loans and Advances':
+            otherAdvances = calculate_note(tb_df, note_name, ['Loans & Advances'])['total']
+            PrepaidExpenses = calculate_note(tb_df, note_name, ['Prepaid Expenses'])['total']
+            advancetaxes = calculate_note(tb_df, note_name, ['TDS Advance Tax Paid'])['total']
+            balances = calculate_note(tb_df, note_name, ['TDS Receivables'])['total']
+            total = otherAdvances + PrepaidExpenses + advancetaxes + balances
+            content = f"""
+| Particulars      | March 31, 2024 | March 31, 2023 |
+|------------------|----------------|----------------|
+| Prepaid Expenses | {to_lakhs(PrepaidExpenses)}     | -              |
+| Other Advances   | {to_lakhs(otherAdvances)}       | -              |
+| Advance tax      | {to_lakhs(advancetaxes)}        | -              |
+| Balances with statutory/government authorities | {to_lakhs(balances)} | - |
+| **Total**        | **{to_lakhs(total)}**           | -              |
+"""
+            result['total'] = total
+        elif note_name == '16. Revenue from Operations':
+            ServicingBABEExport = calculate_note(tb_df, note_name, ['Servicing of BA/BE PROJECTS EXPORT'])['total']
+            WorkingStandardsExport = calculate_note(tb_df, note_name, ['Working Standards - Export'])['total']
+            exports = ServicingBABEExport + WorkingStandardsExport
+
+            ServicingBABEInterState = calculate_note(tb_df, note_name, ['Servicing of BA/BE PROJECTS-Inter State'])['total']
+            ServicingBABEIntraState = calculate_note(tb_df, note_name, ['Servicing of BA/BE PROJECTS-Intra State'])['total']
+            ServicingBAIntraState = calculate_note(tb_df, note_name, ['SERVICING OF BA PROJECTS-Intra State'])['total']
+            ServicingClinicalIntraState = calculate_note(tb_df, note_name, ['SERVICING OF ONLY CLINICAL INTRA STATE'])['total']
+            domestic = ServicingBABEInterState + ServicingBABEIntraState + ServicingBAIntraState + ServicingClinicalIntraState
+
+            total = exports + domestic
+
+            content = f"""
+|                    | March 31, 2024          | March 31, 2023 |
+|--------------------|------------------------|----------------|
+| Sale of Services   |                        |                |
+| Domestic           | {to_lakhs(domestic)}   | -              |
+| Exports            | {to_lakhs(exports)}    | -              |
+| **Total**          | {to_lakhs(total)}      | -              |
+"""
+            result['total'] = total
+        elif note_name == '17. Other Income':
+            InterestnFD = calculate_note(tb_df, note_name, ['Interest on FD'])['total']
+            InterestonIncomeTaxRefund = calculate_note(tb_df, note_name, ['Interest on Income Tax Refund'])['total']
+            UnadjustedForexGainLoss = calculate_note(tb_df, note_name, ['Unadjusted Forex Gain/Loss'])['total']
+            ForexGainLoss = calculate_note(tb_df, note_name, ['Forex Gain/Loss'])['total']
+            Interestincome = InterestnFD + InterestonIncomeTaxRefund
+            ForeignexchangeainNet = UnadjustedForexGainLoss + ForexGainLoss
+            total = Interestincome + ForeignexchangeainNet
+
+            content = f"""
+| Particulars                | March 31, 2024 | March 31, 2023 |
+|----------------------------|----------------|----------------|
+| Interest income            | {to_lakhs(Interestincome)} | - |
+| Foreign exchange gain (Net)| {to_lakhs(ForeignexchangeainNet)} | - |
+| **Total**                  | {to_lakhs(total)} | - |
+"""
+            result['total'] = total
+        elif note_name == '18. Cost of Materials Consumed':
+            openingstock = calculate_note(tb_df, note_name, ['opening stock'])['total']
+            BioLabConsumables = calculate_note(tb_df, note_name, ['Bio Lab Consumables'])['total']
+            NonGST = calculate_note(tb_df, note_name, ['Non GST'])['total']
+            PurchaseGST = calculate_note(tb_df, note_name, ['Purchase GST'])['total']
+            closingstock = calculate_note(tb_df, note_name, ['closing stock'])['total']
+
+            purchases = BioLabConsumables + NonGST + PurchaseGST
+            mid = openingstock + purchases
+            total = openingstock + purchases - closingstock
+
+            content = f"""
+| Particulars         | March 31, 2024 | March 31, 2023 |
+|---------------------|----------------|----------------|
+| Opening Stock       | {to_lakhs(openingstock)} | - |
+| Purchases           | {to_lakhs(purchases)} | - |
+|                     | {to_lakhs(mid)} | - |
+| Closing Stock       | {to_lakhs(closingstock)} | - |
+| Cost of materials consumed | {to_lakhs(total)} | - |
+"""
+            result['total'] = total
+        elif note_name == '30. Financial Ratios':
+            current_assets = sum(calculate_note(tb_df, note_name, [kw])['total'] for kw in ['Stock', 'Cash', 'Bank', 'Receivables', 'Prepaid'])
+            current_liabilities = sum(calculate_note(tb_df, note_name, [kw])['total'] for kw in ['Creditors', 'Payable'])
+            current_ratio = current_assets / abs(current_liabilities) if current_liabilities != 0 else 0
+            content = f"""
+| Particulars     | 2024-03-31 | 2023-03-31 |
+|-----------------|------------|------------|
+| Current Ratio   | {round(current_ratio, 2)} | 2.52 |
+| Current Assets  | {to_lakhs(current_assets)} | - |
+| Current Liabilities | {to_lakhs(abs(current_liabilities))} | - |
+"""
+        else:
+            content = f"""
+                                                 | March,31 2024  | March,31 2023    
+| {note_name.split('.', 1)[1].strip() if '.' in note_name else note_name}                      | {to_lakhs(result['total'])}  
+"""
+        notes.append({'Note': note_name, 'Content': content, 'Total': result['total'], 'Matched_Accounts': len(result.get('matched_accounts', []))})
+    return notes

app/pnl.py

@@ -0,0 +1,292 @@
+import os
+import json
+import logging
+from typing import Optional, Dict, Any
+from openpyxl import Workbook
+from openpyxl.styles import Font, Border, Side, Alignment
+from openpyxl.utils import get_column_letter
+from datetime import datetime
+from pydantic import BaseModel, ValidationError
+from pydantic_settings import BaseSettings
+
+# Configure logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+class Settings(BaseSettings):
+    """Application settings loaded from environment variables or .env file."""
+    notes_folder: str = "generated_notes"
+    output_folder: str = "pnl_excel"
+    output_file: str = "pnl_report.xlsx"
+
+settings = Settings()
+
+class NoteData(BaseModel):
+    note_number: Optional[str]
+    structure: Optional[Any]
+    notes_and_disclosures: Optional[list] = []
+
+def load_note_data(note_number: str, folder: str = settings.notes_folder) -> Optional[NoteData]:
+    """
+    Load note data for a specific note_number from notes.json in the specified folder.
+    Compatible with {"notes": [ ... ]} structure.
+    """
+    file_path = os.path.join(folder, "notes.json")
+    try:
+        with open(file_path, "r", encoding="utf-8") as f:
+            data = json.load(f)
+            notes = data.get("notes", [])
+            for note in notes:
+                n_num = note.get("note_number") or note.get("metadata", {}).get("note_number")
+                if str(n_num) == str(note_number):
+                    try:
+                        return NoteData(**note)
+                    except ValidationError as ve:
+                        logger.warning(f"Validation error for note {note_number}: {ve}")
+                        return None
+            logger.warning(f"Note {note_number} not found in {file_path}")
+            return None
+    except FileNotFoundError:
+        logger.warning(f"Note {note_number} file not found at {file_path}")
+        return None
+    except json.JSONDecodeError:
+        logger.warning(f"Invalid JSON in note {note_number}")
+        return None
+
+def extract_total_from_note(note_data: Optional[NoteData], year: str = "2024") -> float:
+    """Extract total value from note data for the specified year."""
+    if not note_data or not note_data.structure:
+        return 0.0
+    for category in note_data.structure:
+        if year == "2024" and "total" in category:
+            try:
+                return float(category["total"])
+            except (ValueError, TypeError):
+                continue
+        elif year == "2023" and "previous_total" in category:
+            try:
+                return float(category["previous_total"])
+            except (ValueError, TypeError):
+                continue
+    # If no total found, sum up subcategory values
+    total = 0.0
+    for category in note_data.structure:
+        if "subcategories" in category:
+            for subcat in category["subcategories"]:
+                if year == "2024" and "value" in subcat:
+                    try:
+                        total += float(subcat["value"])
+                    except (ValueError, TypeError):
+                        continue
+                elif year == "2023" and "previous_value" in subcat:
+                    try:
+                        total += float(subcat["previous_value"])
+                    except (ValueError, TypeError):
+                        continue
+    return total
+
+def extract_specific_value(note_data: Optional[NoteData], key: str, year: str = "2024") -> float:
+    """Extract specific value from note data based on key and year."""
+    if not note_data or not note_data.structure:
+        return 0.0
+    for category in note_data.structure:
+        if "subcategories" in category:
+            for subcat in category["subcategories"]:
+                label = subcat.get("label", "").lower().replace(" ", "").replace("-", "").replace("/", "").replace("&", "")
+                if key.lower() in label:
+                    if year == "2024" and "value" in subcat:
+                        try:
+                            return float(subcat["value"])
+                        except (ValueError, TypeError):
+                            continue
+                    elif year == "2023" and "previous_value" in subcat:
+                        try:
+                            return float(subcat["previous_value"])
+                        except (ValueError, TypeError):
+                            continue
+    return 0.0
+
+def format_currency(value: float) -> str:
+    """Format currency value for display."""
+    if isinstance(value, (int, float)) and value != 0:
+        return f"{value:,.2f}"
+    return "0.00"
+
+def generate_pnl_report() -> None:
+    """Generate P&L report in Excel format using data from generated_notes folder."""
+    wb = Workbook()
+    ws = wb.active
+    ws.title = "Profit and Loss Statement"
+
+    # Define styles
+    bold_font = Font(bold=True)
+    thin_border = Border(left=Side(style="thin"), right=Side(style="thin"),
+                        top=Side(style="thin"), bottom=Side(style="thin"))
+    center_align = Alignment(horizontal="center")
+    left_align = Alignment(horizontal="left")
+
+    # Set column widths
+    ws.column_dimensions["A"].width = 50
+    ws.column_dimensions["B"].width = 10
+    ws.column_dimensions["C"].width = 20
+    ws.column_dimensions["D"].width = 20
+
+    # Header
+    ws["A1"] = "Profit and Loss Statement for the Years Ended March 31, 2024 and 2023"
+    ws["A1"].font = bold_font
+    ws.merge_cells("A1:D1")
+    ws["A1"].alignment = center_align
+
+    # Table headers
+    headers = ["Particulars", "Note No.", "Year Ended 31.03.2024", "Year Ended 31.03.2023"]
+    for col, header in enumerate(headers, 1):
+        cell = ws.cell(row=3, column=col)
+        cell.value = header
+        cell.font = bold_font
+        cell.border = thin_border
+        cell.alignment = center_align if col > 1 else left_align
+
+    # Load all required notes
+    notes_data: Dict[str, Optional[NoteData]] = {}
+    for note_num in range(16, 29):  # Notes 16-28
+        notes_data[str(note_num)] = load_note_data(str(note_num))
+
+    # Calculate values
+    revenue_2024 = extract_total_from_note(notes_data.get("16"), "2024")
+    revenue_2023 = extract_total_from_note(notes_data.get("16"), "2023")
+    other_income_2024 = extract_total_from_note(notes_data.get("17"), "2024")
+    other_income_2023 = extract_total_from_note(notes_data.get("17"), "2023")
+    total_income_2024 = revenue_2024 + other_income_2024
+    total_income_2023 = revenue_2023 + other_income_2023
+
+    cost_materials_2024 = extract_total_from_note(notes_data.get("18"), "2024")
+    cost_materials_2023 = extract_total_from_note(notes_data.get("18"), "2023")
+    employee_benefit_2024 = extract_total_from_note(notes_data.get("19"), "2024")
+    employee_benefit_2023 = extract_total_from_note(notes_data.get("19"), "2023")
+    other_expenses_2024 = extract_total_from_note(notes_data.get("20"), "2024")
+    other_expenses_2023 = extract_total_from_note(notes_data.get("20"), "2023")
+    depreciation_2024 = extract_total_from_note(notes_data.get("21"), "2024")
+    depreciation_2023 = extract_total_from_note(notes_data.get("21"), "2023")
+    loss_assets_2024 = extract_total_from_note(notes_data.get("22"), "2024")
+    loss_assets_2023 = extract_total_from_note(notes_data.get("22"), "2023")
+    finance_costs_2024 = extract_total_from_note(notes_data.get("23"), "2024")
+    finance_costs_2023 = extract_total_from_note(notes_data.get("23"), "2023")
+    auditor_payment_2024 = extract_total_from_note(notes_data.get("24"), "2024")
+    auditor_payment_2023 = extract_total_from_note(notes_data.get("24"), "2023")
+
+    total_expenses_2024 = (cost_materials_2024 + employee_benefit_2024 + other_expenses_2024 +
+                          depreciation_2024 + loss_assets_2024 + finance_costs_2024 + auditor_payment_2024)
+    total_expenses_2023 = (cost_materials_2023 + employee_benefit_2023 + other_expenses_2023 +
+                          depreciation_2023 + loss_assets_2023 + finance_costs_2023 + auditor_payment_2023)
+
+    profit_before_exceptional_2024 = total_income_2024 - total_expenses_2024
+    profit_before_exceptional_2023 = total_income_2023 - total_expenses_2023
+
+    current_tax_2024 = extract_total_from_note(notes_data.get("25"), "2024")
+    current_tax_2023 = extract_total_from_note(notes_data.get("25"), "2023")
+    deferred_tax_2024 = extract_total_from_note(notes_data.get("26"), "2024")
+    deferred_tax_2023 = extract_total_from_note(notes_data.get("26"), "2023")
+
+    total_tax_2024 = current_tax_2024 + deferred_tax_2024
+    total_tax_2023 = current_tax_2023 + deferred_tax_2023
+
+    profit_after_tax_2024 = profit_before_exceptional_2024 - total_tax_2024
+    profit_after_tax_2023 = profit_before_exceptional_2023 - total_tax_2023
+
+    # P&L line items with calculated values
+    line_items = [
+        {"label": "I. Revenue from Operations", "note": "16", "value_2024": revenue_2024, "value_2023": revenue_2023},
+        {"label": "II. Other Income", "note": "17", "value_2024": other_income_2024, "value_2023": other_income_2023},
+        {"label": "III. Total Income (I + II)", "note": "", "value_2024": total_income_2024, "value_2023": total_income_2023},
+        {"label": "IV. Expenses", "note": "", "value_2024": "", "value_2023": ""},
+        {"label": "   Cost of Materials Consumed", "note": "18", "value_2024": cost_materials_2024, "value_2023": cost_materials_2023},
+        {"label": "   Employee Benefit Expense", "note": "19", "value_2024": employee_benefit_2024, "value_2023": employee_benefit_2023},
+        {"label": "   Other Expenses", "note": "20", "value_2024": other_expenses_2024, "value_2023": other_expenses_2023},
+        {"label": "   Depreciation and Amortisation Expense", "note": "21", "value_2024": depreciation_2024, "value_2023": depreciation_2023},
+        {"label": "   Loss on Sale of Assets & Investments", "note": "22", "value_2024": loss_assets_2024, "value_2023": loss_assets_2023},
+        {"label": "   Finance Costs", "note": "23", "value_2024": finance_costs_2024, "value_2023": finance_costs_2023},
+        {"label": "   Payment to Auditor", "note": "24", "value_2024": auditor_payment_2024, "value_2023": auditor_payment_2023},
+        {"label": "   Total Expenses", "note": "", "value_2024": total_expenses_2024, "value_2023": total_expenses_2023},
+        {"label": "V. Profit Before Exceptional and Extraordinary Items and Tax (III - IV)", "note": "", "value_2024": profit_before_exceptional_2024, "value_2023": profit_before_exceptional_2023},
+        {"label": "VI. Exceptional Items", "note": "27", "value_2024": extract_total_from_note(notes_data.get("27"), "2024"), "value_2023": extract_total_from_note(notes_data.get("27"), "2023")},
+        {"label": "VII. Profit Before Tax (V - VI)", "note": "", "value_2024": profit_before_exceptional_2024, "value_2023": profit_before_exceptional_2023},
+        {"label": "VIII. Tax Expense:", "note": "", "value_2024": "", "value_2023": ""},
+        {"label": "   (1) Current Tax", "note": "25", "value_2024": current_tax_2024, "value_2023": current_tax_2023},
+        {"label": "   (2) Deferred Tax", "note": "26", "value_2024": deferred_tax_2024, "value_2023": deferred_tax_2023},
+        {"label": "IX. Profit After Tax for the period (VII - VIII)", "note": "", "value_2024": profit_after_tax_2024, "value_2023": profit_after_tax_2023}
+    ]
+
+    # Write line items to Excel
+    row = 4
+    for item in line_items:
+        ws.cell(row=row, column=1).value = item["label"]
+        ws.cell(row=row, column=2).value = item["note"]
+        ws.cell(row=row, column=3).value = format_currency(item["value_2024"]) if item["value_2024"] != "" else ""
+        ws.cell(row=row, column=4).value = format_currency(item["value_2023"]) if item["value_2023"] != "" else ""
+        for col in range(1, 5):
+            ws.cell(row=row, column=col).border = thin_border
+            ws.cell(row=row, column=col).alignment = center_align if col > 1 else left_align
+            if item["label"].startswith(("I.", "II.", "III.", "IV.", "V.", "VI.", "VII.", "VIII.", "IX.")):
+                ws.cell(row=row, column=col).font = bold_font
+        row += 1
+
+    # Add notes and disclosures
+    row += 1
+    ws.cell(row=row, column=1).value = "Notes:"
+    ws.cell(row=row, column=1).font = bold_font
+    row += 1
+
+    # Add any specific disclosures from notes
+    note_20_data = notes_data.get("20")
+    if note_20_data and note_20_data.notes_and_disclosures:
+        ws.cell(row=row, column=1).value = note_20_data.notes_and_disclosures[0]
+        ws.cell(row=row, column=1).alignment = left_align
+        row += 1
+
+    # EPS information (if available in notes 27-28)
+    eps_data = notes_data.get("28")  # Assuming EPS is in note 28
+    if eps_data:
+        ws.cell(row=row, column=1).value = "Earnings Per Share (EPS):"
+        ws.cell(row=row, column=1).font = bold_font
+        row += 1
+
+        basic_eps_2024 = extract_specific_value(eps_data, "basic", "2024")
+        basic_eps_2023 = extract_specific_value(eps_data, "basic", "2023")
+        diluted_eps_2024 = extract_specific_value(eps_data, "diluted", "2024")
+        diluted_eps_2023 = extract_specific_value(eps_data, "diluted", "2023")
+
+        ws.cell(row=row, column=1).value = "   Basic EPS"
+        ws.cell(row=row, column=3).value = format_currency(basic_eps_2024)
+        ws.cell(row=row, column=4).value = format_currency(basic_eps_2023)
+        ws.cell(row=row, column=1).alignment = left_align
+        ws.cell(row=row, column=3).alignment = center_align
+        ws.cell(row=row, column=4).alignment = center_align
+        row += 1
+
+        ws.cell(row=row, column=1).value = "   Diluted EPS"
+        ws.cell(row=row, column=3).value = format_currency(diluted_eps_2024)
+        ws.cell(row=row, column=4).value = format_currency(diluted_eps_2023)
+        ws.cell(row=row, column=1).alignment = left_align
+        ws.cell(row=row, column=3).alignment = center_align
+        ws.cell(row=row, column=4).alignment = center_align
+
+    # Save Excel file with error handling
+    output_folder = settings.output_folder
+    os.makedirs(output_folder, exist_ok=True)
+    output_file = os.path.join(output_folder, settings.output_file)
+    try:
+        wb.save(output_file)
+        logger.info(f"P&L report generated successfully and saved to {output_file}")
+    except PermissionError:
+        logger.error(f"PermissionError: Unable to save to {output_file}. Trying alternative location...")
+        fallback_file = os.path.join(os.path.expanduser("~"), "Desktop", "pnl_report_fallback.xlsx")
+        try:
+            wb.save(fallback_file)
+            logger.info(f"P&L report saved to alternative location: {fallback_file}")
+        except Exception as e:
+            logger.error(f"Failed to save P&L report: {str(e)}")
+    except Exception as e:
+        logger.error(f"Error saving P&L report: {str(e)}")
+
+if __name__ == "__main__":
+    generate_pnl_report()

app/utils.py

@@ -0,0 +1,57 @@
+import logging
+from typing import Any, Union
+
+# Configure logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+def clean_value(value: Union[str, float, int, None]) -> float:
+    """
+    Clean and convert a value to float.
+    Removes commas from strings and strips whitespace.
+    Returns 0.0 if conversion fails.
+    """
+    try:
+        if isinstance(value, str):
+            value = value.replace(',', '').strip()
+        return float(value) if value else 0.0
+    except (ValueError, TypeError):
+        logger.debug(f"Could not clean value: {value}")
+        return 0.0
+
+def to_lakhs(value: Union[float, int, str]) -> float:
+    """
+    Convert a numeric value to lakhs (divide by 100,000 and round to 2 decimals).
+    Accepts int, float, or numeric string.
+    """
+    try:
+        if isinstance(value, str):
+            value = float(value.replace(',', '').strip())
+        return round(float(value) / 100000, 2)
+    except (ValueError, TypeError):
+        logger.debug(f"Could not convert to lakhs: {value}")
+        return 0.0
+
+def convert_note_json_to_lakhs(note_json: Any) -> Any:
+    """
+    Recursively convert all numeric values in a note JSON to lakhs.
+    Returns the converted object.
+    """
+    def convert(obj: Any) -> Any:
+        if isinstance(obj, dict):
+            for k, v in obj.items():
+                if isinstance(v, (int, float)):
+                    obj[k] = to_lakhs(v)
+                elif isinstance(v, str):
+                    try:
+                        obj[k] = to_lakhs(float(v.replace(',', '')))
+                    except Exception:
+                        obj[k] = v
+                else:
+                    obj[k] = convert(v)
+        elif isinstance(obj, list):
+            for i in range(len(obj)):
+                obj[i] = convert(obj[i])
+        return obj
+
+    return convert(note_json)

app/utils_normalize.py

@@ -0,0 +1,95 @@
+import logging
+from typing import Any, Dict, List, Optional
+from pydantic import BaseModel, ValidationError
+
+# Configure logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+class NormalizedNote(BaseModel):
+    note_number: Optional[str]
+    note_title: Optional[str]
+    full_title: Optional[str]
+    table_data: List[Dict[str, Any]]
+    breakdown: Dict[str, Any] = {}
+    matched_accounts: List[Any] = []
+    total_amount: Optional[float] = None
+    total_amount_lakhs: Optional[float] = None
+    matched_accounts_count: Optional[int] = None
+    comparative_data: Dict[str, Any] = {}
+    notes_and_disclosures: List[str] = []
+    markdown_content: Optional[str] = ""
+
+def is_date_label(label: str) -> bool:
+    """Check if a label is a date string."""
+    import re
+    return bool(re.match(r"^(March|April|May|June|July|August|September|October|November|December)\s+\d{1,2},\s+\d{4}$", label)) \
+        or bool(re.match(r"^\d{4}-\d{2}-\d{2}$", label))
+
+def normalize_llm_note_json(llm_json: Dict[str, Any]) -> Dict[str, Any]:
+    """
+    Normalize a single LLM-generated note JSON to standard format.
+    Returns a dict compatible with NormalizedNote.
+    """
+    note_number = llm_json.get("note_number") or llm_json.get("metadata", {}).get("note_number", "")
+    note_title = llm_json.get("note_title") or llm_json.get("title", "")
+    full_title = llm_json.get("full_title") or (f"{note_number}. {note_title}" if note_number else note_title)
+
+    table_data: List[Dict[str, Any]] = []
+
+    if "structure" in llm_json and llm_json["structure"]:
+        for item in llm_json["structure"]:
+            if "subcategories" in item and item["subcategories"]:
+                for sub in item["subcategories"]:
+                    label = sub.get("label", "")
+                    if not is_date_label(label):
+                        row = {
+                            "particulars": label,
+                            "current_year": sub.get("value", ""),
+                            "previous_year": sub.get("previous_value", "-"),
+                        }
+                        table_data.append(row)
+            if "category" in item and ("total" in item or "previous_total" in item):
+                row = {
+                    "particulars": f"Total {item.get('category', '')}",
+                    "current_year": item.get("total", ""),
+                    "previous_year": item.get("previous_total", "-"),
+                }
+                table_data.append(row)
+
+    # Optionally, add a header row
+    if table_data:
+        table_data.insert(0, {
+            "particulars": "Particulars",
+            "current_year": "March 31, 2024",
+            "previous_year": "March 31, 2023"
+        })
+
+    normalized = {
+        "note_number": note_number,
+        "note_title": note_title,
+        "full_title": full_title,
+        "table_data": table_data,
+        "breakdown": {},
+        "matched_accounts": [],
+        "total_amount": None,
+        "total_amount_lakhs": None,
+        "matched_accounts_count": None,
+        "comparative_data": {},
+        "notes_and_disclosures": [],
+        "markdown_content": llm_json.get("markdown_content", ""),
+    }
+    try:
+        # Validate with Pydantic model
+        NormalizedNote(**normalized)
+    except ValidationError as ve:
+        logger.warning(f"Validation error in normalized note: {ve}")
+    return normalized
+
+def normalize_llm_notes_json(llm_json: Dict[str, Any]) -> Dict[str, Any]:
+    """
+    Accepts {"notes": [ ... ]} and returns {"notes": [ ...normalized... ]}
+    """
+    notes = llm_json.get("notes", [])
+    normalized_notes = [normalize_llm_note_json(note) for note in notes]
+    return {"notes": normalized_notes}

config/mapping1.json

@@ -0,0 +1,744 @@
+{
+  "Capital Account": "Equity",
+  "Reserves & Surplus": "Equity",
+  "Share Capital": "Equity",
+  "Share Premium Account": "Equity",
+  "Loans (Liability)": "Non-Current Liability",
+  "DAIMLER FINANCIAL SERVICES INDIA PVT LTD": "Non-Current Liability",
+  "Loan From APSFC HYDERABAD": "Non-Current Liability",
+  "Loan From ICICI Bank 603090031420": "Non-Current Liability",
+  "LOAN FROM SBI SME HYDERABAD 40392204781": "Non-Current Liability",
+  "Current Liabilities": "Current Liability",
+  "Duties & Taxes": "Current Liability",
+  "Provisions": "Current Liability",
+  "Sundry Creditors": "Current Liability",
+  "Expenses Payable": "Current Liability",
+  "Commission Payable": "Current Liability",
+  "Interest Payable on APSFC LOAN": "Current Liability",
+  "Refundable Advance": "Current Liability",
+  "Fixed Assets": "Non-Current Asset",
+  "Equipments": "Non-Current Asset",
+  "Furniture & Fixtures": "Non-Current Asset",
+  "Accumulated Depreciation": "Accumulated Depreciation",
+  "Bar Code Scanner and Printer": "Non-Current Asset",
+  "MERCEDES-BENZ CAR": "Non-Current Asset",
+  "PURCHASE OF COMMERCIAL BULIDING": "Non-Current Asset",
+  "Current Assets": "Current Asset",
+  "Opening Stock": "Current Asset",
+  "Deposits (Asset)": "Current Asset",
+  "Loans & Advances (Asset)": "Current Asset",
+  "Sundry Debtors": "Current Asset",
+  "Cash-in-Hand": "Current Asset",
+  "Bank Accounts": "Current Asset",
+  "GST Input Tax Credit": "Current Asset",
+  "Advance to Perennail Code IT Consultants Pvt Ltd": "Current Asset",
+  "Prepaid Expenses": "Current Asset",
+  "TCS RECEIVABLES": "Current Asset",
+  "Tds & Advance Tax Fy -2021-2022": "Current Asset",
+  "TDS Advance Tax Paid SEC 100": "Current Asset",
+  "Tds Receivables": "Current Asset",
+  "Sales Accounts": "Revenue from Operations",
+  "Servicing of BA/BE PROJECTS EXPORT": "Revenue from Operations",
+  "Servicing of BA/BE PROJECTS-Inter State": "Revenue from Operations",
+  "Servicing of BA/BE PROJECTS-Intra State": "Revenue from Operations",
+  "SERVICING OF BA PROJECTS-Intra State": "Revenue from Operations",
+  "SERVICING OF ONLY CLINICAL INTRA STATE": "Revenue from Operations",
+  "Working Standards - Export": "Revenue from Operations",
+  "Working Standards-Inter State": "Revenue from Operations",
+  "Working Standards-Intra State": "Revenue from Operations",
+  "Purchase Accounts": "Cost of Materials Consumed",
+  "Bio Lab Consumables": "Cost of Materials Consumed",
+  "Non GST": "Cost of Materials Consumed",
+  "Purchase GST": "Cost of Materials Consumed",
+  "Direct Expenses": "Direct Expenses",
+  "Ambulance Service Charges": "Direct Expenses",
+  "Aprons-Cp Dept": "Direct Expenses",
+  "BA/BE NOC Charges": "Direct Expenses",
+  "BE Center-Consultancy Charges": "Direct Expenses",
+  "CLINICAL TRAIL INSURANCE": "Direct Expenses",
+  "Dietician Charges": "Direct Expenses",
+  "ECG PAYMENT": "Direct Expenses",
+  "Oncall Nurse/ Plebhos Charges": "Direct Expenses",
+  "Oncall Phisian Charges": "Direct Expenses",
+  "PK And Statastical Analysis Charges": "Direct Expenses",
+  "Study Expenses": "Direct Expenses",
+  "Volunteers Screening Payments": "Direct Expenses",
+  "Volunteers Study Payments": "Direct Expenses",
+  "Indirect Incomes": "Other Income",
+  "Interest on FD": "Other Income",
+  "Interest on Income Tax Refund": "Other Income",
+  "Indirect Expenses": "Other Expenses",
+  "DIVIDEND PAID TO SHARE HOLDERS": "Other Expenses",
+  "Employee Expenditure": "Employee Benefits Expense",
+  "Airtel DTH Charges": "Other Expenses",
+  "Annual Maintenance Charges": "Other Expenses",
+  "BA Expenses": "Other Expenses",
+  "Bank Charges": "Other Expenses",
+  "Bio Medical Waste Disposal Charges": "Other Expenses",
+  "Business Development Expenses": "Other Expenses",
+  "Calibration Charges": "Other Expenses",
+  "Car Insurance": "Other Expenses",
+  "CDM AND CDISC SERVICES": "Other Expenses",
+  "Civil Works": "Other Expenses",
+  "Cold Storage Charges-Freezer": "Other Expenses",
+  "Commission": "Other Expenses",
+  "COnsultancy Charges": "Other Expenses",
+  "Courier and Postage Charges": "Other Expenses",
+  "CSR Fund Allocation/expenses": "Other Expenses",
+  "Customs Duty Payment": "Other Expenses",
+  "Diesel Expences For Vehicle(Car)": "Other Expenses",
+  "ELECTRICAL EXPENSES": "Other Expenses",
+  "Electricity Charges": "Other Expenses",
+  "Emergency Medicines": "Other Expenses",
+  "Fabrication Work Expenses": "Other Expenses",
+  "Fire Extingushiers Refilling Charges": "Other Expenses",
+  "Food Expenses for Guests": "Other Expenses",
+  "Forex Gain / Loss": "Other Income",
+  "Generator -Diesel Expenses": "Other Expenses",
+  "Gratutity Paid to Staff": "Employee Benefits Expense",
+  "Group Health Insurence for Emp": "Employee Benefits Expense",
+  "GST Default Amount FY 2019-20": "Other Expenses",
+  "Hdfcergo General Insurance": "Other Expenses",
+  "HOUSE KEEPING CHARGES": "Other Expenses",
+  "House Keeping Materials": "Other Expenses",
+  "IEC Certificate Charges": "Other Expenses",
+  "Incentives to Staff": "Employee Benefits Expense",
+  "INSURANCE FOR ASSETS BUGLARY": "Other Expenses",
+  "INSURANCE FOR ASSETS FIRE POLICY": "Other Expenses",
+  "Interest of Car Loan": "Finance Cost",
+  "Interest on APSFC Loan": "Finance Cost",
+  "Interest on ICICI Loan-Commercial Building": "Finance Cost",
+  "Interest on Loan From SBI": "Finance Cost",
+  "Interest on TDS": "Finance Cost",
+  "Interest Paid": "Finance Cost",
+  "Interest Under 234 C Fy 2021-22": "Finance Cost",
+  "IT Expenses": "Other Expenses",
+  "Labour Licence": "Other Expenses",
+  "Lab Testing Charges": "Other Expenses",
+  "Loan Processing Charges": "Other Expenses",
+  "Maxwell PHARMA": "Other Expenses",
+  "Office Expenses": "Other Expenses",
+  "Pantry Expenses": "Other Expenses",
+  "Pest Control Charges": "Other Expenses",
+  "Plumbing Expenses": "Other Expenses",
+  "Plumbing Material": "Other Expenses",
+  "PRINTING AND STATIONERY": "Other Expenses",
+  "Processing Charges": "Other Expenses",
+  "Professional & Consultancy Fee": "Other Expenses",
+  "Professional Fee-Legal": "Other Expenses",
+  "Property Tax for Zenrise- Centre1": "Other Expenses",
+  "Protocol Review/IEC Charges": "Other Expenses",
+  "Rates and Taxes": "Other Expenses",
+  "Registration Fee": "Other Expenses",
+  "Remuniration to Directors": "Employee Benefits Expense",
+  "Rent of the Premises": "Other Expenses",
+  "Repairs and Maintenance": "Other Expenses",
+  "Retainership Fees": "Other Expenses",
+  "Round Off": "Other Expenses",
+  "Salary": "Employee Benefits Expense",
+  "SECURITY SERVICES": "Other Expenses",
+  "Service Charges": "Other Expenses",
+  "Sitting Fee of Directors": "Other Expenses",
+  "Software Equipment": "Non-Current Asset",
+  "SOFTWARE RENEWAL FEES": "Other Expenses",
+  "Staff Comp Offs and OTs": "Employee Benefits Expense",
+  "Staff Food Expenses": "Employee Benefits Expense",
+  "Stamp Duty": "Other Expenses",
+  "Stamp Papers": "Other Expenses",
+  "Storage Charges": "Other Expenses",
+  "Study Food Expences": "Other Expenses",
+  "Tax on Professional Charges": "Other Expenses",
+  "Telephone and Internet Charges": "Other Expenses",
+  "Trade License Expenses": "Other Expenses",
+  "Translation Charges": "Other Expenses",
+  "Transportation and Unloading Charges": "Other Expenses",
+  "Travelling Expences": "Other Expenses",
+  "Wages for Contract Employees": "Employee Benefits Expense",
+  "Water Cans Expenses": "Other Expenses",
+  "Water Charges (Hyderabad Metropolitan": "Other Expenses",
+  "Wooden Work Expenses": "Other Expenses",
+  "X-RAY CHARGES": "Other Expenses",
+  "Non-Current Liabilities": "Non-Current Liability",
+  "Deferred Tax Liability": "Deferred Tax Liability",
+  "Profit & Loss A/c": "Profit and Loss Account",
+  "Unadjusted Forex Gain/Loss": "Other Income",
+  "Advance Tax": "Current Asset",
+  "APC Schneider (UPS 3KVA/2.4KW)": "Fixed Asset",
+  "Apple Ipad": "Fixed Asset",
+  "Apple Iphone 12 Max Pro": "Fixed Asset",
+  "Apple Iphone 12 Max Pro - 2": "Fixed Asset",
+  "Apple Iphone XS": "Fixed Asset",
+  "Apple M2 Pro Laptop": "Fixed Asset",
+  "Apple M3 Pro Laptop": "Fixed Asset",
+  "Apple Macbook Pro - A1990": "Fixed Asset",
+  "Apple Watch": "Fixed Asset",
+  "Canon Printer cum Scanner - 1": "Fixed Asset",
+  "Canon Printer cum Scanner - 2": "Fixed Asset",
+  "CD Balance GHI & GPA - Aditya Birla Health Insurance Co Ltd": "Current Asset",
+  "CD Balance GTLI - Tata AIA Life Insurance Company Limited": "Current Asset",
+  "Citi Bank (528828019)": "Current Asset",
+  "Deferred Revenue Expenditure": "Other Asset",
+  "Deferred Tax Asset": "Other Asset",
+  "Dell LAPTOP_Batch-19": "Fixed Asset",
+  "Dell LAPTOP_Batch-20": "Fixed Asset",
+  "Dell LAPTOP_Batch-21": "Fixed Asset",
+  "EPSON Projector": "Fixed Asset",
+  "Fortigate Firewall (Server) - BLR": "Fixed Asset",
+  "Fortigate Firewall (Server) - HYD": "Fixed Asset",
+  "Godrej Safe": "Fixed Asset",
+  "Godrej Wardrobe": "Fixed Asset",
+  "HP Printer cum Scanner - 1": "Fixed Asset",
+  "Input CGST": "Input Tax Credit",
+  "Input IGST": "Input Tax Credit",
+  "Input SGST": "Input Tax Credit",
+  "IT Server": "Fixed Asset",
+  "Kotak Mahindra Bank (2012183177)": "Current Asset",
+  "Kotak Mahindra Bank (2013992013)": "Current Asset",
+  "Lenovo Desktop CPU": "Fixed Asset",
+  "Lenovo Laptop - E580": "Fixed Asset",
+  "Lenovo LAPTOP_Batch-1": "Fixed Asset",
+  "Lenovo LAPTOP_Batch-10": "Fixed Asset",
+  "Lenovo LAPTOP_Batch-11": "Fixed Asset",
+  "Lenovo LAPTOP_Batch-12": "Fixed Asset",
+  "Lenovo LAPTOP_Batch-13": "Fixed Asset",
+  "Lenovo LAPTOP_Batch-14": "Fixed Asset",
+  "Lenovo LAPTOP_Batch-15": "Fixed Asset",
+  "Lenovo LAPTOP_Batch-16": "Fixed Asset",
+  "Lenovo LAPTOP_Batch-17": "Fixed Asset",
+  "Lenovo LAPTOP_Batch-18": "Fixed Asset",
+  "Lenovo LAPTOP_Batch-2": "Fixed Asset",
+  "Lenovo LAPTOP_Batch-3": "Fixed Asset",
+  "Lenovo LAPTOP_Batch-4": "Fixed Asset",
+  "Lenovo LAPTOP_Batch-5": "Fixed Asset",
+  "Lenovo LAPTOP_Batch-6": "Fixed Asset",
+  "Lenovo LAPTOP_Batch-7": "Fixed Asset",
+  "Lenovo LAPTOP_Batch-8": "Fixed Asset",
+  "Lenovo LAPTOP_Batch-9": "Fixed Asset",
+  "LG Projector - Batch-1": "Fixed Asset",
+  "LG Projector - Batch-2": "Fixed Asset",
+  "Logitech Web Camera - 1": "Fixed Asset",
+  "Petty Cash": "Current Asset",
+  "Prepaid - Employees Group Life Insurance": "Current Asset",
+  "Prepaid Assets Insurance": "Current Asset",
+  "Prepaid Expenses - Laptop AMC": "Current Asset",
+  "Prepaid Expenses - Laptop Extended Warranty": "Current Asset",
+  "Prepaid Insurance - Employees Health & Personal Accident": "Current Asset",
+  "Samsung Mobile Galaxy S9 SM-G960F": "Fixed Asset",
+  "Samsung Refrigerator - 1": "Fixed Asset",
+  "Seagate Hard Disc 2TB": "Fixed Asset",
+  "Security Deposit - ESIC": "Other Asset",
+  "Security Deposit - Hive Space": "Other Asset",
+  "Security Deposit - Incuspaze Solutions Private Limited": "Other Asset",
+  "Security Deposits - Awfis Space Solutions Private Limited": "Other Asset",
+  "Security Deposits - Concept Classic Converge": "Other Asset",
+  "Accounts Payable": "Current Liability",
+  "Payroll liabilities": "Current Liability",
+  "Profession Tax Payable": "Current Liability",
+  "Provident Fund Payables": "Current Liability",
+  "Provision for Gratuity": "Long-Term Liability",
+  "Provision for Professional Fee (Transfer Pricing)": "Long-Term Liability",
+  "Provision for Statutory Audit Fee": "Long-Term Liability",
+  "Provision for Tax": "Long-Term Liability",
+  "TDS Payable": "Current Liability",
+  "Gulf FZE (Related Party)": "Current Liability",
+  "Retained Earnings": "Equity",
+  "Shares Issued to Fadhlurahman": "Equity",
+  "Shares Issued to Mohammed Anwar": "Equity",
+  "Shares Issued to Veripark Yazilim Anonim Sirketi": "Equity",
+  "Sales": "Revenue from Operations",
+  "Annual Maintenance Charges - Laptop": "Other Expenses",
+  "Annual Profession Tax": "Other Expenses",
+  "Asset Insurance": "Other Expenses",
+  "Bank Fees and Charges": "Other Expenses",
+  "Consultancy & Service Fee": "Other Expenses",
+  "Conveyance Allowances": "Other Expenses",
+  "Deferred Tax Expense": "Other Expenses",
+  "Depreciation And Amortisation": "Other Expenses",
+  "Dues & Subscriptions": "Other Expenses",
+  "Employees Expenses Reimbursement": "Employee Benefits Expense",
+  "Employees Group Life Insurance": "Employee Benefits Expense",
+  "Employees Health & Personal Accident Insurance": "Employee Benefits Expense",
+  "Employer Contribution to EPF": "Employee Benefits Expense",
+  "Gratuity Expense": "Employee Benefits Expense",
+  "Income Tax": "Other Expenses",
+  "Laptop Accessories and Maintenance": "Other Expenses",
+  "Laptop Extended Warranty": "Other Expenses",
+  "Loss/Gain on Exchange Rate": "Other Income",
+  "Loss/Gain on Foreign Exchange": "Other Income",
+  "Office Rent": "Other Expenses",
+  "Other Expenses": "Other Expenses",
+  "Payroll Expenses": "Employee Benefits Expense",
+  "Per Diem Expenses": "Employee Benefits Expense",
+  "PF Administration & EDLI Charges": "Other Expenses",
+  "Postage & Courier Charges": "Other Expenses",
+  "Printing and Stationery": "Other Expenses",
+  "Professional Fee": "Other Expenses",
+  "Professional Fee (Transfer Pricing)": "Other Expenses",
+  "Registrations & Renewals": "Other Expenses",
+  "Retainership Fee": "Other Expenses",
+  "ROC Filing Fee": "Other Expenses",
+  "Round off": "Other Expenses",
+  "Staff Welfare Expenses": "Employee Benefits Expense",
+  "Statutory Audit Fee": "Other Expenses",
+  "Telephone Expense": "Other Expenses",
+  "Visa Expenses": "Other Expenses",
+  "GST Written off": "Other Expenses",
+  "Net Profit": "Profit and Loss Account",
+  "0% GST Output Tax": "Liability",
+  "12% IGST INPUT TAX": "Input Tax Credit",
+  "14% CGST Input Tax Credit": "Input Tax Credit",
+  "14% SGST Input Tax Credit": "Input Tax Credit",
+  "18% IGST INPUT TAX CREDIT": "Input Tax Credit",
+  "18% IGST Out Put Tax": "Liability",
+  "2.5% CGST INPUT TAX CREDIT": "Input Tax Credit",
+  "2.5% SGST INPUT TAX CREDIT": "Input Tax Credit",
+  "5% IGST INPUT CREDIT": "Input Tax Credit",
+  "6% CGST Input Tax Credit": "Input Tax Credit",
+  "6% SGST Input Tax Credit": "Input Tax Credit",
+  "9% CGST Input Tax Credit": "Input Tax Credit",
+  "9% CGST OUTPUT TAX": "Liability",
+  "9% SGST Input Tax Credit": "Input Tax Credit",
+  "9% SGST OUTPUT TAX": "Liability",
+  "AB SCIEX API 3200": "Fixed Asset",
+  "ACCESS CONTROL EQUIPMENT - IT DEPT": "Fixed Asset",
+  "ACP PANEL WORK": "Fixed Asset",
+  "Acs Installation Charges": "Expense",
+  "Adavnce to Ebiztechnix.Com Pvt Ltd": "Current Asset",
+  "Adavnce to Sucopeia Reference Standards OPC Pvt Ltd": "Current Asset",
+  "Adrta Technologies Pvt Lttd": "Current Asset",
+  "Advance for Rent Dr Rohit Prakash Kolipaka": "Current Asset",
+  "Advance for Rent M Kaushik Reddy": "Current Asset",
+  "Advance for Rent M Mayur Reddy": "Current Asset",
+  "Advance for Rent P Murali Krishna Chaitanya": "Current Asset",
+  "Advance for Rent SSK Tulasi Rao": "Current Asset",
+  "Advance for Rent Vimala Sravanthi Vajjala": "Current Asset",
+  "Advance for Rent V Vijaya Krishna Prasad": "Current Asset",
+  "Advance Given to B Nagarjuna VMO": "Current Asset",
+  "Advance Given to B Pavan Kumar": "Current Asset",
+  "Advance Given to Dr K Krishna Moorthy": "Current Asset",
+  "Advance Given to Dr Ragula Naveen": "Current Asset",
+  "Advance to Avantec Laboroatories": "Current Asset",
+  "ADVANCE TO I CLEAN TECHNOLOGIES": "Current Asset",
+  "Advance to K Hari Prasad": "Current Asset",
+  "Advance to K Sampath": "Current Asset",
+  "Advance to M Bhaskar": "Current Asset",
+  "Advance to M Prabhukumar": "Current Asset",
+  "Advance to NEPPALLI NARENDRA": "Current Asset",
+  "Advance to Perennail Code IT Conslultants Pvt Ltd": "Current Asset",
+  "Advance to Sudha Analytics": "Current Asset",
+  "Advance to Vemula Ravi Kumar": "Current Asset",
+  "Agilent Technologies": "Fixed Asset",
+  "A G Ravindranath Reddy": "Current Asset",
+  "AGR Corporate Consultants LLP": "Expense",
+  "AIR CONDITIONERS - Admin Dept": "Fixed Asset",
+  "AKIRA ANALYTICAL SOLUTIONS P LTD": "Current Asset",
+  "Akshaya Labtech": "Current Asset",
+  "Akshaya Scientific Pvt Ltd": "Current Asset",
+  "Akula Indira Prasanna": "Current Asset",
+  "Amazon": "Expense",
+  "AMBICA & COMPANY": "Current Asset",
+  "Amigo Techno Park Private Limited": "Current Asset",
+  "AMIS ENGINEERS": "Current Asset",
+  "Ample Enterprises": "Current Asset",
+  "AnalChem SPE": "Current Asset",
+  "Annual Fee for Demat RTA Services": "Expense",
+  "APL Research Centre": "Current Asset",
+  "Appco Pharma LLC, USA": "Current Asset",
+  "APSTEC SYSTEMS": "Current Asset",
+  "AR Interiors & Contrator": "Fixed Asset",
+  "ARJUN WATCH COMPANY": "Current Asset",
+  "Arnav Health Care": "Current Asset",
+  "Art Lab India Private Ltd.": "Current Asset",
+  "ASIAN SURGICAL COMPANY": "Current Asset",
+  "ATHENA TECHNOLOGIES": "Current Asset",
+  "ATRIA CONVERGENCE TECHNOLOGIES PVT LTD": "Expense",
+  "Audit Fee": "Expense",
+  "Audit Fee Payable": "Liability",
+  "AURO PHARMA INC": "Current Asset",
+  "AVS NARAYANA": "Current Asset",
+  "Axis Bank KUKATPALLY A/C": "Current Asset",
+  "AXIS BANK ,MIYAPUR A/C": "Current Asset",
+  "Axis Clinicals Limited": "Current Asset",
+  "AYSIT Solutions Private Limited": "Current Asset",
+  "Ayyappa Amubulance Service": "Expense",
+  "AYYAPPA MANAGEMENT SERVICES": "Expense",
+  "Azurity Pharmaceuticals,Inc": "Current Asset",
+  "Azurity Pharmaceuticals India LLP": "Current Asset",
+  "BADAL KUMAR MAHOPATRA": "Current Asset",
+  "Bajaj Allianz General Insurance": "Expense",
+  "B Balachari Carpenter": "Expense",
+  "Beetal Phone": "Fixed Asset",
+  "BEQSSE SERVICES -BRAZIL": "Current Asset",
+  "Beximco Pharmaceuticals Ltd": "Current Asset",
+  "BHARATHI AIRTEL LTD": "Expense",
+  "Bharat Science Apparatus Workshops": "Current Asset",
+  "BHAVANI ENTERPRISES": "Current Asset",
+  "Bhumeswar": "Current Asset",
+  "Bioagile Therapeutics Pvt Ltd": "Current Asset",
+  "Bio Organics & Applied Materials Pvt Ltd": "Current Asset",
+  "Bison Panels 75MM Thickness": "Fixed Asset",
+  "BLOOMEDHA INFO SOLUTIONS LTD": "Current Asset",
+  "BPL Multipara Monitors": "Fixed Asset",
+  "Brundavan Medical Needs": "Current Asset",
+  "BSreeLatha Rent Depost": "Current Asset",
+  "Business Combine Corporation": "Current Asset",
+  "BVVSN PRASAD": "Current Asset",
+  "C. Abhay kumar & Co.": "Expense",
+  "Calling Buttons - CP Dept": "Fixed Asset",
+  "Caltronix Healthcare Solutions": "Current Asset",
+  "CAPITAL INDIA FINANCE LTD": "Liability",
+  "Capital WIP - Centre 1": "Fixed Asset",
+  "Carpet Home Decor": "Fixed Asset",
+  "Cash": "Current Asset",
+  "Cash in Foreign Currency USD": "Current Asset",
+  "CCTV CAMERAS -IT DEPT": "Fixed Asset",
+  "Chemtopes": "Current Asset",
+  "CHOICE MARKETING": "Current Asset",
+  "Choudhary Enterprises": "Current Asset",
+  "Chromatography Solutions": "Current Asset",
+  "Chromatography World": "Current Asset",
+  "CHROME SOURCE": "Current Asset",
+  "Chrome source Pvt Ltd.": "Current Asset",
+  "City Glass Centre": "Current Asset",
+  "Civil Works-Siri Building": "Fixed Asset",
+  "CLEARSYNTH LABS LTD": "Current Asset",
+  "CLEARSYNTH LABS LTD (Hyd)": "Current Asset",
+  "Clinical Equipments - Cp Dept": "Fixed Asset",
+  "Clinitext Translation Services": "Expense",
+  "Clinvend Clinical Research Solutions": "Current Asset",
+  "Communities Heritage Pvt LTd.": "Current Asset",
+  "Consultancy Charges": "Expense",
+  "CONTRACT PHARMACAL CORPORATION USA": "Current Asset",
+  "Cooling Chambers - BA Dept": "Fixed Asset",
+  "Cooling Chambers - CP Dept": "Fixed Asset",
+  "Core Pharma LLC": "Current Asset",
+  "CROMA": "Current Asset",
+  "CRO Splendid Lab Pvt Ltd": "Current Asset",
+  "Customs Duty Payable Account": "Liability",
+  "Davy Chem Labs": "Current Asset",
+  "Deposit to G J MULTICLAVE INDIA PVT LTD": "Current Asset",
+  "Deposit to SLV SPECIALITY GASES PVT LTD": "Current Asset",
+  "DESKTOPS AND LAPTOPS": "Fixed Asset",
+  "DHL EXPRESS P LTD": "Expense",
+  "DHR Holding India Pvt Ltd": "Current Asset",
+  "Dr A T Bapuji": "Current Asset",
+  "Dr Bodapati Neeraja": "Current Asset",
+  "Dr K Krishna Moorthy": "Current Asset",
+  "Dr Kosuri Naga Murali": "Current Asset",
+  "Dr M Navya": "Current Asset",
+  "Dr Reddy's Laboartories Limited": "Current Asset",
+  "Dr. Venkat Sai Raj Kumar": "Current Asset",
+  "Durga Fabricators": "Current Asset",
+  "DVR AND HDD - IT DEPT": "Fixed Asset",
+  "ECG MACHINES": "Fixed Asset",
+  "Electrical Cables-Admin Dept": "Fixed Asset",
+  "Electrical Deposit": "Current Asset",
+  "Electrical Gadgets- CP Dept": "Fixed Asset",
+  "Electrical Transformer and Pannels": "Fixed Asset",
+  "E Mudhra Limited": "Current Asset",
+  "ENDPOINT DATA ANALYTICS PVT LTD": "Current Asset",
+  "EPF Contribution A/c": "Liability",
+  "Epic Pharma LLC": "Current Asset",
+  "Ertiga Car Insurance": "Expense",
+  "Esic Contribution": "Liability",
+  "Ethixinn Consulting & Research Solutions PVT LTD": "Current Asset",
+  "Excel Infotech": "Current Asset",
+  "Fabric Blinds": "Fixed Asset",
+  "Fedex Express Transportation and Supply Chain Servi": "Expense",
+  "Fixed Deposit 05880510013861": "Current Asset",
+  "Fixed Deposit 058810014070": "Current Asset",
+  "Fixed Deposit 058810014350": "Current Asset",
+  "Fixed Deposit 058810014816": "Current Asset",
+  "Fixed Deposit 058810014817": "Current Asset",
+  "Fixed Deposit 058810014895": "Current Asset",
+  "Fixed Deposit 058810015195": "Current Asset",
+  "Fixed Deposit 058810015702": "Current Asset",
+  "Fixed Deposit 058810015988": "Current Asset",
+  "Fixed Deposit 058813017503": "Current Asset",
+  "Fixed Deposit 058813022834": "Current Asset",
+  "Focus Exhibition and Leisure Tours Pvt Ltd": "Expense",
+  "Forex Card 5554491100927730": "Current Asset",
+  "Fortune Labels 'n' Systems": "Current Asset",
+  "FUJIFILM INDIA PVT LTD": "Current Asset",
+  "Furniture - Admin Dept": "Fixed Asset",
+  "Furniture - CP Dept": "Fixed Asset",
+  "Future General India Insurance Co. Ltd": "Expense",
+  "Garnier Office Systems": "Current Asset",
+  "GB AIR SOLUTIONS": "Current Asset",
+  "GC Health care": "Current Asset",
+  "GENERATOR": "Fixed Asset",
+  "G J Multiclave (India) Pvt Ltd": "Current Asset",
+  "GK ANALYTICS": "Current Asset",
+  "Global Technologies": "Current Asset",
+  "GLOBE FURNITURES & LIGHTINGS": "Fixed Asset",
+  "GPS CLOCKS": "Fixed Asset",
+  "G Pulla Reddy (Sweets)": "Expense",
+  "GRANULES INDIA LIMITED": "Current Asset",
+  "GRAVITI PHARMACEUTICALS": "Current Asset",
+  "GRID CHANNEL FALCEILING": "Fixed Asset",
+  "GST Payable": "Liability",
+  "GST Payable on RCM": "Liability",
+  "GST RCM INPUT": "Input Tax Credit",
+  "Guardian Drug Company": "Current Asset",
+  "Gulf Pharmaceutical Industries": "Current Asset",
+  "HAEMO SERVICE LABORATORIES": "Current Asset",
+  "Harish Kumar Chinni": "Current Asset",
+  "Health Care Needs": "Expense",
+  "Help Hospitals Pvt Ltd": "Current Asset",
+  "HIMALA WATER SUPPLY": "Expense",
+  "HINDUSTAN FIRE SAFETY PROTECTION": "Expense",
+  "HRMS Software": "Fixed Asset",
+  "Humidity Chamber - CP Dept": "Fixed Asset",
+  "Hyderabad Metro Water Service Board": "Expense",
+  "I3 Pharamaceuticals LLC USA": "Current Asset",
+  "ICICI BANK CHANDANAGAR 058805003515": "Current Asset",
+  "Icici Bank-Chandanagar-058805004234": "Current Asset",
+  "ICICI BANK -Dividend Account 058805007279": "Current Asset",
+  "ICICI LOMBARD GIC LTD": "Expense",
+  "Icon Irani Chai": "Expense",
+  "ICPMS Machine 7850 along with Spares": "Fixed Asset",
+  "ICU Equipments - CP Dept": "Fixed Asset",
+  "Implement Technologies": "Current Asset",
+  "Income Tax FY 23-24": "Liability",
+  "Income Tax Refund": "Current Asset",
+  "Inductive Quotient Analytics India Pvt Ltd": "Current Asset",
+  "Ineligible GST": "Expense",
+  "INEXUS BIOTECH PVT LTD": "Current Asset",
+  "Innosyn Life Sciences Pvt. Ltd.": "Current Asset",
+  "INSADEC SERVICES PRIVATE LIMITED": "Current Asset",
+  "INSTANT PRINT SOLUTIONS INDIA P LTD": "Expense",
+  "Insurance of  Properties": "Expense",
+  "Interest on FD Receivable": "Current Asset",
+  "InterGlobe Aviation Ltd": "Expense",
+  "IP PBX": "Fixed Asset",
+  "Jairam Bio Sciences": "Current Asset",
+  "JAYA SIRI ENTERPRISES": "Current Asset",
+  "Jet Speed Engineers": "Current Asset",
+  "J.K. Enterprises": "Current Asset",
+  "K.G.N Medi Care": "Current Asset",
+  "Kireeti Indenting & Exim Services Pvt Ltd": "Current Asset",
+  "KOTHARI FIRE SAFETY EQUIPMENTS": "Current Asset",
+  "K Prabhakar": "Current Asset",
+  "K Rama Satyanarayana": "Current Asset",
+  "Krishnaveni Printers": "Expense",
+  "LAB EQUIPMENT-BA Dept": "Fixed Asset",
+  "Lab Equipment-Cp Dept": "Fixed  Asset",
+  "Lab Expo": "Expense",
+  "Lab Modulure Furniture BA Dept": "Fixed Asset",
+  "LabNeeds": "Current Asset",
+  "Lab Needs Private Limited": "Current Asset",
+  "Labosys Instruments India Pvt Ltd": "Current Asset",
+  "Labtop Instruments Pvt Ltd": "Current Asset",
+  "LAMBROS Analytics Pvt Ltd": "Current Asset",
+  "Lan Cable Network - IT Dept": "Fixed Asset",
+  "LCGC Chrom Consumables LLP": "Current Asset",
+  "LCMS SYSTEM": "Fixed Asset",
+  "LEGAL ENTITY IDENTIFIER INDIA LTD": "Expense",
+  "Likhitha Diagnostics and Speciality Lab": "Current Asset",
+  "LKG Industrial Solutions": "Current Asset",
+  "LOGANATHAN SEKHAR": "Current Asset",
+  "LYRUS LIFE SCIENCES PVT LTD": "Current Asset",
+  "Maddi Bhanu Kiran Reddy": "Current Asset",
+  "MAHADEV ENTERPRISES": "Current Asset",
+  "Mankind Pharma Limited": "Current Asset",
+  "MARG INDEPENDENT ETHICS COMMITTEE": "Expense",
+  "Maruthi Air Conditioners": "Fixed Asset",
+  "Mataji Plywood Glass & Hardware": "Current Asset",
+  "MCA Filing Fees": "Expense",
+  "MDS BIO ANALYTICS PVT LTD": "Current Asset",
+  "Mediclin Clinical Services Private Limited": "Current Asset",
+  "MEDILINK ENTERPRISES P LTD": "Current Asset",
+  "MeReDoC Pharma Cosultancy": "Expense",
+  "METRO CASH AND CARRY": "Expense",
+  "Mint Pharmaceutical INC": "Current Asset",
+  "Modular Lab Furniture (Art Lab)": "Fixed Asset",
+  "Mokshy Surgicals": "Current Asset",
+  "Molecules Analytical Lab Solutions Pvt Ltd": "Current Asset",
+  "MR SCIENTIFICS": "Current Asset",
+  "Msn Laboratories Pvt Ltd": "Current Asset",
+  "MSP LAB INSTRUMENTS": "Current Asset",
+  "Mylan Laboratories Limited": "Current Asset",
+  "NATCO PHARMA LIMITED": "Current Asset",
+  "NEO TECHNIQUES": "Current Asset",
+  "NETPROPHETS CYBERWORKS PVT. LTD": "Current Asset",
+  "Nihon Scientifics": "Current Asset",
+  "Ninth Dimension IT Solutions Private Limited": "Current Asset",
+  "Novel Laboratories Inc D/B/A Lupin": "Current Asset",
+  "NSDL FEE DMAT ACCOUNT": "Expense",
+  "Office Equipments": "Fixed Asset",
+  "OPERATING SOFWARE KEYS": "Fixed Asset",
+  "Opulent Furniture": "Fixed Asset",
+  "ORBIT EXHIBITIONS PVT LTD": "Expense",
+  "ORIGIN Medicare Systems": "Current Asset",
+  "Others Payble Account": "Liability",
+  "Pavani Consultancy": "Expense",
+  "Pavan Traders": "Current Asset",
+  "Payable to Srinivas": "Liability",
+  "PCI Analyticals Pvt Ltd": "Current Asset",
+  "Peak Scientific Instruments (India) Pvt Ltd": "Current Asset",
+  "Pest Control Technics": "Expense",
+  "Phenomenex India Pvt Ltd": "Current Asset",
+  "Phones - IT Dept": "Fixed Asset",
+  "Pinnacle Life Science Pvt Ltd": "Current Asset",
+  "POWER LINKS Infra Tech Pvt Ltd": "Current Asset",
+  "Prasoft IT Services Private Limited": "Current Asset",
+  "Pravesha Industries Private Limited, Unit - I": "Current Asset",
+  "Pravesha Industries Private Limited, Unit-IV": "Current Asset",
+  "Pre Closure of Loan": "Expense",
+  "Premier Systems": "Current Asset",
+  "Pre-Operative Expenses Capitalised As FF": "Fixed Asset",
+  "Pre-Operative Expenses Capitalised As P&M": "Fixed Asset",
+  "PRINTERS - IT Dept": "Fixed Asset",
+  "Priority Advertising": "Expense",
+  "PRODIGY COMPUTERS & LAPTOPS P LTD": "Current Asset",
+  "Prof Tax": "Expense",
+  "Projector and Screen - IT Dept": "Fixed Asset",
+  "Provision for Income Tax": "Liability",
+  "Prroxy Technology": "Current Asset",
+  "PSR IT SERVICES PVT LTD": "Current Asset",
+  "Quality Calibration Laboratory": "Current Asset",
+  "Radiant Bio System": "Current Asset",
+  "RAFF AND HALL PHARMACY": "Current Asset",
+  "Rainbow Engineering & Manufacturing": "Current Asset",
+  "Rajesh Technical Services": "Current Asset",
+  "Ramanvita Solutions": "Current Asset",
+  "RAMSON GENSYSTEM SERVICES": "Current Asset",
+  "RAPSTECH SYSTEMS INDIA PRIVATE LIMITED": "Current Asset",
+  "Raptor Safety": "Current Asset",
+  "RATHAN RERIGERATION": "Current Asset",
+  "Ray Analyticals Instruments": "Current Asset",
+  "Rental Advance - Siri Raidurgam": "Current Asset",
+  "RICON PHARMA LLC": "Current Asset",
+  "Riki Global Trading Pvt Ltd": "Current Asset",
+  "Rising Pharmaceuticals": "Current Asset",
+  "R Sumana": "Current Asset",
+  "RYB Technologies": "Current Asset",
+  "Sai Baba Business Solutions Pvt Ltd": "Current Asset",
+  "Salaries Payable": "Liability",
+  "Sales GST": "Liability",
+  "SAMPLE BARCODE MAGEMENT SYSTEM": "Fixed Asset",
+  "SAMSON MS": "Current Asset",
+  "Sana Fabrication": "Current Asset",
+  "SAPTAGIRI TRADERS": "Current Asset",
+  "Satya Devaya Clinic Lab": "Current Asset",
+  "Savant Instruments Pvt Ltd": "Current Asset",
+  "Sciex India Private Ltd": "Current Asset",
+  "Scindler India Pvt Ltd": "Current Asset",
+  "Security Deposit to DFS Financials": "Current Asset",
+  "SG SANITATION": "Expense",
+  "SHANTHI ENGINEERING": "Current Asset",
+  "Share Capital Account of KOTA PARVATHINI": "Equity",
+  "Share Capital Indira Prasanna": "Equity",
+  "Share Capital of Apteka RX Inc": "Equity",
+  "Share Capital of Dr A T Bapuji Director": "Equity",
+  "Share Capital of K Anil Venkata Reddy": "Equity",
+  "Share Capital Of R Srinivas -Director": "Equity",
+  "Share Capital of S Rajesh Kumar Director": "Equity",
+  "Shares of Mrs Vishnu Bhotla Sunitha": "Equity",
+  "SHED CONSTRUCTION": "Fixed Asset",
+  "Shiva Project Binding": "Expense",
+  "Shree Mathaji Electricals": "Current Asset",
+  "SHRI BALAZEE CATERING SERVICES": "Expense",
+  "SIDDHARTHA MEDICAL COLLEGE": "Current Asset",
+  "SIGMA PHARMA USA": "Current Asset",
+  "Simco Calibration & Testing Pvt Ltd": "Current Asset",
+  "SIMSON PHARMA LIMITED": "Current Asset",
+  "S Kalyan": "Current Asset",
+  "SKANRAY TECHNOLOGIES": "Current Asset",
+  "S.K.C Agencies": "Current Asset",
+  "SKG Pharma Inc": "Current Asset",
+  "SLAYBACK PHARMA INDIA LLP": "Current Asset",
+  "SLV Speciality Gases Private Limited": "Current Asset",
+  "Smart Labtech Pvt Ltd": "Current Asset",
+  "Smoke Detectors and Fire Alaram Expenses": "Expense",
+  "SMR Sales And Services": "Current Asset",
+  "Snowman Logistics Limited": "Expense",
+  "Sohan Healthcare Pvt Ltd": "Current Asset",
+  "SPEAKERS - IT DEPT": "Fixed Asset",
+  "SPINCOTECH PVT LTD": "Current Asset",
+  "SREE V LINK TELECOM INTEGRATOR": "Current Asset",
+  "SRESHTH PRINT HUB": "Expense",
+  "Sri Karyasiddhi Veeranjaneya Services": "Expense",
+  "Sri Lakshmi Moon and Bright Laundry Services": "Expense",
+  "Sri Laxmi Dry Ice & Gases": "Expense",
+  "Sri Nandini Air Conditioning Works": "Current Asset",
+  "Sri Sai Home Needs": "Expense",
+  "Sri Sai Power Solutions": "Current Asset",
+  "Sri Sai Ram Enterprises": "Current Asset",
+  "Sri Vasavi Enginerring": "Current Asset",
+  "Sri Venkateshwara Prefab": "Current Asset",
+  "S S ANALYTICALS": "Current Asset",
+  "S Siva Parvathi": "Current Asset",
+  "S S RACKS": "Fixed Asset",
+  "SSR Facility Management Services": "Expense",
+  "STP TANK": "Fixed Asset",
+  "Subtle Pharmaceuticals Private Limited": "Current Asset",
+  "SV Aircon": "Current Asset",
+  "SVVSS COMPUTERS": "Current Asset",
+  "System Software Server": "Fixed Asset",
+  "Tables & Chairs - Admin Dept": "Fixed Asset",
+  "T CHANDRA SEKHARA SARMA": "Current Asset",
+  "TCS Payble 206C 6CE": "Liability",
+  "TDS ON INTERESTOTHER THAN SECURITIES SEC 194A": "Liability",
+  "Tds on Professional Services Sec194 , 94J": "Liability",
+  "TDS ON RENT SEC 194, 94I": "Liability",
+  "TDS ON SALARIES SEC 192 92B": "Liability",
+  "TDS PAYMENT CONTRACT 194 C": "Liability",
+  "TDS SEC 195": "Liability",
+  "TecPharma": "Current Asset",
+  "Tempocon Express Pvt Ltd": "Expense",
+  "T GARGEYA": "Current Asset",
+  "The Professional Couriers LTD": "Expense",
+  "Thermo Fisher Certrifuge Apparatus - BA Dept": "Fixed Asset",
+  "THERMO FISHER SCIENTIFIC INDIA PVT LTD": "Current Asset",
+  "T.Leela Rent": "Expense",
+  "T Leela Rent Deposit": "Current Asset",
+  "T Nageswara Rao Carpentor": "Expense",
+  "TORRENT PHARMACEUTICALS LTD": "Current Asset",
+  "TOUGHENED GLASS DOORS": "Fixed Asset",
+  "TOUGHENED GLASS DOORS - Admin Dept": "Fixed Asset",
+  "Trolleys": "Fixed Asset",
+  "T Sridhar (Poojari)": "Expense",
+  "TSSPDCL": "Expense",
+  "TVS AND FRIDGES": "Fixed Asset",
+  "UNI CAL LABS PVT LTD": "Current Asset",
+  "Universal Instruments": "Current Asset",
+  "UPS SYSTEM": "Fixed Asset",
+  "U Srinivasulu (Dietician)": "Expense",
+  "Vasavi Hospital": "Current Asset",
+  "Vasudha Enviro Labs Pvt Ltd": "Current Asset",
+  "V Clean Technology": "Current Asset",
+  "Veldanda Traders": "Current Asset",
+  "VelZen Pharma Pvt Ltd": "Current Asset",
+  "V-ENSURE PHARMA TECHNOLOGIES PVT LTD": "Current Asset",
+  "Venture Capital and Corporate Investments PVT LTD": "Current Asset",
+  "Vidith Powers": "Current Asset",
+  "Vignesh Scientifics Technologies": "Current Asset",
+  "Vijaya Textiles": "Current Asset",
+  "Vinayaka Foods": "Expense",
+  "Vista Labs": "Current Asset",
+  "Vivan Life Sciences Pvt Ltd": "Current Asset",
+  "VM Sciences": "Current Asset",
+  "Volunteer BEDS - CP Dept": "Fixed Asset",
+  "VRK BUSINESS SOLUTIONS": "Current Asset",
+  "V Satyanarayana Rao": "Current Asset",
+  "VSL Electronics": "Current Asset",
+  "V Swapna Chai": "Expense",
+  "WALL PANEL SYSTEM-Admin Dept": "Fixed Asset",
+  "Wash O Wash": "Expense",
+  "Water Charges (Hyderabad Metropolitan)": "Expense",
+  "Weighing Machines-BA Dept": "Fixed Asset",
+  "Weighing Machines - CP Dept": "Fixed Asset",
+  "Weighing & Measuring Instrument Corporation": "Current Asset",
+  "Wishmen Life Sciences Pvt Ltd": "Current Asset",
+  "Wooden Partitions and Cupboards": "Fixed Asset",
+  "Writers Business Services Pvt Ltd": "Current Asset",
+  "Written Off": "Expense",
+  "WWF CSR Fund": "Expense",
+  "YOOSHITHA AUTO ENTERPRISES": "Current Asset",
+  "Yoshitha Traders": "Current Asset",
+  "Zef Scientific India Pvt Ltd": "Current Asset",
+  "ZENARA PHARMA PVT LTD": "Current Asset",
+  "ZODIAC LIFE SCIENCES PVT LTD": "Current Asset",
+  "Difference in opening balances": "Equity"
+}

config/rules1.json

@@ -0,0 +1,15 @@
+{
+  "Equity": ["capital", "share", "reserve", "surplus", "premium"],
+  "Non-Current Liability": ["loan", "liability", "debt", "borrowing"],
+ "Current Liability": ["payable", "creditor", "tax", "duty", "refundable", "advance.*received"],
+  "Non-Current Asset": ["asset", "equipment", "furniture", "vehicle", "building", "depreciation"],
+  "Current Asset": ["advance.*to", "advance.*given", "deposit", "prepaid","cash", "bank", "debtor", "receivable", "stock", "deposit", "prepaid", "input", "credit"],
+  "Revenue from Operations": ["sales", "service", "revenue", "turnover", "income"],
+  "Cost of Materials Consumed": ["purchase", "consumable", "material", "stock"],
+  "Direct Expenses": ["charge", "payment", "expense", "study", "volunteer", "insurance", "consultancy", "nurse", "physician", "analysis", "screening"],
+  "Other Income": ["interest", "gain", "refund"],
+  "Other Expenses": ["maintenance", "repair", "rent", "electricity", "water", "housekeeping", "travel", "transport", "printing", "stationery", "software", "fee", "license", "tax", "duty"],
+  "Employee Benefits Expense": ["salary", "wage", "staff", "employee", "gratuity", "incentive", "remuneration", "director", "compensation"],
+  "Finance Cost": ["interest", "finance", "bank charge"]
+  
+}

docker-compose.yml

@@ -0,0 +1,19 @@
+version: '3.9'
+
+services:
+  fastapi-api:
+    build: .
+    container_name: financial-notes-api
+    ports:
+      - "8000:8000"
+    volumes:
+      - ./input:/app/input
+      - ./output1:/app/output1
+      - ./generated_notes:/app/generated_notes
+      - ./.env:/app/.env
+    environment:
+      - PYTHONUNBUFFERED=1
+      - PORT=8000
+    env_file:
+      - .env
+    restart: unless-stopped

pnlbs/bl_llm.py

@@ -0,0 +1,835 @@
+import os
+import json
+import re
+import logging
+from datetime import datetime
+from typing import Any, Dict, List, Optional
+from openpyxl import Workbook
+from openpyxl.styles import Font, Border, Side, Alignment
+import requests
+from dotenv import load_dotenv
+from pydantic import BaseModel, Field, ValidationError
+from pydantic_settings import BaseSettings
+
+load_dotenv()
+
+# Configure logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+class Settings(BaseSettings):
+    """Application settings loaded from environment variables or .env file."""
+    api_key: str = Field(default_factory=lambda: os.getenv("OPENROUTER_API_KEY", ""), env="OPENROUTER_API_KEY")
+    input_file: str = Field(default="clean_financial_data_bs.json", env="INPUT_FILE")
+    output_dir: str = Field(default="output", env="BL_OUTPUT_DIR")
+
+settings = Settings()
+
+class BalanceSheetItem(BaseModel):
+    category: str
+    subcategory: Optional[str] = ""
+    name: str
+    note: Optional[str] = ""
+    value_2024: float
+    value_2023: float
+
+class BalanceSheetTotals(BaseModel):
+    shareholders_funds_2024: float = 0.0
+    shareholders_funds_2023: float = 0.0
+    non_current_liabilities_2024: float = 0.0
+    non_current_liabilities_2023: float = 0.0
+    current_liabilities_2024: float = 0.0
+    current_liabilities_2023: float = 0.0
+    non_current_assets_2024: float = 0.0
+    non_current_assets_2023: float = 0.0
+    current_assets_2024: float = 0.0
+    current_assets_2023: float = 0.0
+    total_equity_liabilities_2024: float = 0.0
+    total_equity_liabilities_2023: float = 0.0
+    total_assets_2024: float = 0.0
+    total_assets_2023: float = 0.0
+    balance_difference_2024: float = 0.0
+    balance_difference_2023: float = 0.0
+
+class EnhancedBalanceSheetGenerator:
+    def __init__(self, api_key: str):
+        self.api_key = api_key
+        self.base_url = "https://openrouter.ai/api/v1/chat/completions"
+        
+        # Enhanced mapping with multiple patterns
+        self.field_mappings = {
+            # Share Capital patterns
+            'share_capital': [
+                'share capital', 'equity share', 'paid up', 'issued shares', 
+                'authorised shares', 'subscribed', 'fully paid'
+            ],
+            # Reserves patterns
+            'reserves_surplus': [
+                'reserves and surplus', 'reserves', 'surplus', 'retained earnings',
+                'profit and loss', 'general reserves', 'closing balance'
+            ],
+            # Long term borrowings
+            'long_term_borrowings': [
+                'long term borrowings', 'long-term borrowings', 'borrowings',
+                'debt', 'loans', 'financial corporation', 'bank loan'
+            ],
+            # Deferred tax
+            'deferred_tax': [
+                'deferred tax', 'tax liability', 'deferred tax liability'
+            ],
+            # Trade payables
+            'trade_payables': [
+                'trade payables', 'payables', 'creditors', 'sundry creditors',
+                'capital expenditure', 'other expenses'
+            ],
+            # Other current liabilities
+            'other_current_liabilities': [
+                'other current liabilities', 'current maturities', 'outstanding liabilities',
+                'statutory dues', 'accrued expenses'
+            ],
+            # Short term provisions
+            'short_term_provisions': [
+                'short term provisions', 'provisions', 'provision for taxation',
+                'tax provision'
+            ],
+            # Fixed assets - Tangible
+            'tangible_assets': [
+                'tangible assets', 'property plant', 'fixed assets', 'buildings',
+                'plant', 'equipment', 'net carrying value'
+            ],
+            # Fixed assets - Intangible
+            'intangible_assets': [
+                'intangible assets', 'software', 'goodwill', 'intangible'
+            ],
+            # Long term loans and advances
+            'long_term_loans_advances': [
+                'long term loans', 'security deposits', 'long term advances'
+            ],
+            # Inventories
+            'inventories': [
+                'inventories', 'stock', 'consumables', 'raw materials'
+            ],
+            # Trade receivables
+            'trade_receivables': [
+                'trade receivables', 'receivables', 'debtors', 'outstanding',
+                'other receivables'
+            ],
+            # Cash and bank
+            'cash_bank': [
+                'cash and bank', 'cash', 'bank balances', 'current accounts',
+                'cash on hand', 'fixed deposits'
+            ],
+            # Short term loans and advances
+            'short_term_loans_advances': [
+                'short term loans', 'prepaid expenses', 'other advances',
+                'advance tax', 'statutory authorities'
+            ],
+            # Other current assets
+            'other_current_assets': [
+                'other current assets', 'accrued income', 'interest accrued'
+            ]
+        }
+
+    def safe_float(self, value: Any) -> float:
+        """Convert various value formats to float."""
+        if not value or str(value).strip() in ['-', '--', 'None', '', 'null']:
+            return 0.0
+        
+        # Handle strings
+        if isinstance(value, str):
+            # Remove currency symbols and brackets
+            cleaned = re.sub(r'[₹,Rs\.\s\(\)]', '', value)
+            # Handle negative values in brackets
+            if '(' in str(value) and ')' in str(value):
+                cleaned = '-' + cleaned.replace('(', '').replace(')', '')
+            try:
+                return float(cleaned)
+            except Exception:
+                return 0.0
+        
+        # Handle numeric values
+        try:
+            return float(value)
+        except Exception:
+            return 0.0
+
+    def get_value_flexible(self, data: Any, date_key_2024: str = "2024-03-31 00:00:00", date_key_2023: str = "2023-03-31 00:00:00") -> tuple[float, float]:
+        """Flexibly extract values from either list or dictionary format."""
+        if isinstance(data, dict):
+            # Dictionary format - extract by date keys
+            val_2024 = self.safe_float(data.get(date_key_2024, 0))
+            val_2023 = self.safe_float(data.get(date_key_2023, 0))
+            return val_2024, val_2023
+        
+        elif isinstance(data, list):
+            # List format - assume first element is 2024, second is 2023
+            val_2024 = self.safe_float(data[0]) if len(data) > 0 else 0.0
+            val_2023 = self.safe_float(data[1]) if len(data) > 1 else 0.0
+            return val_2024, val_2023
+        
+        else:
+            # Single value or other format
+            val = self.safe_float(data)
+            return val, 0.0  # Assume it's 2024 value, 2023 is 0
+
+    def call_ai_for_analysis(self, data_summary: str) -> Dict[str, Any]:
+        """Use AI to analyze and extract balance sheet data"""
+        
+        prompt = f"""
+You are a financial analyst. Extract balance sheet data from the following JSON data and create a properly structured balance sheet.
+
+CRITICAL REQUIREMENTS:
+1. Extract ALL line items with their 2024 and 2023 values
+2. Calculate missing totals where needed
+3. Ensure the balance sheet balances (Assets = Equity + Liabilities)
+4. Return ONLY valid JSON in the exact format specified below
+
+Expected Balance Sheet Structure:
+- EQUITY AND LIABILITIES
+  - Shareholders' funds (Share capital, Reserves and surplus)
+  - Non-Current liabilities (Long term borrowings, Deferred tax liability)
+  - Current liabilities (Trade payables, Other current liabilities, Short term provisions)
+- ASSETS  
+  - Non-current assets (Fixed assets - Tangible/Intangible, Long term loans and advances)
+  - Current assets (Inventories, Trade receivables, Cash and bank balances, Short-term loans and advances, Other current assets)
+
+Data to analyze:
+{data_summary}
+
+Return ONLY this JSON format:
+{{
+  "balance_sheet_items": [
+    {{
+      "category": "Shareholders' funds",
+      "subcategory": "",
+      "name": "Share capital",
+      "note": "2",
+      "value_2024": 542.52,
+      "value_2023": 542.52
+    }},
+    {{
+      "category": "Shareholders' funds", 
+      "subcategory": "",
+      "name": "Reserves and surplus",
+      "note": "3",
+      "value_2024": 3152.39,
+      "value_2023": 2642.87
+    }},
+    {{
+      "category": "Non-Current liabilities",
+      "subcategory": "",
+      "name": "Long term borrowings", 
+      "note": "4",
+      "value_2024": 914.46,
+      "value_2023": 321.36
+    }}
+  ],
+  "totals": {{
+    "shareholders_funds_2024": 3694.91,
+    "shareholders_funds_2023": 3185.39,
+    "total_equity_liabilities_2024": 5246.10,
+    "total_equity_liabilities_2023": 4725.23,
+    "total_assets_2024": 5246.10,
+    "total_assets_2023": 4725.23
+  }}
+}}
+"""
+
+        headers = {
+            "Authorization": f"Bearer {self.api_key}",
+            "Content-Type": "application/json"
+        }
+        
+        payload = {
+            "model": "anthropic/claude-3.5-sonnet",
+            "messages": [{"role": "user", "content": prompt}],
+            "temperature": 0.1,
+            "max_tokens": 4000
+        }
+        
+        try:
+            response = requests.post(self.base_url, headers=headers, json=payload, timeout=60)
+            content = response.json()['choices'][0]['message']['content']
+            
+            # Clean the response
+            content = re.sub(r'```(?:json)?\s*', '', content).strip('`').strip()
+            
+            return json.loads(content)
+        except Exception as e:
+            logger.error(f"AI analysis failed: {e}")
+            return {"balance_sheet_items": [], "totals": {}}
+
+    def extract_from_json_structure(self, json_data: Dict[str, Any]) -> List[Dict[str, Any]]:
+        """Direct extraction from the structured JSON data with flexible list/dict support"""
+        items = []
+        
+        company_data = json_data.get("company_financial_data", {})
+        
+        # Extract Share Capital
+        share_capital = company_data.get("share_capital", {})
+        total_share_capital = share_capital.get("Total issued, subscribed and fully paid-up share capital", {})
+        if total_share_capital:
+            val_2024, val_2023 = self.get_value_flexible(total_share_capital)
+            if val_2024 or val_2023:
+                items.append({
+                    "category": "Shareholders' funds",
+                    "name": "Share capital",
+                    "note": "2",
+                    "value_2024": val_2024,
+                    "value_2023": val_2023
+                })
+
+        # Extract Reserves and Surplus
+        reserves = company_data.get("reserves_and_surplus", {})
+        closing_balance = reserves.get("Balance, at the end of the year", {})
+        if closing_balance:
+            val_2024, val_2023 = self.get_value_flexible(closing_balance)
+            if val_2024 or val_2023:
+                items.append({
+                    "category": "Shareholders' funds",
+                    "name": "Reserves and surplus", 
+                    "note": "3",
+                    "value_2024": val_2024,
+                    "value_2023": val_2023
+                })
+
+        # Extract Long-term Borrowings
+        borrowings = company_data.get("borrowings", {}).get("4. Long-Term Borrowings", {})
+        total_borrowings_2024 = 0
+        total_borrowings_2023 = 0
+        
+        for key, value in borrowings.items():
+            if key != "_metadata" and value is not None:
+                val_2024, val_2023 = self.get_value_flexible(value)
+                total_borrowings_2024 += val_2024
+                total_borrowings_2023 += val_2023
+        
+        if total_borrowings_2024 or total_borrowings_2023:
+            items.append({
+                "category": "Non-Current liabilities",
+                "name": "Long term borrowings",
+                "note": "4", 
+                "value_2024": total_borrowings_2024,
+                "value_2023": total_borrowings_2023
+            })
+
+        # Extract Deferred Tax
+        deferred_tax = company_data.get("other_data", {}).get("5. Deferred Tax Liability / (Asset)", {})
+        if deferred_tax:
+            dtl = deferred_tax.get("Deferred tax liability", {})
+            val_2024, val_2023 = self.get_value_flexible(dtl)
+            if val_2024 or val_2023:
+                items.append({
+                    "category": "Non-Current liabilities",
+                    "name": "Deferred Tax Liability (Net)",
+                    "note": "5",
+                    "value_2024": val_2024,
+                    "value_2023": val_2023
+                })
+
+        # Extract Current Liabilities
+        current_liabilities = company_data.get("current_liabilities", {})
+        
+        # Trade Payables
+        trade_payables = current_liabilities.get("6. Trade Payables", {})
+        tp_2024 = tp_2023 = 0
+        for key, value in trade_payables.items():
+            if key not in ["_metadata", "Particulars", "Disputed dues"] and value is not None:
+                val_2024, val_2023 = self.get_value_flexible(value)
+                tp_2024 += val_2024
+                tp_2023 += val_2023
+        
+        if tp_2024 or tp_2023:
+            items.append({
+                "category": "Current liabilities",
+                "name": "Trade payables",
+                "note": "6",
+                "value_2024": tp_2024,
+                "value_2023": tp_2023
+            })
+
+        # Other Current Liabilities
+        other_cl = current_liabilities.get("7. Other Current Liabilities", {})
+        ocl_2024 = ocl_2023 = 0
+        for key, value in other_cl.items():
+            if key != "_metadata" and value is not None:
+                val_2024, val_2023 = self.get_value_flexible(value)
+                ocl_2024 += val_2024
+                ocl_2023 += val_2023
+        
+        if ocl_2024 or ocl_2023:
+            items.append({
+                "category": "Current liabilities",
+                "name": "Other current liabilities",
+                "note": "7",
+                "value_2024": ocl_2024,
+                "value_2023": ocl_2023
+            })
+
+        # Short Term Provisions
+        provisions = current_liabilities.get("8. Short Term Provisions", {})
+        prov_2024 = prov_2023 = 0
+        for key, value in provisions.items():
+            if key != "_metadata" and value is not None:
+                val_2024, val_2023 = self.get_value_flexible(value)
+                prov_2024 += val_2024
+                prov_2023 += val_2023
+        
+        if prov_2024 or prov_2023:
+            items.append({
+                "category": "Current liabilities",
+                "name": "Short term provisions",
+                "note": "8", 
+                "value_2024": prov_2024,
+                "value_2023": prov_2023
+            })
+
+        # Extract Fixed Assets
+        fixed_assets = company_data.get("fixed_assets", {})
+        
+        # Tangible Assets
+        tangible = fixed_assets.get("tangible_assets", {}).get("", {})
+        if tangible:
+            net_carrying = tangible.get("net_carrying_value", {})
+            if net_carrying:
+                # Handle both dict and list formats for net carrying value
+                if isinstance(net_carrying, dict):
+                    val_2024 = self.safe_float(net_carrying.get("closing", 0))
+                    val_2023 = self.safe_float(net_carrying.get("opening", 0))
+                else:
+                    val_2024, val_2023 = self.get_value_flexible(net_carrying)
+                
+                if val_2024 or val_2023:
+                    items.append({
+                        "category": "Non-current assets",
+                        "subcategory": "Fixed assets",
+                        "name": "Tangible assets",
+                        "note": "9",
+                        "value_2024": val_2024,
+                        "value_2023": val_2023
+                    })
+
+        # Intangible Assets  
+        intangible = fixed_assets.get("intangible_assets", {}).get("", {})
+        if intangible:
+            net_carrying = intangible.get("net_carrying_value", {})
+            if net_carrying:
+                # Handle both dict and list formats for net carrying value
+                if isinstance(net_carrying, dict):
+                    val_2024 = self.safe_float(net_carrying.get("closing", 0))
+                    val_2023 = self.safe_float(net_carrying.get("opening", 0))
+                else:
+                    val_2024, val_2023 = self.get_value_flexible(net_carrying)
+                
+                if val_2024 or val_2023:
+                    items.append({
+                        "category": "Non-current assets",
+                        "subcategory": "Fixed assets", 
+                        "name": "Intangible assets",
+                        "note": "9",
+                        "value_2024": val_2024,
+                        "value_2023": val_2023
+                    })
+
+        # Long Term Loans and Advances
+        lt_loans = company_data.get("loans_and_advances", {}).get("10. Long Term Loans and advances", {})
+        lt_2024 = lt_2023 = 0
+        for key, value in lt_loans.items():
+            if key != "_metadata" and value is not None:
+                val_2024, val_2023 = self.get_value_flexible(value)
+                lt_2024 += val_2024
+                lt_2023 += val_2023
+        
+        if lt_2024 or lt_2023:
+            items.append({
+                "category": "Non-current assets",
+                "name": "Long Term Loans and Advances", 
+                "note": "10",
+                "value_2024": lt_2024,
+                "value_2023": lt_2023
+            })
+
+        # Extract Current Assets
+        current_assets = company_data.get("current_assets", {})
+        
+        # Inventories
+        inventories = current_assets.get("11. Inventories", {})
+        inv_2024 = inv_2023 = 0
+        for key, value in inventories.items():
+            if key != "_metadata" and value is not None:
+                val_2024, val_2023 = self.get_value_flexible(value)
+                inv_2024 += val_2024
+                inv_2023 += val_2023
+        
+        if inv_2024 or inv_2023:
+            items.append({
+                "category": "Current assets",
+                "name": "Inventories",
+                "note": "11",
+                "value_2024": inv_2024,
+                "value_2023": inv_2023
+            })
+
+        # Trade Receivables
+        trade_recv = current_assets.get("12. Trade receivables", {})
+        tr_2024 = tr_2023 = 0
+        for key, value in trade_recv.items():
+            if key not in ["_metadata", "Particulars", "trade_receivables_aging"] and value is not None:
+                val_2024, val_2023 = self.get_value_flexible(value)
+                tr_2024 += val_2024
+                tr_2023 += val_2023
+        
+        if tr_2024 or tr_2023:
+            items.append({
+                "category": "Current assets",
+                "name": "Trade receivables",
+                "note": "12",
+                "value_2024": tr_2024,
+                "value_2023": tr_2023
+            })
+
+        # Cash and Bank Balances
+        cash_bank = current_assets.get("13. Cash and bank balances", {})
+        cb_2024 = cb_2023 = 0
+        for key, value in cash_bank.items():
+            if key != "_metadata" and value is not None:
+                val_2024, val_2023 = self.get_value_flexible(value)
+                cb_2024 += val_2024
+                cb_2023 += val_2023
+        
+        if cb_2024 or cb_2023:
+            items.append({
+                "category": "Current assets",
+                "name": "Cash and bank balances",
+                "note": "13",
+                "value_2024": cb_2024,
+                "value_2023": cb_2023
+            })
+
+        # Short-term Loans and Advances
+        st_loans = company_data.get("loans_and_advances", {}).get("14. Short Term Loans and Advances", {})
+        st_2024 = st_2023 = 0
+        for key, value in st_loans.items():
+            if key != "_metadata" and value is not None:
+                val_2024, val_2023 = self.get_value_flexible(value)
+                st_2024 += val_2024
+                st_2023 += val_2023
+        
+        if st_2024 or st_2023:
+            items.append({
+                "category": "Current assets", 
+                "name": "Short-term loans and advances",
+                "note": "14",
+                "value_2024": st_2024,
+                "value_2023": st_2023
+            })
+
+        # Other Current Assets
+        other_ca = company_data.get("other_data", {}).get("15. Other Current Assets", {})
+        oca_2024 = oca_2023 = 0
+        for key, value in other_ca.items():
+            if key != "_metadata" and value is not None:
+                val_2024, val_2023 = self.get_value_flexible(value)
+                oca_2024 += val_2024
+                oca_2023 += val_2023
+        
+        if oca_2024 or oca_2023:
+            items.append({
+                "category": "Current assets",
+                "name": "Other current assets", 
+                "note": "15",
+                "value_2024": oca_2024,
+                "value_2023": oca_2023
+            })
+
+        return items
+
+    def calculate_totals(self, items: List[Dict[str, Any]]) -> BalanceSheetTotals:
+        """Calculate section totals and verify balance"""
+        totals = {}
+        
+        # Group by categories
+        categories = {}
+        for item in items:
+            cat = item["category"]
+            if cat not in categories:
+                categories[cat] = {"2024": 0, "2023": 0}
+            categories[cat]["2024"] += item["value_2024"]
+            categories[cat]["2023"] += item["value_2023"]
+        
+        # Calculate major totals
+        shareholders_funds_2024 = categories.get("Shareholders' funds", {}).get("2024", 0)
+        shareholders_funds_2023 = categories.get("Shareholders' funds", {}).get("2023", 0)
+        
+        non_current_liab_2024 = categories.get("Non-Current liabilities", {}).get("2024", 0)
+        non_current_liab_2023 = categories.get("Non-Current liabilities", {}).get("2023", 0)
+        
+        current_liab_2024 = categories.get("Current liabilities", {}).get("2024", 0)
+        current_liab_2023 = categories.get("Current liabilities", {}).get("2023", 0)
+        
+        non_current_assets_2024 = categories.get("Non-current assets", {}).get("2024", 0)
+        non_current_assets_2023 = categories.get("Non-current assets", {}).get("2023", 0)
+        
+        current_assets_2024 = categories.get("Current assets", {}).get("2024", 0)
+        current_assets_2023 = categories.get("Current assets", {}).get("2023", 0)
+        
+        total_equity_liab_2024 = shareholders_funds_2024 + non_current_liab_2024 + current_liab_2024
+        total_equity_liab_2023 = shareholders_funds_2023 + non_current_liab_2023 + current_liab_2023
+        
+        total_assets_2024 = non_current_assets_2024 + current_assets_2024
+        total_assets_2023 = non_current_assets_2023 + current_assets_2023
+        
+        return BalanceSheetTotals(
+            shareholders_funds_2024=shareholders_funds_2024,
+            shareholders_funds_2023=shareholders_funds_2023,
+            non_current_liabilities_2024=non_current_liab_2024,
+            non_current_liabilities_2023=non_current_liab_2023,
+            current_liabilities_2024=current_liab_2024,
+            current_liabilities_2023=current_liab_2023,
+            non_current_assets_2024=non_current_assets_2024,
+            non_current_assets_2023=non_current_assets_2023,
+            current_assets_2024=current_assets_2024,
+            current_assets_2023=current_assets_2023,
+            total_equity_liabilities_2024=total_equity_liab_2024,
+            total_equity_liabilities_2023=total_equity_liab_2023,
+            total_assets_2024=total_assets_2024,
+            total_assets_2023=total_assets_2023,
+            balance_difference_2024=abs(total_assets_2024 - total_equity_liab_2024),
+            balance_difference_2023=abs(total_assets_2023 - total_equity_liab_2023)
+        )
+
+    def generate_balance_sheet_excel(self, items: List[Dict[str, Any]], totals: BalanceSheetTotals, output_dir: str = "output") -> str:
+        """Generate formatted Excel balance sheet"""
+        os.makedirs(output_dir, exist_ok=True)
+        
+        wb = Workbook()
+        ws = wb.active
+        ws.title = "Balance Sheet"
+        
+        # Set column widths
+        ws.column_dimensions["A"].width = 40
+        ws.column_dimensions["B"].width = 8
+        ws.column_dimensions["C"].width = 15
+        ws.column_dimensions["D"].width = 15
+        
+        # Styles
+        bold_font = Font(bold=True)
+        thin_border = Border(
+            left=Side(style='thin'), right=Side(style='thin'),
+            top=Side(style='thin'), bottom=Side(style='thin')
+        )
+        
+        row = 1
+        
+        def add_row(desc, note, val_2024, val_2023, bold=False, indent=0, border=False):
+            nonlocal row
+            
+            # Description
+            cell_a = ws.cell(row=row, column=1, value="  " * indent + desc)
+            if bold:
+                cell_a.font = bold_font
+            if border:
+                cell_a.border = thin_border
+            
+            # Note
+            cell_b = ws.cell(row=row, column=2, value=note)
+            if bold:
+                cell_b.font = bold_font
+            if border:
+                cell_b.border = thin_border
+            
+            # Values
+            for col, val in [(3, val_2024), (4, val_2023)]:
+                cell = ws.cell(row=row, column=col)
+                if val != 0:
+                    cell.value = val
+                    cell.number_format = '#,##0.00'
+                if bold:
+                    cell.font = bold_font
+                if border:
+                    cell.border = thin_border
+                cell.alignment = Alignment(horizontal='right')
+            
+            row += 1
+        
+        # Header
+        add_row("Balance Sheet as at March 31, 2024", "", 0, 0, True)
+        add_row("", "", 0, 0)
+        add_row("(In Lakhs)", "", 0, 0)
+        add_row("", "Notes", "March 31, 2024", "March 31, 2023", True)
+        add_row("", "", 0, 0)
+        
+        # EQUITY AND LIABILITIES
+        add_row("EQUITY AND LIABILITIES", "", 0, 0, True)
+        
+        # Shareholders' funds
+        add_row("Shareholders' funds", "", 0, 0, True)
+        shareholders_items = [item for item in items if item["category"] == "Shareholders' funds"]
+        for item in shareholders_items:
+            add_row(item["name"], item["note"], item["value_2024"], item["value_2023"])
+        
+        add_row("", "", totals.shareholders_funds_2024, totals.shareholders_funds_2023, True)
+        add_row("", "", 0, 0)
+        
+        # Non-Current liabilities
+        add_row("Non-Current liabilities", "", 0, 0, True)
+        non_current_liab_items = [item for item in items if item["category"] == "Non-Current liabilities"]
+        for item in non_current_liab_items:
+            add_row(item["name"], item["note"], item["value_2024"], item["value_2023"])
+        
+        add_row("", "", totals.non_current_liabilities_2024, totals.non_current_liabilities_2023, True)
+        add_row("", "", 0, 0)
+        
+        # Current liabilities
+        add_row("Current liabilities", "", 0, 0, True)
+        current_liab_items = [item for item in items if item["category"] == "Current liabilities"]
+        for item in current_liab_items:
+            add_row(item["name"], item["note"], item["value_2024"], item["value_2023"])
+        
+        add_row("", "", totals.current_liabilities_2024, totals.current_liabilities_2023, True)
+        add_row("", "", 0, 0)
+        
+        # TOTAL EQUITY & LIABILITIES
+        add_row("TOTAL", "", totals.total_equity_liabilities_2024, totals.total_equity_liabilities_2023, True, 0, True)
+        add_row("", "", 0, 0)
+        
+        # ASSETS
+        add_row("ASSETS", "", 0, 0, True)
+        
+        # Non-current assets
+        add_row("Non-current assets", "", 0, 0, True)
+        
+        # Fixed assets
+        fixed_asset_items = [item for item in items if item.get("subcategory") == "Fixed assets"]
+        if fixed_asset_items:
+            add_row("Fixed assets", "", 0, 0, True, 1)
+            fixed_total_2024 = fixed_total_2023 = 0
+            for item in fixed_asset_items:
+                add_row(item["name"], item["note"], item["value_2024"], item["value_2023"], False, 2)
+                fixed_total_2024 += item["value_2024"]
+                fixed_total_2023 += item["value_2023"]
+            add_row("", "", fixed_total_2024, fixed_total_2023, True, 2)
+        
+        # Other non-current assets
+        other_non_current = [item for item in items if item["category"] == "Non-current assets" and item.get("subcategory") != "Fixed assets"]
+        for item in other_non_current:
+            add_row(item["name"], item["note"], item["value_2024"], item["value_2023"], False, 1)
+        
+        add_row("", "", totals.non_current_assets_2024, totals.non_current_assets_2023, True)
+        add_row("", "", 0, 0)
+        
+        # Current assets
+        add_row("Current assets", "", 0, 0, True)
+        current_asset_items = [item for item in items if item["category"] == "Current assets"]
+        for item in current_asset_items:
+            add_row(item["name"], item["note"], item["value_2024"], item["value_2023"], False, 1)
+        
+        add_row("", "", totals.current_assets_2024, totals.current_assets_2023, True)
+        add_row("", "", 0, 0)
+        
+        # TOTAL ASSETS
+        add_row("TOTAL", "", totals.total_assets_2024, totals.total_assets_2023, True, 0, True)
+        
+        # Add balance verification
+        add_row("", "", 0, 0)
+        balance_2024 = totals.balance_difference_2024
+        balance_2023 = totals.balance_difference_2023
+        
+        if balance_2024 < 0.01 and balance_2023 < 0.01:
+            add_row(" Balance Sheet is BALANCED", "", 0, 0, True)
+        else:
+            add_row(f" Balance Difference: {balance_2024:.2f} | {balance_2023:.2f}", "", 0, 0, True)
+        
+        # Save file
+        timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+        output_file = os.path.join(output_dir, f"balance_sheet_{timestamp}.xlsx")
+        wb.save(output_file)
+        logger.info(f"Output file: {output_file}")
+        return output_file
+
+    def process(self, input_file: str, output_dir: str = "output") -> Optional[str]:
+        """Main processing function"""
+        try:
+            logger.info(f"Processing: {input_file}")
+            
+            # Load JSON data
+            with open(input_file, 'r', encoding='utf-8') as f:
+                json_data = json.load(f)
+            
+            logger.info("Extracting data from JSON structure...")
+            
+            # Method 1: Direct extraction from structured JSON
+            items = self.extract_from_json_structure(json_data)
+            logger.info(f"Extracted {len(items)} items from JSON structure")
+            
+            # Method 2: AI-assisted extraction if needed
+            if len(items) < 10:  # If we don't have enough items
+                logger.info("Using AI for additional extraction...")
+                
+                # Create summary for AI
+                summary = json.dumps(json_data, indent=2)[:8000]  # Limit size
+                ai_result = self.call_ai_for_analysis(summary)
+                
+                ai_items = ai_result.get("balance_sheet_items", [])
+                logger.info(f"AI extracted {len(ai_items)} additional items")
+                
+                # Merge items (avoid duplicates)
+                existing_names = {item["name"].lower() for item in items}
+                for ai_item in ai_items:
+                    if ai_item["name"].lower() not in existing_names:
+                        items.append(ai_item)
+            
+            if not items:
+                logger.error("No balance sheet items extracted")
+                return None
+            
+            # Calculate totals
+            totals = self.calculate_totals(items)
+            
+            # Display summary
+            logger.info(f"\n BALANCE SHEET SUMMARY:")
+            logger.info(f"Total Items Extracted: {len(items)}")
+            logger.info(f"Assets 2024: Rs. {totals.total_assets_2024:,.2f} Lakhs")
+            logger.info(f"Equity & Liabilities 2024: Rs. {totals.total_equity_liabilities_2024:,.2f} Lakhs")
+            logger.info(f"Balance Difference 2024: Rs. {totals.balance_difference_2024:,.2f} Lakhs")
+            logger.info(f"Assets 2023: Rs. {totals.total_assets_2023:,.2f} Lakhs")
+            logger.info(f"Equity & Liabilities 2023: Rs. {totals.total_equity_liabilities_2023:,.2f} Lakhs")
+            logger.info(f"Balance Difference 2023: Rs. {totals.balance_difference_2023:,.2f} Lakhs")
+
+            # Check if balanced
+            is_balanced_2024 = totals.balance_difference_2024 < 0.01
+            is_balanced_2023 = totals.balance_difference_2023 < 0.01
+            
+            if is_balanced_2024 and is_balanced_2023:
+                logger.info("Balance Sheet is PERFECTLY BALANCED!")
+            else:
+                logger.warning("Balance Sheet has differences - may need adjustment")
+            
+            # Generate Excel
+            output_file = self.generate_balance_sheet_excel(items, totals, output_dir)
+            
+            logger.info(f"SUCCESS: Generated {output_file}")
+            return output_file
+            
+        except Exception as e:
+            logger.error(f"Error processing file: {e}", exc_info=True)
+            return None
+
+def main() -> None:
+    """Main function for running the balance sheet generator."""
+    logger.info("ENHANCED BALANCE SHEET GENERATOR v2.0")
+    api_key = settings.api_key
+    if not api_key:
+        logger.error("Missing OPENROUTER_API_KEY environment variable. Please set your OpenRouter API key in the .env file.")
+        return
+    input_file = settings.input_file
+    if not os.path.exists(input_file):
+        logger.error(f"Input file not found: {input_file}. Please ensure your JSON data file exists.")
+        return
+    generator = EnhancedBalanceSheetGenerator(api_key)
+    result = generator.process(input_file, settings.output_dir)
+    if result:
+        logger.info(f"COMPLETED SUCCESSFULLY! Output file: {result}")
+        logger.info("Open the Excel file to view your balance sheet")
+    else:
+        logger.error("PROCESSING FAILED. Please check the error messages above and try again.")

pnlbs/csv_json_bs.py

@@ -0,0 +1,360 @@
+import pandas as pd
+import json
+import os
+import re
+import logging
+from datetime import datetime
+from typing import Dict, List, Any, Optional, Union
+from pydantic import BaseModel, Field, ValidationError
+from pydantic_settings import BaseSettings
+
+# Configure logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+class Settings(BaseSettings):
+    """Settings for CSV to JSON conversion, loaded from environment variables or .env file."""
+    csv_folder_path: str = Field(default="csv_notes_bs", env="CSV_FOLDER_PATH")
+    output_json: str = Field(default="clean_financial_data_bs.json", env="OUTPUT_JSON")
+
+settings = Settings()
+
+class NoteSection(BaseModel):
+    title: str
+    data: Dict[str, Any]
+
+class FixedAssetData(BaseModel):
+    gross_carrying_value: Dict[str, Optional[Union[float, int]]]
+    accumulated_depreciation: Dict[str, Optional[Union[float, int]]]
+    net_carrying_value: Dict[str, Optional[Union[float, int]]]
+
+class FinancialData(BaseModel):
+    processing_summary: Dict[str, Any]
+    share_capital: Dict[str, Any] = Field(default_factory=dict)
+    reserves_and_surplus: Dict[str, Any] = Field(default_factory=dict)
+    borrowings: Dict[str, Any] = Field(default_factory=dict)
+    current_liabilities: Dict[str, Any] = Field(default_factory=dict)
+    fixed_assets: Dict[str, Any] = Field(default_factory=dict)
+    current_assets: Dict[str, Any] = Field(default_factory=dict)
+    loans_and_advances: Dict[str, Any] = Field(default_factory=dict)
+    other_data: Dict[str, Any] = Field(default_factory=dict)
+
+class FinancialCSVMapper:
+    def __init__(self, csv_folder_path: str = settings.csv_folder_path):
+        self.csv_folder_path = csv_folder_path
+
+    def clean_value(self, value: Any) -> Optional[Union[float, int, str]]:
+        """
+        Clean and convert values appropriately.
+        Returns None for empty or NaN values.
+        """
+        if pd.isna(value) or value == '':
+            return None
+        value_str = str(value).strip()
+        cleaned_num = re.sub(r'[,\s₹]', '', value_str)
+        try:
+            if '.' in cleaned_num:
+                return float(cleaned_num)
+            else:
+                return int(cleaned_num)
+        except (ValueError, TypeError):
+            return value_str
+
+    def identify_note_sections(self, df: pd.DataFrame) -> Dict[str, Dict]:
+        """
+        Identify and extract note sections (e.g., 2. Share capital, 3. Reserves).
+        Returns a dictionary of section title to parsed data.
+        """
+        sections = {}
+        current_section = None
+        current_data = []
+
+        for idx, row in df.iterrows():
+            first_col = str(row.iloc[0]) if not pd.isna(row.iloc[0]) else ""
+            # Check if this is a new section header (starts with number and dot)
+            if re.match(r'^\d+\.?\s+[A-Za-z]', first_col):
+                # Save previous section
+                if current_section and current_data:
+                    sections[current_section] = self.parse_section_data(current_data)
+                
+                # Start new section
+                current_section = first_col.strip()
+                current_data = []
+            else:
+                # Add row to current section
+                if current_section:
+                    row_data = [self.clean_value(cell) for cell in row]
+                    if any(cell is not None for cell in row_data):  # Skip empty rows
+                        current_data.append(row_data)
+        
+        # Handle last section
+        if current_section and current_data:
+            sections[current_section] = self.parse_section_data(current_data)
+        
+        return sections
+
+    def parse_section_data(self, rows: List[List[Any]]) -> Dict:
+        """
+        Parse section data into a meaningful structure.
+        Returns a dictionary mapping keys to values or date-mapped values.
+        """
+        if not rows:
+            return {}
+        
+        section_data = {}
+        
+        # Find date headers (usually in first or second row)
+        date_row = None
+        for i, row in enumerate(rows[:3]):
+            for cell in row:
+                if cell and isinstance(cell, str) and re.search(r'\d{4}-\d{2}-\d{2}', str(cell)):
+                    date_row = i
+                    break
+            if date_row is not None:
+                break
+        
+        # Extract dates if found
+        dates = []
+        if date_row is not None:
+            dates = [cell for cell in rows[date_row] if cell and re.search(r'\d{4}-\d{2}-\d{2}', str(cell))]
+        
+        # Process data rows
+        for row in rows:
+            if not row or not row[0]:
+                continue
+            
+            key = str(row[0]).strip()
+            
+            # Skip header/date rows
+            if date_row is not None and row == rows[date_row]:
+                continue
+            if any(date in str(cell) for cell in row for date in dates if date):
+                continue
+            
+            # Extract values (non-None values after the key)
+            values = [cell for cell in row[1:] if cell is not None]
+            
+            if values:
+                if len(values) == 1:
+                    section_data[key] = values[0]
+                else:
+                    # If we have dates, map values to dates
+                    if dates and len(values) <= len(dates):
+                        section_data[key] = {dates[i]: values[i] for i in range(len(values))}
+                    else:
+                        section_data[key] = values
+        
+        # Add dates to metadata if found
+        if dates:
+            section_data["_metadata"] = {"reporting_dates": dates}
+        
+        return section_data
+
+    def parse_fixed_assets(self, df: pd.DataFrame) -> Dict[str, Any]:
+        """
+        Parse fixed assets table (Note 9) with proper structure.
+        Returns a dictionary with tangible, intangible, and totals.
+        """
+        fixed_assets = {
+            "tangible_assets": {},
+            "intangible_assets": {},
+            "totals": {}
+        }
+        
+        current_category = None
+        
+        for idx, row in df.iterrows():
+            first_col = self.clean_value(row.iloc[0])
+            
+            # Skip header rows
+            if not first_col or "Particulars" in str(first_col) or "Gross Carrying" in str(first_col):
+                continue
+            
+            # Identify categories
+            if "Tangible Assets" in str(first_col):
+                current_category = "tangible"
+                continue
+            elif "Intangible Assets" in str(first_col):
+                current_category = "intangible"
+                continue
+            elif "Total" in str(first_col) or "Grand Total" in str(first_col):
+                current_category = "totals"
+            
+            # Extract asset data
+            if current_category and len(row) > 1:
+                asset_name = str(first_col).strip()
+                
+                # Remove numbering (1, 2, 3, etc.)
+                asset_name = re.sub(r'^\d+\s*', '', asset_name)
+                
+                asset_data = FixedAssetData(
+                    gross_carrying_value={
+                        "opening": self.clean_value(row.iloc[2]) if len(row) > 2 else None,
+                        "additions": self.clean_value(row.iloc[3]) if len(row) > 3 else None,
+                        "deletions": self.clean_value(row.iloc[4]) if len(row) > 4 else None,
+                        "closing": self.clean_value(row.iloc[5]) if len(row) > 5 else None
+                    },
+                    accumulated_depreciation={
+                        "opening": self.clean_value(row.iloc[6]) if len(row) > 6 else None,
+                        "for_the_year": self.clean_value(row.iloc[7]) if len(row) > 7 else None,
+                        "deletions": self.clean_value(row.iloc[8]) if len(row) > 8 else None,
+                        "closing": self.clean_value(row.iloc[9]) if len(row) > 9 else None
+                    },
+                    net_carrying_value={
+                        "closing": self.clean_value(row.iloc[10]) if len(row) > 10 else None,
+                        "opening": self.clean_value(row.iloc[11]) if len(row) > 11 else None
+                    }
+                )
+                
+                if current_category == "tangible":
+                    fixed_assets["tangible_assets"][asset_name] = asset_data.dict()
+                elif current_category == "intangible":
+                    fixed_assets["intangible_assets"][asset_name] = asset_data.dict()
+                elif current_category == "totals":
+                    fixed_assets["totals"][asset_name] = asset_data.dict()
+        
+        return fixed_assets
+    
+    def parse_trade_receivables_aging(self, df: pd.DataFrame) -> Dict[str, Any]:
+        """
+        Parse trade receivables aging analysis.
+        Returns a dictionary of year to aging buckets.
+        """
+        aging_data = {}
+        current_year = None
+        
+        for idx, row in df.iterrows():
+            first_col = str(row.iloc[0]) if not pd.isna(row.iloc[0]) else ""
+            
+            # Identify year sections
+            if "2024" in first_col:
+                current_year = "2024"
+                continue
+            elif "2023" in first_col:
+                current_year = "2023"
+                continue
+            
+            # Parse aging buckets
+            if current_year and "Considered good" in first_col:
+                aging_data[current_year] = {
+                    "0_6_months": self.clean_value(row.iloc[1]) if len(row) > 1 else None,
+                    "6_12_months": self.clean_value(row.iloc[2]) if len(row) > 2 else None,
+                    "1_2_years": self.clean_value(row.iloc[3]) if len(row) > 3 else None,
+                    "2_3_years": self.clean_value(row.iloc[4]) if len(row) > 4 else None,
+                    "more_than_3_years": self.clean_value(row.iloc[5]) if len(row) > 5 else None,
+                    "total": self.clean_value(row.iloc[6]) if len(row) > 6 else None
+                }
+        
+        return aging_data
+    
+    def process_single_csv(self, file_path: str) -> Dict[str, Any]:
+        """
+        Process a single CSV file with intelligent parsing.
+        Returns a dictionary of processed data.
+        """
+        try:
+            df = pd.read_csv(file_path, encoding='utf-8')
+            filename = os.path.basename(file_path)
+            result = {
+                "file_name": filename,
+                "processing_date": datetime.now().isoformat()
+            }
+            # Special handling for different note types
+            if "Note_9" in filename:
+                # Fixed assets
+                result["fixed_assets"] = self.parse_fixed_assets(df)
+            elif "Note_2_to_8" in filename or "Note_10_to_15" in filename:
+                # Share capital, reserves, borrowings, etc.
+                result["notes"] = self.identify_note_sections(df)
+                
+                # Special handling for trade receivables aging
+                if any("Age wise analysis" in str(cell) for row in df.values for cell in row):
+                    result["trade_receivables_aging"] = self.parse_trade_receivables_aging(df)
+            else:
+                # Generic note parsing
+                result["notes"] = self.identify_note_sections(df)
+            
+            return result
+        except Exception as e:
+            logger.error(f"Error processing {file_path}: {e}")
+            return {
+                "file_name": os.path.basename(file_path),
+                "error": str(e),
+                "processing_date": datetime.now().isoformat()
+            }
+    
+    def process_all_csvs(self) -> Dict[str, Any]:
+        """
+        Process all CSV files and create meaningful financial JSON.
+        Returns the structured financial data.
+        """
+        if not os.path.exists(self.csv_folder_path):
+            logger.error(f"Folder {self.csv_folder_path} not found")
+            return {"error": f"Folder {self.csv_folder_path} not found"}
+        
+        csv_files = [f for f in os.listdir(self.csv_folder_path) if f.endswith('.csv')]
+        
+        if not csv_files:
+            logger.error(f"No CSV files found in {self.csv_folder_path}")
+            return {"error": f"No CSV files found in {self.csv_folder_path}"}
+        
+        financial_data = FinancialData(
+            processing_summary={
+                "total_files": len(csv_files),
+                "processing_date": datetime.now().isoformat(),
+                "processed_files": []
+            }
+        )
+        
+        # Process each file
+        for csv_file in csv_files:
+            file_path = os.path.join(self.csv_folder_path, csv_file)
+            file_data = self.process_single_csv(file_path)
+            
+            if "error" not in file_data:
+                financial_data.processing_summary["processed_files"].append(csv_file)
+                
+                # Organize data by financial statement categories
+                if "notes" in file_data:
+                    for note_title, note_data in file_data["notes"].items():
+                        if "Share capital" in note_title:
+                            financial_data.share_capital = note_data
+                        elif "Reserves and surplus" in note_title:
+                            financial_data.reserves_and_surplus = note_data
+                        elif "borrowings" in note_title.lower():
+                            financial_data.borrowings[note_title] = note_data
+                        elif any(x in note_title.lower() for x in ["payables", "liabilities", "provisions"]):
+                            financial_data.current_liabilities[note_title] = note_data
+                        elif any(x in note_title.lower() for x in ["receivables", "cash", "inventories"]):
+                            financial_data.current_assets[note_title] = note_data
+                        elif any(x in note_title.lower() for x in ["loans", "advances"]):
+                            financial_data.loans_and_advances[note_title] = note_data
+                        else:
+                            financial_data.other_data[note_title] = note_data
+                
+                if "fixed_assets" in file_data:
+                    financial_data.fixed_assets = file_data["fixed_assets"]
+                
+                if "trade_receivables_aging" in file_data:
+                    financial_data.current_assets["trade_receivables_aging"] = file_data["trade_receivables_aging"]
+        
+        return {"company_financial_data": financial_data.dict()}
+    
+    def save_to_json(self, output_path: str = settings.output_json) -> str:
+        """
+        Process all CSVs and save meaningful financial JSON.
+        Returns the output file path.
+        """
+        financial_data = self.process_all_csvs()
+        
+        with open(output_path, 'w', encoding='utf-8') as f:
+            json.dump(financial_data, f, indent=2, ensure_ascii=False, default=str)
+        
+        logger.info(f"Clean financial JSON created: {output_path}")
+        return output_path
+
+# Usage
+if __name__ == "__main__":
+    mapper = FinancialCSVMapper(settings.csv_folder_path)
+    output_file = mapper.save_to_json(settings.output_json)
+    logger.info(f"Clean financial JSON created: {output_file}")

pnlbs/csv_json_pnl.py

@@ -0,0 +1,360 @@
+import pandas as pd
+import json
+import os
+import re
+import logging
+from datetime import datetime
+from typing import Dict, List, Any, Optional, Union
+from pydantic import BaseModel, Field, ValidationError
+from pydantic_settings import BaseSettings
+
+# Configure logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+class Settings(BaseSettings):
+    """Settings for CSV to JSON conversion, loaded from environment variables or .env file."""
+    csv_folder_path: str = Field(default="csv_notes_pnl", env="CSV_FOLDER_PATH")
+    output_json: str = Field(default="clean_financial_data_pnl.json", env="OUTPUT_JSON")
+
+settings = Settings()
+
+class NoteSection(BaseModel):
+    title: str
+    data: Dict[str, Any]
+
+class FixedAssetData(BaseModel):
+    gross_carrying_value: Dict[str, Optional[Union[float, int]]]
+    accumulated_depreciation: Dict[str, Optional[Union[float, int]]]
+    net_carrying_value: Dict[str, Optional[Union[float, int]]]
+
+class FinancialData(BaseModel):
+    processing_summary: Dict[str, Any]
+    share_capital: Dict[str, Any] = Field(default_factory=dict)
+    reserves_and_surplus: Dict[str, Any] = Field(default_factory=dict)
+    borrowings: Dict[str, Any] = Field(default_factory=dict)
+    current_liabilities: Dict[str, Any] = Field(default_factory=dict)
+    fixed_assets: Dict[str, Any] = Field(default_factory=dict)
+    current_assets: Dict[str, Any] = Field(default_factory=dict)
+    loans_and_advances: Dict[str, Any] = Field(default_factory=dict)
+    other_data: Dict[str, Any] = Field(default_factory=dict)
+
+class FinancialCSVMapper:
+    def __init__(self, csv_folder_path: str = settings.csv_folder_path):
+        self.csv_folder_path = csv_folder_path
+
+    def clean_value(self, value: Any) -> Optional[Union[float, int, str]]:
+        """
+        Clean and convert values appropriately.
+        Returns None for empty or NaN values.
+        """
+        if pd.isna(value) or value == '':
+            return None
+        value_str = str(value).strip()
+        cleaned_num = re.sub(r'[,\s₹]', '', value_str)
+        try:
+            if '.' in cleaned_num:
+                return float(cleaned_num)
+            else:
+                return int(cleaned_num)
+        except (ValueError, TypeError):
+            return value_str
+
+    def identify_note_sections(self, df: pd.DataFrame) -> Dict[str, Dict]:
+        """
+        Identify and extract note sections (e.g., 2. Share capital, 3. Reserves).
+        Returns a dictionary of section title to parsed data.
+        """
+        sections = {}
+        current_section = None
+        current_data = []
+
+        for idx, row in df.iterrows():
+            first_col = str(row.iloc[0]) if not pd.isna(row.iloc[0]) else ""
+            # Check if this is a new section header (starts with number and dot)
+            if re.match(r'^\d+\.?\s+[A-Za-z]', first_col):
+                # Save previous section
+                if current_section and current_data:
+                    sections[current_section] = self.parse_section_data(current_data)
+                
+                # Start new section
+                current_section = first_col.strip()
+                current_data = []
+            else:
+                # Add row to current section
+                if current_section:
+                    row_data = [self.clean_value(cell) for cell in row]
+                    if any(cell is not None for cell in row_data):  # Skip empty rows
+                        current_data.append(row_data)
+        
+        # Handle last section
+        if current_section and current_data:
+            sections[current_section] = self.parse_section_data(current_data)
+        
+        return sections
+
+    def parse_section_data(self, rows: List[List[Any]]) -> Dict:
+        """
+        Parse section data into a meaningful structure.
+        Returns a dictionary mapping keys to values or date-mapped values.
+        """
+        if not rows:
+            return {}
+        
+        section_data = {}
+        
+        # Find date headers (usually in first or second row)
+        date_row = None
+        for i, row in enumerate(rows[:3]):
+            for cell in row:
+                if cell and isinstance(cell, str) and re.search(r'\d{4}-\d{2}-\d{2}', str(cell)):
+                    date_row = i
+                    break
+            if date_row is not None:
+                break
+        
+        # Extract dates if found
+        dates = []
+        if date_row is not None:
+            dates = [cell for cell in rows[date_row] if cell and re.search(r'\d{4}-\d{2}-\d{2}', str(cell))]
+        
+        # Process data rows
+        for row in rows:
+            if not row or not row[0]:
+                continue
+            
+            key = str(row[0]).strip()
+            
+            # Skip header/date rows
+            if date_row is not None and row == rows[date_row]:
+                continue
+            if any(date in str(cell) for cell in row for date in dates if date):
+                continue
+            
+            # Extract values (non-None values after the key)
+            values = [cell for cell in row[1:] if cell is not None]
+            
+            if values:
+                if len(values) == 1:
+                    section_data[key] = values[0]
+                else:
+                    # If we have dates, map values to dates
+                    if dates and len(values) <= len(dates):
+                        section_data[key] = {dates[i]: values[i] for i in range(len(values))}
+                    else:
+                        section_data[key] = values
+        
+        # Add dates to metadata if found
+        if dates:
+            section_data["_metadata"] = {"reporting_dates": dates}
+        
+        return section_data
+
+    def parse_fixed_assets(self, df: pd.DataFrame) -> Dict[str, Any]:
+        """
+        Parse fixed assets table (Note 9) with proper structure.
+        Returns a dictionary with tangible, intangible, and totals.
+        """
+        fixed_assets = {
+            "tangible_assets": {},
+            "intangible_assets": {},
+            "totals": {}
+        }
+        
+        current_category = None
+        
+        for idx, row in df.iterrows():
+            first_col = self.clean_value(row.iloc[0])
+            
+            # Skip header rows
+            if not first_col or "Particulars" in str(first_col) or "Gross Carrying" in str(first_col):
+                continue
+            
+            # Identify categories
+            if "Tangible Assets" in str(first_col):
+                current_category = "tangible"
+                continue
+            elif "Intangible Assets" in str(first_col):
+                current_category = "intangible"
+                continue
+            elif "Total" in str(first_col) or "Grand Total" in str(first_col):
+                current_category = "totals"
+            
+            # Extract asset data
+            if current_category and len(row) > 1:
+                asset_name = str(first_col).strip()
+                
+                # Remove numbering (1, 2, 3, etc.)
+                asset_name = re.sub(r'^\d+\s*', '', asset_name)
+                
+                asset_data = FixedAssetData(
+                    gross_carrying_value={
+                        "opening": self.clean_value(row.iloc[2]) if len(row) > 2 else None,
+                        "additions": self.clean_value(row.iloc[3]) if len(row) > 3 else None,
+                        "deletions": self.clean_value(row.iloc[4]) if len(row) > 4 else None,
+                        "closing": self.clean_value(row.iloc[5]) if len(row) > 5 else None
+                    },
+                    accumulated_depreciation={
+                        "opening": self.clean_value(row.iloc[6]) if len(row) > 6 else None,
+                        "for_the_year": self.clean_value(row.iloc[7]) if len(row) > 7 else None,
+                        "deletions": self.clean_value(row.iloc[8]) if len(row) > 8 else None,
+                        "closing": self.clean_value(row.iloc[9]) if len(row) > 9 else None
+                    },
+                    net_carrying_value={
+                        "closing": self.clean_value(row.iloc[10]) if len(row) > 10 else None,
+                        "opening": self.clean_value(row.iloc[11]) if len(row) > 11 else None
+                    }
+                )
+                
+                if current_category == "tangible":
+                    fixed_assets["tangible_assets"][asset_name] = asset_data.dict()
+                elif current_category == "intangible":
+                    fixed_assets["intangible_assets"][asset_name] = asset_data.dict()
+                elif current_category == "totals":
+                    fixed_assets["totals"][asset_name] = asset_data.dict()
+        
+        return fixed_assets
+
+    def parse_trade_receivables_aging(self, df: pd.DataFrame) -> Dict[str, Any]:
+        """
+        Parse trade receivables aging analysis.
+        Returns a dictionary of year to aging buckets.
+        """
+        aging_data = {}
+        current_year = None
+        
+        for idx, row in df.iterrows():
+            first_col = str(row.iloc[0]) if not pd.isna(row.iloc[0]) else ""
+            
+            # Identify year sections
+            if "2024" in first_col:
+                current_year = "2024"
+                continue
+            elif "2023" in first_col:
+                current_year = "2023"
+                continue
+            
+            # Parse aging buckets
+            if current_year and "Considered good" in first_col:
+                aging_data[current_year] = {
+                    "0_6_months": self.clean_value(row.iloc[1]) if len(row) > 1 else None,
+                    "6_12_months": self.clean_value(row.iloc[2]) if len(row) > 2 else None,
+                    "1_2_years": self.clean_value(row.iloc[3]) if len(row) > 3 else None,
+                    "2_3_years": self.clean_value(row.iloc[4]) if len(row) > 4 else None,
+                    "more_than_3_years": self.clean_value(row.iloc[5]) if len(row) > 5 else None,
+                    "total": self.clean_value(row.iloc[6]) if len(row) > 6 else None
+                }
+        
+        return aging_data
+
+    def process_single_csv(self, file_path: str) -> Dict[str, Any]:
+        """
+        Process a single CSV file with intelligent parsing.
+        Returns a dictionary of processed data.
+        """
+        try:
+            df = pd.read_csv(file_path, encoding='utf-8')
+            filename = os.path.basename(file_path)
+            result = {
+                "file_name": filename,
+                "processing_date": datetime.now().isoformat()
+            }
+            # Special handling for different note types
+            if "Note_9" in filename:
+                # Fixed assets
+                result["fixed_assets"] = self.parse_fixed_assets(df)
+            elif "Note_2_to_8" in filename or "Note_10_to_15" in filename:
+                # Share capital, reserves, borrowings, etc.
+                result["notes"] = self.identify_note_sections(df)
+                
+                # Special handling for trade receivables aging
+                if any("Age wise analysis" in str(cell) for row in df.values for cell in row):
+                    result["trade_receivables_aging"] = self.parse_trade_receivables_aging(df)
+            else:
+                # Generic note parsing
+                result["notes"] = self.identify_note_sections(df)
+            
+            return result
+        except Exception as e:
+            logger.error(f"Error processing {file_path}: {e}")
+            return {
+                "file_name": os.path.basename(file_path),
+                "error": str(e),
+                "processing_date": datetime.now().isoformat()
+            }
+
+    def process_all_csvs(self) -> Dict[str, Any]:
+        """
+        Process all CSV files and create meaningful financial JSON.
+        Returns the structured financial data.
+        """
+        if not os.path.exists(self.csv_folder_path):
+            logger.error(f"Folder {self.csv_folder_path} not found")
+            return {"error": f"Folder {self.csv_folder_path} not found"}
+        
+        csv_files = [f for f in os.listdir(self.csv_folder_path) if f.endswith('.csv')]
+        
+        if not csv_files:
+            logger.error(f"No CSV files found in {self.csv_folder_path}")
+            return {"error": f"No CSV files found in {self.csv_folder_path}"}
+        
+        financial_data = FinancialData(
+            processing_summary={
+                "total_files": len(csv_files),
+                "processing_date": datetime.now().isoformat(),
+                "processed_files": []
+            }
+        )
+        
+        # Process each file
+        for csv_file in csv_files:
+            file_path = os.path.join(self.csv_folder_path, csv_file)
+            file_data = self.process_single_csv(file_path)
+            
+            if "error" not in file_data:
+                financial_data.processing_summary["processed_files"].append(csv_file)
+                
+                # Organize data by financial statement categories
+                if "notes" in file_data:
+                    for note_title, note_data in file_data["notes"].items():
+                        if "Share capital" in note_title:
+                            financial_data.share_capital = note_data
+                        elif "Reserves and surplus" in note_title:
+                            financial_data.reserves_and_surplus = note_data
+                        elif "borrowings" in note_title.lower():
+                            financial_data.borrowings[note_title] = note_data
+                        elif any(x in note_title.lower() for x in ["payables", "liabilities", "provisions"]):
+                            financial_data.current_liabilities[note_title] = note_data
+                        elif any(x in note_title.lower() for x in ["receivables", "cash", "inventories"]):
+                            financial_data.current_assets[note_title] = note_data
+                        elif any(x in note_title.lower() for x in ["loans", "advances"]):
+                            financial_data.loans_and_advances[note_title] = note_data
+                        else:
+                            financial_data.other_data[note_title] = note_data
+                
+                if "fixed_assets" in file_data:
+                    financial_data.fixed_assets = file_data["fixed_assets"]
+                
+                if "trade_receivables_aging" in file_data:
+                    financial_data.current_assets["trade_receivables_aging"] = file_data["trade_receivables_aging"]
+        
+        return {"company_financial_data": financial_data.dict()}
+
+    def save_to_json(self, output_path: str = settings.output_json) -> str:
+        """
+        Process all CSVs and save meaningful financial JSON.
+        Returns the output file path.
+        """
+        financial_data = self.process_all_csvs()
+        
+        with open(output_path, 'w', encoding='utf-8') as f:
+            json.dump(financial_data, f, indent=2, ensure_ascii=False, default=str)
+        
+        logger.info(f"Clean financial JSON created: {output_path}")
+        return output_path
+
+# Usage
+if __name__ == "__main__":
+    mapper = FinancialCSVMapper(settings.csv_folder_path)
+    output_file = mapper.save_to_json(settings.output_json)
+    logger.info(f"Clean financial JSON created: {output_file}")

pnlbs/pnl_note.py

@@ -0,0 +1,353 @@
+import os
+import json
+import logging
+from openpyxl import Workbook
+from openpyxl.styles import Font, Border, Side, Alignment
+from typing import Dict, List, Tuple, Any, Optional
+from pydantic import BaseModel, Field, ValidationError
+from pydantic_settings import BaseSettings
+
+# Configure logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+class Settings(BaseSettings):
+    """Settings for P&L generation, loaded from environment variables or .env file."""
+    json_files: List[str] = Field(default_factory=lambda: [
+        "clean_financial_data_pnl.json",
+        "pnl_notes.json"
+    ], env="PNL_JSON_FILES")
+    output_file: str = Field(default="pnl_statement.xlsx", env="PNL_OUTPUT_FILE")
+
+settings = Settings()
+
+class FinancialItem(BaseModel):
+    name: str
+    values: List[float] = Field(default_factory=list)
+
+class FinancialDataModel(BaseModel):
+    other_data: Dict[str, Any] = Field(default_factory=dict)
+
+class PnLGenerator:
+    def __init__(self, json_file_path: str = settings.json_files[0]):
+        """Initialize the P&L generator with JSON file path."""
+        self.json_file_path = json_file_path
+        self.financial_data: Dict[str, Any] = {}
+
+    def load_financial_data(self) -> bool:
+        """Load financial data from JSON file."""
+        try:
+            logger.info(f"Loading financial data from: {self.json_file_path}")
+            with open(self.json_file_path, 'r', encoding='utf-8') as f:
+                data = json.load(f)
+            # Handle different JSON structures flexibly
+            if "company_financial_data" in data:
+                self.financial_data = data["company_financial_data"].get("other_data", {})
+            elif "other_data" in data:
+                self.financial_data = data["other_data"]
+            else:
+                self.financial_data = data
+            logger.info(f"Loaded data for {len(self.financial_data)} financial items")
+            return True
+        except FileNotFoundError:
+            logger.error(f"File not found: {self.json_file_path}")
+            return False
+        except json.JSONDecodeError as e:
+            logger.error(f"Invalid JSON format: {str(e)}")
+            return False
+        except Exception as e:
+            logger.error(f"Error loading data: {str(e)}")
+            return False
+
+    def extract_values(self, item_key: str) -> Tuple[float, float]:
+        """Extract 2024 and 2023 values from financial data."""
+        if item_key not in self.financial_data:
+            logger.warning(f"{item_key} not found in data")
+            return 0.0, 0.0
+        item_data = self.financial_data[item_key]
+        total_2024 = 0.0
+        total_2023 = 0.0
+        if isinstance(item_data, dict):
+            for category, values in item_data.items():
+                if isinstance(values, list) and len(values) >= 2:
+                    total_2024 += float(values[0] or 0)
+                    total_2023 += float(values[1] or 0)
+                elif isinstance(values, (int, float)):
+                    total_2024 += float(values)
+        elif isinstance(item_data, list) and len(item_data) >= 2:
+            total_2024 = float(item_data[0] or 0)
+            total_2023 = float(item_data[1] or 0)
+        return total_2024, total_2023
+
+    def get_revenue_data(self) -> Tuple[float, float]:
+        """Extract revenue from operations data."""
+        return self.extract_values("16. Revenue from Operations")
+
+    def get_other_income_data(self) -> Tuple[float, float]:
+        """Extract other income data."""
+        return self.extract_values("17. Other income")
+
+    def get_cost_materials_data(self) -> Tuple[float, float]:
+        """Extract cost of materials consumed data."""
+        item_key = "18. Cost of materials consumed"
+        if item_key not in self.financial_data:
+            logger.warning(f"{item_key} not found in data")
+            return 0.0, 0.0
+        item_data = self.financial_data[item_key]
+        if "Cost of materials consumed" in item_data:
+            values = item_data["Cost of materials consumed"]
+            if isinstance(values, list) and len(values) >= 2:
+                return float(values[0] or 0), float(values[1] or 0)
+        # Fallback: calculate from opening stock + purchases - closing stock
+        opening_2024 = opening_2023 = 0.0
+        purchases_2024 = purchases_2023 = 0.0
+        closing_2024 = closing_2023 = 0.0
+        if "Opening stock" in item_data:
+            values = item_data["Opening stock"]
+            if isinstance(values, list) and len(values) >= 2:
+                opening_2024, opening_2023 = float(values[0] or 0), float(values[1] or 0)
+        if "Add: Purchases" in item_data:
+            values = item_data["Add: Purchases"]
+            if isinstance(values, list) and len(values) >= 2:
+                purchases_2024, purchases_2023 = float(values[0] or 0), float(values[1] or 0)
+        if "Less: Closing stock" in item_data:
+            values = item_data["Less: Closing stock"]
+            if isinstance(values, list) and len(values) >= 2:
+                closing_2024, closing_2023 = float(values[0] or 0), float(values[1] or 0)
+        cost_2024 = opening_2024 + purchases_2024 - closing_2024
+        cost_2023 = opening_2023 + purchases_2023 - closing_2023
+        return cost_2024, cost_2023
+
+    def get_employee_expense_data(self) -> Tuple[float, float]:
+        """Extract employee benefit expense data."""
+        return self.extract_values("19. Employee benefit expense")
+
+    def get_other_expenses_data(self) -> Tuple[float, float]:
+        """Extract other expenses data."""
+        return self.extract_values("20. Other expenses")
+
+    def get_depreciation_data(self) -> Tuple[float, float]:
+        """Extract depreciation and amortisation data."""
+        return self.extract_values("21. Depreciation and amortisation expense")
+
+    def get_loss_on_sale_data(self) -> Tuple[float, float]:
+        """Extract loss on sale of assets data."""
+        return self.extract_values("22. Loss on sale of assets")
+
+    def get_finance_costs_data(self) -> Tuple[float, float]:
+        """Extract finance costs data."""
+        return self.extract_values("23. Finance costs")
+
+    def format_currency(self, value: float) -> str:
+        """Format currency with commas."""
+        if value == 0:
+            return ""
+        return f"{value:,.2f}"
+
+    def generate_pnl_statement(self, output_file: str = settings.output_file) -> bool:
+        """Generate comprehensive P&L statement Excel file."""
+        if not self.financial_data:
+            logger.error("No financial data loaded. Please load data first.")
+            return False
+        wb = Workbook()
+        ws = wb.active
+        ws.title = "Profit and Loss Statement"
+        title_font = Font(bold=True, size=12)
+        header_font = Font(bold=True, size=10)
+        normal_font = Font(size=10)
+        bold_font = Font(bold=True, size=10)
+        thin_border = Border(
+            left=Side(style="thin"), right=Side(style="thin"),
+            top=Side(style="thin"), bottom=Side(style="thin")
+        )
+        top_bottom_border = Border(
+            top=Side(style="thin"), bottom=Side(style="thin")
+        )
+        center_align = Alignment(horizontal="center", vertical="center")
+        left_align = Alignment(horizontal="left", vertical="center")
+        right_align = Alignment(horizontal="right", vertical="center")
+        ws.column_dimensions["A"].width = 45
+        ws.column_dimensions["B"].width = 8
+        ws.column_dimensions["C"].width = 15
+        ws.column_dimensions["D"].width = 15
+        row = 1
+        ws.merge_cells("A1:D1")
+        ws["A1"] = "Statement of Profit and Loss for the year ended March 31, 2024"
+        ws["A1"].font = title_font
+        ws["A1"].alignment = center_align
+        ws["A1"].border = top_bottom_border
+        row += 2
+        ws["C3"] = "In Lakhs"
+        ws["C3"].font = normal_font
+        ws["C3"].alignment = right_align
+        row += 1
+        headers = ["", "Notes", "Year ended March 31, 2024", "Year ended March 31, 2023"]
+        for col, header in enumerate(headers, 1):
+            cell = ws.cell(row=row, column=col)
+            cell.value = header
+            cell.font = header_font
+            cell.border = top_bottom_border
+            cell.alignment = center_align if col > 2 else left_align
+        row += 1
+
+        def add_data_row(description: str, note_ref: str, val_2024: float, val_2023: float,
+                         is_bold: bool = False, is_section_header: bool = False) -> None:
+            """Add a data row with proper formatting."""
+            nonlocal row
+            cell_a = ws.cell(row=row, column=1)
+            cell_a.value = description
+            cell_a.font = bold_font if (is_bold or is_section_header) else normal_font
+            cell_a.alignment = left_align
+            if not is_section_header:
+                cell_a.border = thin_border
+            cell_b = ws.cell(row=row, column=2)
+            cell_b.value = note_ref if note_ref else ""
+            cell_b.font = normal_font
+            cell_b.alignment = center_align
+            if not is_section_header:
+                cell_b.border = thin_border
+            cell_c = ws.cell(row=row, column=3)
+            cell_c.value = self.format_currency(val_2024)
+            cell_c.font = bold_font if is_bold else normal_font
+            cell_c.alignment = right_align
+            if not is_section_header:
+                cell_c.border = thin_border
+            cell_d = ws.cell(row=row, column=4)
+            cell_d.value = self.format_currency(val_2023)
+            cell_d.font = bold_font if is_bold else normal_font
+            cell_d.alignment = right_align
+            if not is_section_header:
+                cell_d.border = thin_border
+            row += 1
+
+        logger.info("Extracting financial data...")
+        revenue_2024, revenue_2023 = self.get_revenue_data()
+        other_income_2024, other_income_2023 = self.get_other_income_data()
+        materials_2024, materials_2023 = self.get_cost_materials_data()
+        employee_2024, employee_2023 = self.get_employee_expense_data()
+        other_exp_2024, other_exp_2023 = self.get_other_expenses_data()
+        depreciation_2024, depreciation_2023 = self.get_depreciation_data()
+        loss_sale_2024, loss_sale_2023 = self.get_loss_on_sale_data()
+        finance_2024, finance_2023 = self.get_finance_costs_data()
+
+        # INCOME SECTION
+        add_data_row("Income", "", 0, 0, is_section_header=True)
+        add_data_row("Revenue from operations (net)", "16", revenue_2024, revenue_2023)
+        add_data_row("Other income", "17", other_income_2024, other_income_2023)
+        total_revenue_2024 = revenue_2024 + other_income_2024
+        total_revenue_2023 = revenue_2023 + other_income_2023
+        add_data_row("Total revenue (I)", "", total_revenue_2024, total_revenue_2023, is_bold=True)
+
+        # EXPENSES SECTION
+        add_data_row("Expenses", "", 0, 0, is_section_header=True)
+        add_data_row("Cost of materials consumed", "18", materials_2024, materials_2023)
+        add_data_row("Employee benefit expense", "19", employee_2024, employee_2023)
+        add_data_row("Other expenses", "20", other_exp_2024, other_exp_2023)
+        add_data_row("Depreciation and amortisation expense", "21", depreciation_2024, depreciation_2023)
+        add_data_row("Loss on sale of assets & investments", "22", loss_sale_2024, loss_sale_2023)
+        add_data_row("Finance costs", "23", finance_2024, finance_2023)
+        total_expenses_2024 = materials_2024 + employee_2024 + other_exp_2024 + depreciation_2024 + loss_sale_2024 + finance_2024
+        total_expenses_2023 = materials_2023 + employee_2023 + other_exp_2023 + depreciation_2023 + loss_sale_2023 + finance_2023
+        add_data_row("Total Expenses (II)", "", total_expenses_2024, total_expenses_2023, is_bold=True)
+
+        # Profit before tax
+        profit_before_tax_2024 = total_revenue_2024 - total_expenses_2024
+        profit_before_tax_2023 = total_revenue_2023 - total_expenses_2023
+        add_data_row("Profit before Tax (I) - (II)", "", profit_before_tax_2024, profit_before_tax_2023, is_bold=True)
+
+        # Tax Expense section (placeholders)
+        add_data_row("IV. TAX EXPENSE", "", 0, 0, is_section_header=True)
+        add_data_row("Current Tax", "", 0.0, 0.0)
+        add_data_row("Deferred Tax Liability/(Asset)", "", 0.0, 0.0)
+        add_data_row("Income Tax relating to Prior Year", "", 0.0, 0.0)
+        add_data_row("MAT Credit (Entitlement)/Utilisation", "", 0.0, 0.0)
+        add_data_row("Total Tax Expense (IV)", "", 0.0, 0.0, is_bold=True)
+
+        # Profit after Tax (assuming no tax for now)
+        profit_after_tax_2024 = profit_before_tax_2024
+        profit_after_tax_2023 = profit_before_tax_2023
+        add_data_row("Profit After Tax (III - IV)", "", profit_after_tax_2024, profit_after_tax_2023, is_bold=True)
+
+        # Earnings per share section (placeholders)
+        add_data_row("Earnings per share", "", 0, 0, is_section_header=True)
+        add_data_row("Basic and diluted", "30", 0.0, 0.0)
+        add_data_row("Nominal value", "", 10.0, 10.0)
+        add_data_row("Weighted average number of equity shares", "30", 0.0, 0.0)
+
+        # Footer
+        row += 2
+        ws.merge_cells(f"A{row}:D{row}")
+        ws[f"A{row}"] = "The accompanying notes are an integral part of the financial statements"
+        ws[f"A{row}"].font = normal_font
+        ws[f"A{row}"].alignment = left_align
+
+        # Save the file
+        try:
+            wb.save(output_file)
+            logger.info(f"P&L Statement generated successfully: {output_file}")
+            self.print_financial_summary(
+                total_revenue_2024, total_revenue_2023,
+                total_expenses_2024, total_expenses_2023,
+                profit_before_tax_2024, profit_before_tax_2023,
+                profit_after_tax_2024, profit_after_tax_2023
+            )
+            return True
+        except PermissionError:
+            logger.error(f"Permission Error: Cannot save to {output_file}")
+            fallback_file = os.path.join(os.path.expanduser("~"), "Desktop", "pnl_statement_fallback.xlsx")
+            try:
+                wb.save(fallback_file)
+                logger.info(f"P&L Statement saved to: {fallback_file}")
+                return True
+            except Exception as e:
+                logger.error(f"Failed to save: {str(e)}")
+                return False
+        except Exception as e:
+            logger.error(f"Error saving file: {str(e)}")
+            return False
+
+    def print_financial_summary(self, total_revenue_2024: float, total_revenue_2023: float,
+                                total_expenses_2024: float, total_expenses_2023: float,
+                                profit_before_tax_2024: float, profit_before_tax_2023: float,
+                                profit_after_tax_2024: float, profit_after_tax_2023: float) -> None:
+        """Log financial summary."""
+        logger.info("=" * 60)
+        logger.info("FINANCIAL SUMMARY")
+        logger.info("=" * 60)
+        logger.info(f"Total Revenue 2024:     Rs.{total_revenue_2024:>12,.2f} Lakhs")
+        logger.info(f"Total Revenue 2023:     Rs.{total_revenue_2023:>12,.2f} Lakhs")
+        logger.info(f"Total Expenses 2024:    Rs.{total_expenses_2024:>12,.2f} Lakhs")
+        logger.info(f"Total Expenses 2023:    Rs.{total_expenses_2023:>12,.2f} Lakhs")
+        logger.info(f"Profit Before Tax 2024: Rs.{profit_before_tax_2024:>12,.2f} Lakhs")
+        logger.info(f"Profit Before Tax 2023: Rs.{profit_before_tax_2023:>12,.2f} Lakhs")
+        logger.info(f"Profit After Tax 2024:  Rs.{profit_after_tax_2024:>12,.2f} Lakhs")
+        logger.info(f"Profit After Tax 2023:  Rs.{profit_after_tax_2023:>12,.2f} Lakhs")
+        if total_revenue_2023 > 0:
+            growth_rate = ((total_revenue_2024 - total_revenue_2023) / total_revenue_2023) * 100
+            logger.info(f"Revenue Growth Rate:    {growth_rate:>12.2f}%")
+
+def main() -> None:
+    """Main function to run the P&L generator."""
+    logger.info("P&L STATEMENT GENERATOR FROM JSON")
+    logger.info("=" * 50)
+    json_file: Optional[str] = None
+    for file in settings.json_files:
+        if os.path.exists(file):
+            json_file = file
+            break
+    if not json_file:
+        json_file = input("Enter the path to your JSON file: ").strip()
+    generator = PnLGenerator(json_file)
+    if generator.load_financial_data():
+        output_path = settings.output_file
+        logger.info(f"Output file: {output_path}")
+        if generator.generate_pnl_statement(output_path):
+            logger.info("P&L STATEMENT GENERATION COMPLETED SUCCESSFULLY!")
+            logger.info(f"Output file: {output_path}")
+        else:
+            logger.error("Failed to generate P&L statement")
+    else:
+        logger.error("Failed to load financial data")
+
+if __name__ == "__main__":
+    main()

pnlbs/sircodebs.py

@@ -0,0 +1,75 @@
+import os
+import pandas as pd
+import sys
+import logging
+from typing import Optional
+from pydantic import BaseModel, Field
+from pydantic_settings import BaseSettings
+
+# Ensure stdout encoding for Unicode
+sys.stdout.reconfigure(encoding='utf-8')
+
+# Configure logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+class Settings(BaseSettings):
+    """Settings for Balance Sheet CSV extraction, loaded from environment variables or .env file."""
+    excel_file_path: str = Field(default="In Lakhs  BS_FY 23-24 V5 - Final.xlsx", env="BS_EXCEL_FILE_PATH")
+    output_folder: str = Field(default="csv_notes_bs", env="BS_OUTPUT_FOLDER")
+    note_2_8_sheet: str = Field(default="Note 2 - 8", env="BS_NOTE_2_8_SHEET")
+    note_9_sheet: str = Field(default="Note 9", env="BS_NOTE_9_SHEET")
+    note_10_15_sheet: str = Field(default="Note 10-15", env="BS_NOTE_10_15_SHEET")
+    skiprows: int = Field(default=3, env="BS_SKIPROWS")
+
+settings = Settings()
+
+class NoteCSVInfo(BaseModel):
+    name: str
+    rows: int
+
+def clean_note(sheet_name: str, skiprows: int = settings.skiprows) -> pd.DataFrame:
+    """
+    Parse and clean a sheet from the Excel file.
+    Drops empty rows and columns, resets index.
+    """
+    df = xls.parse(sheet_name, skiprows=skiprows)
+    df = df.dropna(how='all').dropna(axis=1, how='all').reset_index(drop=True)
+    return df
+
+def export_note_to_csv(df: pd.DataFrame, filename: str, output_folder: str) -> NoteCSVInfo:
+    """
+    Export DataFrame to CSV and return info.
+    """
+    output_path = os.path.join(output_folder, filename)
+    df.to_csv(output_path, index=False)
+    return NoteCSVInfo(name=filename, rows=df.shape[0])
+
+def main() -> None:
+    """
+    Main function to extract notes from Excel and export as CSVs.
+    """
+    logger.info("Loading Excel file: %s", settings.excel_file_path)
+    global xls
+    xls = pd.ExcelFile(settings.excel_file_path)
+
+    # Clean each sheet
+    note_2_8_df = clean_note(settings.note_2_8_sheet, settings.skiprows)
+    note_9_df = clean_note(settings.note_9_sheet, settings.skiprows)
+    note_10_15_df = clean_note(settings.note_10_15_sheet, settings.skiprows)
+
+    # Ensure output folder exists
+    os.makedirs(settings.output_folder, exist_ok=True)
+
+    # Export each as CSV in the folder
+    info_2_8 = export_note_to_csv(note_2_8_df, "Note_2_to_8_Full.csv", settings.output_folder)
+    info_9 = export_note_to_csv(note_9_df, "Note_9_Full.csv", settings.output_folder)
+    info_10_15 = export_note_to_csv(note_10_15_df, "Note_10_to_15_Full.csv", settings.output_folder)
+
+    # Log confirmation and row counts
+    logger.info(f"Extracted rows: Note 2–8 = {info_2_8.rows} rows")
+    logger.info(f"Extracted rows: Note 9   = {info_9.rows} rows")
+    logger.info(f"Extracted rows: Note 10–15 = {info_10_15.rows} rows")
+
+if __name__ == "__main__":
+    main()

pnlbs/sircodepnl.py

@@ -0,0 +1,55 @@
+import os
+import pandas as pd
+import logging
+from typing import Optional
+from pydantic import BaseModel, Field
+from pydantic_settings import BaseSettings
+
+# Configure logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+class Settings(BaseSettings):
+    """Settings for P&L CSV extraction, loaded from environment variables or .env file."""
+    excel_file_path: str = Field(default="In Lakhs  BS_FY 23-24 V5 - Final.xlsx", env="PNL_EXCEL_FILE_PATH")
+    output_folder: str = Field(default="csv_notes_pnl", env="PNL_OUTPUT_FOLDER")
+    note_16_23_sheet: str = Field(default="Note 16-23", env="PNL_NOTE_16_23_SHEET")
+    skiprows: int = Field(default=3, env="PNL_SKIPROWS")
+
+settings = Settings()
+
+class NoteCSVInfo(BaseModel):
+    name: str
+    rows: int
+
+def clean_note(sheet_name: str, skiprows: int = settings.skiprows) -> pd.DataFrame:
+    """
+    Parse and clean a sheet from the Excel file.
+    Drops empty rows and columns, resets index.
+    """
+    xls = pd.ExcelFile(settings.excel_file_path)
+    df = xls.parse(sheet_name, skiprows=skiprows)
+    df = df.dropna(how='all').dropna(axis=1, how='all').reset_index(drop=True)
+    return df
+
+def export_note_to_csv(df: pd.DataFrame, filename: str, output_folder: str) -> NoteCSVInfo:
+    """
+    Export DataFrame to CSV and return info.
+    """
+    # Ensure output folder exists
+    os.makedirs(output_folder, exist_ok=True)
+    output_path = os.path.join(output_folder, filename)
+    df.to_csv(output_path, index=False)
+    return NoteCSVInfo(name=filename, rows=df.shape[0])
+
+def main() -> None:
+    """
+    Main function to extract P&L notes from Excel and export as CSV.
+    """
+    logger.info("Loading Excel file: %s", settings.excel_file_path)
+    note_16_23_df = clean_note(settings.note_16_23_sheet, settings.skiprows)
+
+    os.makedirs(settings.output_folder, exist_ok=True)
+    info_16_23 = export_note_to_csv(note_16_23_df, "Note_16_to_23_Full.csv", settings.output_folder)
+
+    logger.info(f"Extracted rows: Note 16-23 = {info_16_23.rows} rows")

pnlbs/temp_bl.py

@@ -0,0 +1,185 @@
+import logging
+from typing import List, Dict, Any, Optional
+from pydantic import BaseModel, Field
+
+# Configure logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+class BalanceSheetItem(BaseModel):
+    section: str
+    category: str
+    subcategory: Optional[str] = ""
+    name: str
+    note: str
+    indent_level: int = 1
+    is_total_row: bool = False
+    is_section_header: bool = False
+    is_category_header: bool = False
+
+class FormattingRules(BaseModel):
+    header: Dict[str, Any]
+    sections: Dict[str, Dict[str, Any]]
+    categories: Dict[str, Dict[str, Any]]
+    subcategories: Dict[str, Dict[str, Any]]
+    totals: Dict[str, Dict[str, Any]]
+
+class BalanceSheetTemplate:
+    """
+    Provides the structure, formatting, and field mappings for a standard Balance Sheet.
+    """
+
+    def __init__(self):
+        # Complete Balance Sheet Structure Template
+        self.template_structure: List[Dict[str, Any]] = [
+            BalanceSheetItem(section="EQUITY AND LIABILITIES", category="Shareholders' funds", subcategory="", name="Share capital", note="2").dict(),
+            BalanceSheetItem(section="EQUITY AND LIABILITIES", category="Shareholders' funds", subcategory="", name="Reserves and surplus", note="3").dict(),
+            BalanceSheetItem(section="EQUITY AND LIABILITIES", category="Non-Current liabilities", subcategory="", name="Long term borrowings", note="4").dict(),
+            BalanceSheetItem(section="EQUITY AND LIABILITIES", category="Non-Current liabilities", subcategory="", name="Deferred Tax Liability (Net)", note="5").dict(),
+            BalanceSheetItem(section="EQUITY AND LIABILITIES", category="Current liabilities", subcategory="", name="Trade payables", note="6").dict(),
+            BalanceSheetItem(section="EQUITY AND LIABILITIES", category="Current liabilities", subcategory="", name="Other current liabilities", note="7").dict(),
+            BalanceSheetItem(section="EQUITY AND LIABILITIES", category="Current liabilities", subcategory="", name="Short term provisions", note="8").dict(),
+            BalanceSheetItem(section="ASSETS", category="Non-current assets", subcategory="Fixed assets", name="Tangible assets", note="9", indent_level=2).dict(),
+            BalanceSheetItem(section="ASSETS", category="Non-current assets", subcategory="Fixed assets", name="Intangible assets", note="9", indent_level=2).dict(),
+            BalanceSheetItem(section="ASSETS", category="Non-current assets", subcategory="", name="Long Term Loans and Advances", note="10").dict(),
+            BalanceSheetItem(section="ASSETS", category="Current assets", subcategory="", name="Inventories", note="11").dict(),
+            BalanceSheetItem(section="ASSETS", category="Current assets", subcategory="", name="Trade receivables", note="12").dict(),
+            BalanceSheetItem(section="ASSETS", category="Current assets", subcategory="", name="Cash and bank balances", note="13").dict(),
+            BalanceSheetItem(section="ASSETS", category="Current assets", subcategory="", name="Short-term loans and advances", note="14").dict(),
+            BalanceSheetItem(section="ASSETS", category="Current assets", subcategory="", name="Other current assets", note="15").dict()
+        ]
+
+        # Formatting rules for display
+        self.formatting_rules: FormattingRules = FormattingRules(
+            header={
+                "title": "Balance Sheet as at March 31, 2024",
+                "currency_note": "(In Lakhs)",
+                "column_headers": ["", "Notes", "March 31, 2024", "March 31, 2023"]
+            },
+            sections={
+                "EQUITY AND LIABILITIES": {"display_name": "EQUITY AND LIABILITIES", "order": 1},
+                "ASSETS": {"display_name": "ASSETS", "order": 2}
+            },
+            categories={
+                "Shareholders' funds": {"display_name": "Shareholders' funds", "show_total": True, "total_label": "", "order": 1},
+                "Non-Current liabilities": {"display_name": "Non-Current liabilities", "show_total": True, "total_label": "", "order": 2},
+                "Current liabilities": {"display_name": "Current liabilities", "show_total": True, "total_label": "", "order": 3},
+                "Non-current assets": {"display_name": "Non-current assets", "show_total": True, "total_label": "", "order": 4},
+                "Current assets": {"display_name": "Current assets", "show_total": True, "total_label": "", "order": 5}
+            },
+            subcategories={
+                "Fixed assets": {"display_name": "Fixed assets", "show_total": True, "total_label": "", "parent_category": "Non-current assets"}
+            },
+            totals={
+                "TOTAL_EQUITY_LIABILITIES": {"display_name": "TOTAL", "position": "after_equity_liabilities", "is_grand_total": True},
+                "TOTAL_ASSETS": {"display_name": "TOTAL", "position": "after_assets", "is_grand_total": True}
+            }
+        )
+
+        # Field mapping patterns for data extraction
+        self.field_mappings: Dict[str, List[str]] = {
+            'share_capital': ['share capital', 'equity share', 'paid up', 'issued shares', 'authorised shares', 'subscribed', 'fully paid'],
+            'reserves_surplus': ['reserves and surplus', 'reserves', 'surplus', 'retained earnings', 'profit and loss', 'general reserves', 'closing balance'],
+            'long_term_borrowings': ['long term borrowings', 'long-term borrowings', 'borrowings', 'debt', 'loans', 'financial corporation', 'bank loan'],
+            'deferred_tax': ['deferred tax', 'tax liability', 'deferred tax liability'],
+            'trade_payables': ['trade payables', 'payables', 'creditors', 'sundry creditors', 'capital expenditure', 'other expenses'],
+            'other_current_liabilities': ['other current liabilities', 'current maturities', 'outstanding liabilities', 'statutory dues', 'accrued expenses'],
+            'short_term_provisions': ['short term provisions', 'provisions', 'provision for taxation', 'tax provision'],
+            'tangible_assets': ['tangible assets', 'property plant', 'fixed assets', 'buildings', 'plant', 'equipment', 'net carrying value'],
+            'intangible_assets': ['intangible assets', 'software', 'goodwill', 'intangible'],
+            'long_term_loans_advances': ['long term loans', 'security deposits', 'long term advances'],
+            'inventories': ['inventories', 'stock', 'consumables', 'raw materials'],
+            'trade_receivables': ['trade receivables', 'receivables', 'debtors', 'outstanding', 'other receivables'],
+            'cash_bank': ['cash and bank', 'cash', 'bank balances', 'current accounts', 'cash on hand', 'fixed deposits'],
+            'short_term_loans_advances': ['short term loans', 'prepaid expenses', 'other advances', 'advance tax', 'statutory authorities'],
+            'other_current_assets': ['other current assets', 'accrued income', 'interest accrued']
+        }
+
+    def get_template_structure(self) -> List[Dict[str, Any]]:
+        """Return the complete template structure."""
+        return self.template_structure.copy()
+
+    def get_formatting_rules(self) -> FormattingRules:
+        """Return the formatting rules."""
+        return self.formatting_rules.copy()
+
+    def get_field_mappings(self) -> Dict[str, List[str]]:
+        """Return the field mapping patterns."""
+        return self.field_mappings.copy()
+
+    def get_categories(self) -> List[str]:
+        """Get unique categories from template."""
+        categories = []
+        seen = set()
+        for item in self.template_structure:
+            cat = item["category"]
+            if cat not in seen:
+                categories.append(cat)
+                seen.add(cat)
+        return categories
+
+    def get_items_by_category(self, category: str) -> List[Dict[str, Any]]:
+        """Get all items for a specific category."""
+        return [item for item in self.template_structure if item["category"] == category]
+
+    def get_items_by_section(self, section: str) -> List[Dict[str, Any]]:
+        """Get all items for a specific section."""
+        return [item for item in self.template_structure if item["section"] == section]
+
+    def get_subcategories(self, category: str) -> List[str]:
+        """Get subcategories for a specific category."""
+        subcats = set()
+        for item in self.template_structure:
+            if item["category"] == category and item["subcategory"]:
+                subcats.add(item["subcategory"])
+        return list(subcats)
+
+# For backward compatibility - alias the class
+BalanceSheet = BalanceSheetTemplate
+
+# Module level constants for quick access
+BALANCE_SHEET_SECTIONS: List[str] = ["EQUITY AND LIABILITIES", "ASSETS"]
+
+BALANCE_SHEET_CATEGORIES: List[str] = [
+    "Shareholders' funds",
+    "Non-Current liabilities",
+    "Current liabilities",
+    "Non-current assets",
+    "Current assets"
+]
+
+STANDARD_NOTES_MAPPING: Dict[str, str] = {
+    "Share capital": "2",
+    "Reserves and surplus": "3",
+    "Long term borrowings": "4",
+    "Deferred Tax Liability (Net)": "5",
+    "Trade payables": "6",
+    "Other current liabilities": "7",
+    "Short term provisions": "8",
+    "Tangible assets": "9",
+    "Intangible assets": "9",
+    "Long Term Loans and Advances": "10",
+    "Inventories": "11",
+    "Trade receivables": "12",
+    "Cash and bank balances": "13",
+    "Short-term loans and advances": "14",
+    "Other current assets": "15"
+}
+
+SIMPLE_TEMPLATE: List[Dict[str, Any]] = [
+    {"category": "Shareholders' funds", "name": "Share capital", "note": "2"},
+    {"category": "Shareholders' funds", "name": "Reserves and surplus", "note": "3"},
+    {"category": "Non-Current liabilities", "name": "Long term borrowings", "note": "4"},
+    {"category": "Non-Current liabilities", "name": "Deferred Tax Liability (Net)", "note": "5"},
+    {"category": "Current liabilities", "name": "Trade payables", "note": "6"},
+    {"category": "Current liabilities", "name": "Other current liabilities", "note": "7"},
+    {"category": "Current liabilities", "name": "Short term provisions", "note": "8"},
+    {"category": "Non-current assets", "subcategory": "Fixed assets", "name": "Tangible assets", "note": "9"},
+    {"category": "Non-current assets", "subcategory": "Fixed assets", "name": "Intangible assets", "note": "9"},
+    {"category": "Non-current assets", "name": "Long Term Loans and Advances", "note": "10"},
+    {"category": "Current assets", "name": "Inventories", "note": "11"},
+    {"category": "Current assets", "name": "Trade receivables", "note": "12"},
+    {"category": "Current assets", "name": "Cash and bank balances", "note": "13"},
+    {"category": "Current assets", "name": "Short-term loans and advances", "note": "14"},
+    {"category": "Current assets", "name": "Other current assets", "note": "15"}
+]

requirements.txt

@@ -0,0 +1,9 @@
+fastapi
+uvicorn
+pandas
+openpyxl
+python-dotenv
+pydantic-settings
+pydantic
+requests
+python-multipart