policy analyser app

.gitignore

@@ -0,0 +1,4 @@
+__pycache__
+*.pycache
+*.pyc
+*.env

app.py

@@ -0,0 +1,129 @@
+import os
+
+import streamlit as st
+
+from utils import validate_pdf
+from styles import apply_custom_styles
+from policy_analyser.analyse import analyse
+
+if 'GPT_KEY' not in os.environ or os.environ.get('GPT_KEY') in [None, '']:
+    os.environ['GPT_KEY'] = st.secrets['GPT_KEY']
+
+def main():
+    # Apply custom styles
+    apply_custom_styles()
+
+    # Header
+    st.markdown("""
+        <div class="header-container">
+            <img src="https://acko-brand.ackoassets.com/brand/vector-svg/gradient/horizontal-reverse.svg" height=50 width=100>
+                <h1>Insurance Policy Analyzer</h1>
+            <p>Upload and compare insurance policies</p>
+        </div>
+    """, unsafe_allow_html=True)
+
+    # File upload section
+    st.markdown('<div class="upload-container">', unsafe_allow_html=True)
+    uploaded_files = st.file_uploader("Choose policy PDF files", type="pdf", accept_multiple_files=True)
+    print(uploaded_files)
+    st.markdown('</div>', unsafe_allow_html=True)
+
+    if uploaded_files and st.button('Analyse'):
+        # Create tabs for different views
+        tab1, tab2 = st.tabs(["Summary View", "Detailed Comparison"])
+
+        # Store analysis results
+        all_analyses = []
+
+        # Process each uploaded file
+        for uploaded_file in uploaded_files:
+            # Read PDF content
+            pdf_bytes = uploaded_file.read()
+            # displayPDF(pdf_bytes)
+
+            # Validate PDF
+            if not validate_pdf(pdf_bytes):
+                st.error(f"Invalid PDF file: {uploaded_file.name}")
+                continue
+
+            # Show loading state
+            with st.spinner(f"Analyzing {uploaded_file.name}..."):
+                try:
+                    # Make API call
+                    response = analyse(pdf_bytes, True)
+                    analysis = next(
+                        (item for item in response if item.get("stage") == "ANALYSE"), None
+                    )['response']
+                    analysis = analysis.split('[CUSTOMER_RESPONSE]')[-1].split('[/CUSTOMER_RESPONSE]')[0]
+                    suggestion = next(
+                        (item for item in response if item.get("stage") == "SUGGEST"), None
+                    )['response']
+                    suggestion = suggestion.split('[POLICY_PITCH]')[-1].split('[/POLICY_PITCH]')[0]
+                    # Store results
+                    all_analyses.append({
+                        'name': uploaded_file.name,
+                        'analysis' : analysis,
+                        'suggestion' : suggestion
+                    })
+
+                except Exception as e:
+                    st.error(f"Error analyzing {uploaded_file.name}: {str(e)}")
+
+        # Summary View Tab
+        with tab1:
+            for idx, analysis in enumerate(all_analyses):
+                with st.expander(f"### Policy {idx + 1}: {analysis['name']}"):
+                    with st.container():
+                        st.markdown(analysis['analysis'])
+                    with st.container():
+                        st.markdown('# Why Acko? 🚀')
+                        st.markdown(analysis['suggestion'])
+
+        # Detailed Comparison Tab
+        with tab2:
+            if len(all_analyses) > 1:
+                # Create comparison matrix
+                factors_to_compare = set()
+                for analysis in all_analyses:
+                    factors_to_compare.update(
+                        [f.split(':')[0] for f in analysis['good_factors'] + 
+                         analysis['average_factors'] + analysis['bad_factors']]
+                    )
+
+                # Create comparison table
+                st.markdown("### Policy Comparison Matrix")
+
+                comparison_data = []
+                for factor in sorted(factors_to_compare):
+                    row = {'Factor': factor}
+                    for idx, analysis in enumerate(all_analyses):
+                        policy_name = f"Policy {idx + 1}"
+                        verdict = 'Not Found'
+                        for category in ['good_factors', 'average_factors', 'bad_factors']:
+                            for item in analysis[category]:
+                                if item.split(':')[0] == factor:
+                                    verdict = category.split('_')[0].title()
+                                    break
+                        row[policy_name] = verdict
+                    comparison_data.append(row)
+
+                # Display comparison table
+                st.table(comparison_data)
+            else:
+                st.info("Upload multiple policies to see comparison")
+
+    # Footer
+    st.markdown("""
+        <div style="margin-top: 50px; text-align: center; color: #666;">
+            <p>Upload one or more insurance policy PDFs to get detailed analysis and comparison.</p>
+            <p>We support all major insurance providers.</p>
+        </div>
+    """, unsafe_allow_html=True)
+
+if __name__ == "__main__":
+    st.set_page_config(
+        page_title="Insurance Policy Analyzer",
+        page_icon="📋",
+        layout="wide"
+    )
+    main()

main.py

@@ -0,0 +1,154 @@
+import streamlit as st
+import io
+from utils import mock_api_call, parse_analysis_response, validate_pdf, displayPDF
+from styles import apply_custom_styles, show_factor_section, show_detailed_factors, show_factor_summary
+
+from policy_analyser.analyse import analyse
+
+def main():
+    # Apply custom styles
+    apply_custom_styles()
+
+    # Header
+    st.markdown("""
+        <div class="header-container">
+            <img src="https://acko-brand.ackoassets.com/brand/vector-svg/gradient/horizontal-reverse.svg" height=50 width=100>
+                <h1>Insurance Policy Analyzer</h1>
+            <p>Upload and compare insurance policies</p>
+        </div>
+    """, unsafe_allow_html=True)
+
+    # File upload section
+    st.markdown('<div class="upload-container">', unsafe_allow_html=True)
+    uploaded_files = st.file_uploader("Choose policy PDF files", type="pdf", accept_multiple_files=True)
+    st.markdown('</div>', unsafe_allow_html=True)
+
+    if uploaded_files:
+        # Create tabs for different views
+        tab1, tab2 = st.tabs(["Summary View", "Detailed Comparison"])
+
+        # Store analysis results
+        all_analyses = []
+
+        # Process each uploaded file
+        for uploaded_file in uploaded_files:
+            # Read PDF content
+            pdf_bytes = uploaded_file.read()
+            # displayPDF(pdf_bytes)
+
+            # Validate PDF
+            if not validate_pdf(pdf_bytes):
+                st.error(f"Invalid PDF file: {uploaded_file.name}")
+                continue
+
+            # Show loading state
+            with st.spinner(f"Analyzing {uploaded_file.name}..."):
+                try:
+                    # Make API call
+                    response = analyse(pdf_bytes)
+                    print(response)
+                    summary = next(
+                        (item for item in response if item.get("stage") == "ANALYSIS_SUMMARY"), None
+                    )['response']
+
+                    # Parse response
+                    good_factors, average_factors, bad_factors = parse_analysis_response(response)
+
+                    # Store results
+                    all_analyses.append({
+                        'name': uploaded_file.name,
+                        'good_factors': good_factors,
+                        'average_factors': average_factors,
+                        'bad_factors': bad_factors
+                    })
+
+                except Exception as e:
+                    st.error(f"Error analyzing {uploaded_file.name}: {str(e)}")
+
+        # Summary View Tab
+        with tab1:
+            for idx, analysis in enumerate(all_analyses):
+                with st.expander(f"### Policy {idx + 1}: {analysis['name']}"):
+                    with st.container():
+                        cols = st.columns(2)
+                        displayed = 0
+                        for verdict in ['Good', 'Average', 'Bad']:
+                            lst = [f.split(':')[0] for f in analysis[f'{verdict.lower()}_factors']]
+                            if len(lst) > 0:
+                                title = f'{verdict} Factors'
+                                if verdict == 'Good':
+                                    title += '✅'
+                                    sentiment = 'Yay!'
+                                elif verdict == 'Average':
+                                    title += '⚠️'
+                                    sentiment = 'Hmmmm'
+                                else:
+                                    title += '❌'
+                                    sentiment = 'Meh'
+                                cols = st.columns(2)
+                                with st.container():
+                                    with cols[0]:
+                                        if displayed % 3 == 0:
+                                            show_factor_section(title, lst, verdict.lower())
+                                        else:
+                                            show_factor_summary(summary[verdict], verdict.lower(), sentiment)
+                                    with cols[1]:
+                                        if displayed % 3 == 0:
+                                            show_factor_summary(summary[verdict], verdict.lower(), sentiment)
+                                        else:
+                                            show_factor_section(title, lst, verdict.lower())
+                                displayed += 1
+
+                    st.markdown('-----')
+                    # with st.container():
+                        # suggestion = next((item for item in response if item.get("stage") == "SUGGEST"), None)['response']
+                        # show_factor_summary(suggestion, 'Good', 'What we have ⛑️')
+
+        # Detailed Comparison Tab
+        with tab2:
+            if len(all_analyses) > 1:
+                # Create comparison matrix
+                factors_to_compare = set()
+                for analysis in all_analyses:
+                    factors_to_compare.update(
+                        [f.split(':')[0] for f in analysis['good_factors'] + 
+                         analysis['average_factors'] + analysis['bad_factors']]
+                    )
+
+                # Create comparison table
+                st.markdown("### Policy Comparison Matrix")
+
+                comparison_data = []
+                for factor in sorted(factors_to_compare):
+                    row = {'Factor': factor}
+                    for idx, analysis in enumerate(all_analyses):
+                        policy_name = f"Policy {idx + 1}"
+                        verdict = 'Not Found'
+                        for category in ['good_factors', 'average_factors', 'bad_factors']:
+                            for item in analysis[category]:
+                                if item.split(':')[0] == factor:
+                                    verdict = category.split('_')[0].title()
+                                    break
+                        row[policy_name] = verdict
+                    comparison_data.append(row)
+
+                # Display comparison table
+                st.table(comparison_data)
+            else:
+                st.info("Upload multiple policies to see comparison")
+
+    # Footer
+    st.markdown("""
+        <div style="margin-top: 50px; text-align: center; color: #666;">
+            <p>Upload one or more insurance policy PDFs to get detailed analysis and comparison.</p>
+            <p>We support all major insurance providers.</p>
+        </div>
+    """, unsafe_allow_html=True)
+
+if __name__ == "__main__":
+    st.set_page_config(
+        page_title="Insurance Policy Analyzer",
+        page_icon="📋",
+        layout="wide"
+    )
+    main()

policy_analyser/__init__.py

@@ -0,0 +1,43 @@
+import os
+import json
+from dotenv import load_dotenv
+
+try:
+    load_dotenv('.env')
+except:
+    pass
+
+PACKAGE = 'policy_analyser'
+PROJECT_DIR = os.getcwd()
+PACKAGE_PATH = os.path.join(PROJECT_DIR, PACKAGE)
+PROMPTS_DIR = os.path.join(PACKAGE_PATH, 'prompts')
+DATA_DIR = os.path.join(PACKAGE_PATH, 'data')
+
+CREDENTIALS = {
+    'azure' : {
+        'plain-text' : {
+            'endpoint' : os.environ.get('AZURE_PLAIN_TEXT_ENDPOINT', ''),
+            'key' : os.environ.get('AZURE_PLAIN_TEXT_KEY')
+        },
+        'layout' : {
+            'endpoint' : os.environ.get('AZURE_LAYOUT_ENDPOINT', ''),
+            'key' : os.environ.get('AZURE_LAYOUT_KEY', ''),
+            'model' : os.environ.get('AZURE_LAYOUT_MODEL', '')
+        }
+    }
+}
+
+GPT_ENGINE = 'o3-mini'
+GPT_KEY = os.environ.get('GPT_KEY', '')
+GPT_VERSION = '2024-12-01-preview'
+GPT_API_BASE = 'https://ai-ackods910341544474.openai.azure.com/'
+
+EXTRACTION_PROMPT = open(os.path.join(PROMPTS_DIR, 'extraction.txt')).read()
+entities = json.load(open(os.path.join(DATA_DIR, 'policy_analyser_entities.json')))
+for entity in entities:
+    del entity['entityId']
+entities_str = '\n---\n'.join(['\n'.join([f'{k} : {v}' for k, v in entity.items()]) for entity in entities])
+EXTRACTION_PROMPT += entities_str
+ANALYSIS_PROMPT = open(os.path.join(PROMPTS_DIR, 'analysis.txt')).read().strip()
+SUGGESTION_PROMPT = open(os.path.join(PROMPTS_DIR, 'suggest.txt')).read().strip()
+ACKO_POLICY = open(os.path.join(DATA_DIR, 'Policy_Wordings_Acko_Personal_Health_Policy_Applicable_for_the_policies_sold_post_1_10_2024_64ea02eb51_ab3c8eefa2.md')).read()

policy_analyser/analyse.py

@@ -0,0 +1,232 @@
+"""
+    Run analysis
+    @author : Sakshi Tantak
+"""
+
+# Imports
+from time import time
+from datetime import datetime
+
+from policy_analyser import ACKO_POLICY, ANALYSIS_PROMPT, SUGGESTION_PROMPT
+from policy_analyser.ocr import AzureLayoutOCR, PyMuPDF4LLMOCR
+from policy_analyser.extraction import extract
+from policy_analyser.rules import prepare_payload, rules
+from policy_analyser.llm import call_openai
+
+# OCR = AzureLayoutOCR()
+OCR = PyMuPDF4LLMOCR()
+
+def analyse(file_bytes, end2end = False):
+    print('OCR Started ...')
+    ocr_start = time()
+    if isinstance(file_bytes, str):
+        text = file_bytes
+    elif isinstance(file_bytes, (bytearray, bytes)):
+        text, _ = OCR(file_bytes)
+    ocr_end = time()
+    print(f'OCR done [{ocr_end - ocr_start}]')
+    if len(text) > 0:
+        if not end2end:
+            print('Extraction Started ...')
+            ext_start = time()
+            raw_response, entities = extract(text)
+            ext_end = time()
+            print(f'Extraction done [{ext_end - ext_start}]')
+            if len(entities) > 0:
+                print('Preparing payload for analysis ...')
+                payload = prepare_payload(entities)
+                print('Payload prepared for analysis')
+                print('Analysing ...')
+                analysis_start = time()
+                analysis = rules(payload)
+                analysis_end = time()
+                print(f'Analysed [{analysis_end - analysis_start}]')
+                print('Summarising ...')
+                summary = {}
+                summary_start = time()
+                for verdict in ['Good', 'Average', 'Bad']:
+                    descriptions = '\n'.join([factor['reason'] for factor in analysis if factor['verdict'] == verdict])
+                    if len(descriptions) > 0:
+                        prompt = f"""Given the following analysis on the {verdict} factors of a customer's policy that they have bought, generate a crisp and catchy summary of the factors for a customer. Try to make it factor-wise with bullet points
+    NOTE : THE POLICY WAS NOT SOLD BY US
+    analysis : {descriptions}
+    summary : """
+                        response = call_openai(prompt)
+                        print(response)
+                    else:
+                        response = ''
+                    summary[verdict] = response
+                summary_end = time()
+    #             print(f'Summarised [{summary_end - summary_start}]')
+    #             factors_str = ''
+    #             for verdict in ['Good', 'Average', 'Bad']:
+    #                 factors_str += verdict + ' Factors:'
+    #                 factors_str += '\n' + '\n'.join([f"{factor['factor']}: {factor['reason']}" for factor in analysis if factor['verdict'] == verdict])
+    #             print('Suggesting ...')
+    #             suggestion_start = time()
+    #             suggestion = call_openai(f"""Given the following main factors and their values of a customer's health insurance policy, use these factors to compare with given Acko's health policy and suggest to the customer how the Average and Bad factors maybe covered better by Acko's policy.
+    # Format response in less than 50 words and make it factor-wise. Try to format in points. Include emojis to make it catchy.
+    # Customer Poliocy Factors:
+    # {factors_str}
+
+    # Acko Policy : {ACKO_POLICY}
+
+    # Customer Suggestion : """)
+    #             suggestion_end = time()
+                # print(f'Suggested [{suggestion_end - suggestion_start}]')
+                response = [
+                    {
+                        'stage' : 'OCR',
+                        'response' : text,
+                        'time' : ocr_end - ocr_start
+                    },
+                    {
+                        'stage' : 'EXTRACTION',
+                        'response' : {
+                            'raw' : raw_response,
+                            'processed' : entities
+                        },
+                        'time' : ext_end - ext_start
+                    },
+                    {
+                        'stage' : 'POST_PROCESS',
+                        'response' : payload,
+                        'time' : 0
+                    },
+                    {
+                        'stage' : 'ANALYSE',
+                        'response' : analysis,
+                        'time' : analysis_end - analysis_start
+                    },
+                    {
+                        'stage' : 'ANALYSIS_SUMMARY',
+                        'response' : summary,
+                        'time' : summary_end - summary_start
+                    },
+                    # {
+                    #     'stage' : 'SUGGEST',
+                    #     'response' : suggestion,
+                    #     'time' : suggestion_end - suggestion_start
+                    # }
+                ]
+                return response
+
+            response = [
+                    {
+                        'stage' : 'OCR',
+                        'response' : text,
+                        'time' : 0
+                    },
+                    {
+                        'stage' : 'EXTRACTION',
+                        'response' : {
+                            'raw' : '',
+                            'processed' : []
+                        },
+                        'time' : 0
+                    },
+                    {
+                        'stage' : 'POST_PROCESS',
+                        'response' : {},
+                        'time' : 0
+                    },
+                    {
+                        'stage' : 'ANALYSE',
+                        'response' : [],
+                        'time' : 0
+                    },
+                    {
+                        'stage' : 'ANALYSIS_SUMMARY',
+                        'response' : {'Good' : '', 'Average' : '', 'Bad' : ''},
+                        'time' : 0
+                    },
+                    # {
+                    #     'stage' : 'SUGGEST',
+                    #     'response' : '',
+                    #     'time' : 0
+                    # }
+                ]
+            return response
+
+        else:
+            response = [
+                {
+                    'stage' : 'OCR',
+                    'response' : text,
+                    'time' : ocr_end - ocr_start
+                }
+            ]
+            try:
+                print('Analysing ...')
+                analysis_start = time()
+                raw_response = call_openai(ANALYSIS_PROMPT + 'Policy : ' + text + f"\n\nConsider today's date as {datetime.today().day}/{datetime.today().month}/{datetime.today().year} for your analysis on waiting periods and dates")
+                analysis_end = time()
+                print(f'Analysed [{analysis_end - analysis_start}]')
+                if raw_response is not None:
+                    response.append(
+                        {
+                            'stage' : 'ANALYSE',
+                            'response' : raw_response,
+                            'time' : analysis_end - analysis_start
+                        }
+                    )
+                    print('Suggesting our policy ...')
+                    suggestion_start = time()
+                    suggestion = call_openai(SUGGESTION_PROMPT + "\nCustomer Policy Analysis : " + raw_response + "\nAcko's Policy : " + ACKO_POLICY)
+                    suggestion_end = time()
+                    print(f'Suggested [{suggestion_end - suggestion_start}]')
+                    if suggestion is not None:
+                        response.append({
+                            'stage' : 'SUGGEST',
+                            'response' : suggestion,
+                            'time' : suggestion_end - suggestion_start
+                            }
+                        )
+                        return response
+            except Exception as e:
+                print(e)
+                response.extend(
+                    [
+                        {
+                            'stage' : 'ANALYSE',
+                            'response' : '',
+                            'time' : 0
+                        },
+                        {
+                            'stage' : 'SUGGEST',
+                            'response' : '',
+                            'time' : 0
+                        }
+                    ]
+                )
+            return response
+
+if __name__ == '__main__':
+    import os
+    import json
+    import sys
+    from tqdm import tqdm
+    filepaths = sys.argv[1:]
+
+    for filepath in tqdm(filepaths):
+        # if os.path.isfile(filepath.replace('.pdf', '.analysis.json')):
+            # continue
+        if '.analysis' in filepath or '.e2e-analysis' in filepath:
+            continue
+        print(filepath)
+        if filepath.endswith('.pdf'):
+            file_bytes = open(filepath, 'rb').read()
+        elif filepath.endswith(('.txt', '.md')):
+            file_bytes = open(filepath).read()
+        end2end = True
+        analysis = analyse(file_bytes, True)
+        # print(analysis)
+        basepath = os.path.splitext(filepath)[0]
+        if not end2end:
+            with open(os.path.splitext(filepath)[0] + '.analysis.json', 'w') as f:
+                json.dump(analysis, f, indent = 4)
+        else:
+            with open(os.path.splitext(filepath)[0] + '.e2e-analysis.json', 'w') as f:
+                json.dump(analysis, f, indent = 4)
+            with open(os.path.splitext(filepath)[0] + '.e2e-analysis.md', 'w') as f:
+                f.write(analysis[1]['response'])

policy_analyser/data/policy_analyser_entities.json

@@ -0,0 +1,176 @@
+[
+  {
+    "entityId": 0,
+    "entityName": "Sum Insured (SI)",
+    "entityDesc": "Total sum insured according to selected insurance plan",
+    "expectedOutputFormat": "float"
+  },
+  {
+    "entityId": 1,
+    "entityName": "Pre-existing diseases (PED) Waiting period",
+    "entityDesc": "Waiting period on any pre-existing diseases after the policy start date for the selected insurance plan",
+    "expectedOutputFormat": "number of months in float"
+  },
+  {
+    "entityId": 2,
+    "entityName": "30-Day Waiting Period",
+    "entityDesc": "Is there waiting period on first 30 days after the policy start date for selected insurance plan?",
+    "expectedOutputFormat": "true/false"
+  },
+  {
+    "entityId": 3,
+    "entityName": "Specific Illness Waiting Period",
+    "entityDesc": "Waiting period on any specific illnesses after the policy start date for selected insurance plan",
+    "expectedOutputFormat": "number of months in float"
+  },
+  {
+    "entityId": 4,
+    "entityName": "Maternity waiting period",
+    "entityDesc": "Waiting period on maternity treatments and causes after policy start date for selected insurance plan",
+    "expectedOutputFormat": "number of months in float"
+  },
+  {
+    "entityId": 5,
+    "entityName": "Exclusions",
+    "entityDesc": "Diseases/procedures/treatments etc that are excluded from coverage of the policy under selected insurance plan",
+    "expectedOutputFormat": "stringified JSON list"
+  },
+  {
+    "entityId": 6,
+    "entityName": "Maternity benefits",
+    "entityDesc": "Are there any additional benefits for maternity illnesses, treatments or procedures under selected insurance plan?",
+    "expectedOutputFormat": "true/false"
+  },
+  {
+    "entityId": 7,
+    "entityName": "OPD",
+    "entityDesc": "Amount covering outpatient consultations like physician visits, medicines, etc for the customer under selected insurance plan",
+    "expectedOutputFormat": "float"
+  },
+  {
+    "entityId": 8,
+    "entityName": "Copay",
+    "entityDesc": "% of amount that a customer must bear themselves and remainder is paid by the insurer under selected insurance plan",
+    "expectedOutputFormat": "float"
+  },
+  {
+    "entityId": 9,
+    "entityName": "Deductible",
+    "entityDesc": "Amount above which the Sum Insured can be claimed in case of super topup for selected insurance plan",
+    "expectedOutputFormat": "float"
+  },
+  {
+    "entityId": 10,
+    "entityName": "Daycare treatment",
+    "entityDesc": "Daycare treatments and procedures where hospitalization may be required for < 24 hours under selected insurance plan",
+    "expectedOutputFormat": "stringified JSON list"
+  },
+  {
+    "entityId": 11,
+    "entityName": "Free Health checkup",
+    "entityDesc": "Are free full body health checkups offered under selected insurance plan?",
+    "expectedOutputFormat": "true/false"
+  },
+  {
+    "entityId": 12,
+    "entityName": "Restoration benefit",
+    "entityDesc": "Does insured sum get restored after if it gets exhausted for selected insurance plan?",
+    "expectedOutputFormat": "true/false"
+  },
+  {
+    "entityId": 13,
+    "entityName": "Sublimits",
+    "entityDesc": "Coverage amount on a claim for specific diseases and treatments under selected insurance plan. Extract all sublimits as JSON list of dictionaries of following schema: [{\"sublimit_name\": \"Name of sublimit\", \"sublimit_value\": Value of sublimit in float}]",
+    "expectedOutputFormat": "stringified JSON list"
+  },
+  {
+    "entityId": 14,
+    "entityName": "Room rent limit (proportionate deduction)",
+    "entityDesc": "% of total sum insured or amount of total sum insured that insurer shall pay for hospitalisation room rent for selected insurance plan. If given upto SI, find the amount or percentage.",
+    "expectedOutputFormat": "float or string"
+  },
+  {
+    "entityId": 15,
+    "entityName": "Pre & Post Hospitalization",
+    "entityDesc": "Are medical expenses leading to and after hospitalization covered under selected insurance plan?",
+    "expectedOutputFormat": "true/false"
+  },
+  {
+    "entityId": 16,
+    "entityName": "Domiciliary Cover",
+    "entityDesc": "Is home treatment covered under selected insurance plan?",
+    "expectedOutputFormat": "true/false"
+  },
+  {
+    "entityId": 17,
+    "entityName": "No claim bonus",
+    "entityDesc": "Reward offered to customer for selected insurance plan for not raising any claims in the past",
+    "expectedOutputFormat": "float"
+  },
+  {
+    "entityId": 18,
+    "entityName": "Ambulance cover",
+    "entityDesc": "Coverage for ambulance charges under selected insurance plan",
+    "expectedOutputFormat": "float"
+  },
+  {
+    "entityId": 19,
+    "entityName": "International coverage",
+    "entityDesc": "Are treatments administered outside India covered under selected insurance plan?",
+    "expectedOutputFormat": "true/false"
+  },
+  {
+    "entityId": 20,
+    "entityName": "Dental treatment",
+    "entityDesc": "Coverage for dental treatments and procedures under selected insurance plan",
+    "expectedOutputFormat": "float"
+  },
+  {
+    "entityId": 21,
+    "entityName": "AYUSH treatment",
+    "entityDesc": "Are Ayurvedic, Homeopathic and other alternative treatments covered under selected insurance plan?",
+    "expectedOutputFormat": "true/false"
+  },
+  {
+    "entityId": 22,
+    "entityName": "Health incentives",
+    "entityDesc": "Are any benefits for healthy habits offered under selected insurance plan?",
+    "expectedOutputFormat": "true/false"
+  },
+  {
+    "entityId": 23,
+    "entityName": "Wellness Services",
+    "entityDesc": "Are any complementary services and benefits offered under selected insurance plan?",
+    "expectedOutputFormat": "true/false"
+  },
+  {
+    "entityId": 24,
+    "entityName": "Consumables/ Non medical expenses",
+    "entityDesc": "Are expenses related to consumables like syringes, bandages, etc in the course of treatment covered under selected insurance plan?",
+    "expectedOutputFormat": "true/false"
+  },
+  {
+    "entityId": 25,
+    "entityName": "Hospital Cash",
+    "entityDesc": "Are amounts paid in hospital bills reimbursed under selected insurance plan?",
+    "expectedOutputFormat": "true/false"
+  },
+  {
+    "entityId": 26,
+    "entityName": "Policy Holder's Details",
+    "entityDesc": "Details of primary policy holder as a JSON dictionary of the following schema : {\"name\": \"Name of primary policy holder\", \"age\": \"Age of primary policy holder in float number\", \"date_of_birth\": \"Date of birth of primary policy holder in dd/mm/yyyy format\", \"address\": \"Residential address of primary policy holder\", \"city\": \"City of residence of primary policy holder\", \"email_address\": \"Email address of primary policy holder\", \"phone_number\": \"Phone number of primary policy holder in integer or string\", \"pan\": \"Permanent Account Number (PAN) of primary policy holder\"}",
+    "expectedOutputFormat": "stringified JSON dictionary"
+  },
+  {
+    "entityId": 27,
+    "entityName": "Insured Persons details",
+    "entityDesc": "Details of insured persons as a JSON list of dictionaries of the following schema : [{\"name\": \"Name of Insured person\", \"age\": \"Age of Insured person in float\", \"date_of_birth\": \"Date of birth of Insured person in dd/mm/yyyy format\", \"gender\": \"Gender of Insured person, one of [Male, Female, Other]\", \"relation\": \"Relationship of insured person with policy holder, one of [Self, Spouse, Mother, Father, Son, Daughter, Mother-in-law, Father-in-law]\", \"pre_existing_diseases\": \"Pre-existing diseases that Insured person has. Separate several diseases with comma in JSON list\"}]",
+    "expectedOutputFormat": "stringified JSON list"
+  },
+  {
+    "entityId": 28,
+    "entityName": "Policy Details",
+    "entityDesc": "Details of the selected insurance plan policy issued to customer as a JSON dictionary of the following schema : {\"insurance_company_name\": \"Name of the insurance company that has issued the given insurance policy\", \"policy_name\": \"Name of the given insurance policy as string\", \"policy_number\": \"Policy number of the given insurance policy\", \"date_of_issue\": \"Date on which the policy was issued to the policy holder in dd/mm/yyy format\", \"policy_start_date\": \"Date on which policy activated in dd/mm/yyyy format\", \"policy_end_date\": \"Date on which policy expires in dd/mm/yyyy format\", \"renewal_date\": \"Date on which policy was renewed in dd/mm/yyyy format\"}",
+    "expectedOutputFormat": "stringified JSON dictionary"
+  }
+]

policy_analyser/extraction.py

@@ -0,0 +1,29 @@
+"""
+    Extraction
+    @author : Sakshi Tantak
+"""
+
+# Imports
+import os
+import re
+import json
+
+from policy_analyser import EXTRACTION_PROMPT
+from policy_analyser.llm import call_openai
+
+
+def extract(text):
+    raw_response = ''
+    try:
+        raw_response = call_openai(EXTRACTION_PROMPT + '\nPolicy Document : ' + text)
+        print(raw_response)
+        response = re.sub(r'`|json', '', raw_response)
+        try:
+            response = json.loads(response)
+            response = [{'entityName' : k, 'entityValue' : v} for k, v in response.items()]
+        except:
+            response = []
+    except Exception as e:
+        print(e)
+        response = []
+    return raw_response, response

policy_analyser/llm.py

@@ -0,0 +1,31 @@
+"""
+    Call OpenAI
+    @author : Sakshi Tantak
+"""
+
+# Imports
+import os
+
+from openai import AzureOpenAI
+
+from policy_analyser import GPT_ENGINE, GPT_API_BASE, GPT_KEY, GPT_VERSION
+
+CLIENT = AzureOpenAI(
+  azure_endpoint = GPT_API_BASE,
+  api_key = GPT_KEY,
+  api_version = GPT_VERSION
+)
+
+def call_openai(system_prompt, seed = 42):
+    print('Calling openai')
+    # messages = [{'role' : 'system', 'content' : system_prompt},
+                # {'role' : 'user', 'content' : document}]
+    messages = [{'role' : 'user', 'content' : system_prompt}]
+    response = CLIENT.chat.completions.create(
+        model = GPT_ENGINE,
+        messages = messages,
+        # response_format = response_format,
+        reasoning_effort = 'low'
+    )
+    
+    return response.choices[0].message.content

policy_analyser/ocr.py

@@ -0,0 +1,140 @@
+"""
+    OCR
+    @author : Sakshi Tantak
+"""
+
+# Imports
+import json
+
+from azure.core.credentials import AzureKeyCredential
+from azure.ai.formrecognizer import DocumentAnalysisClient
+import pymupdf4llm, pymupdf
+
+from policy_analyser import CREDENTIALS
+
+def convert_nested_complex_obj_to_json(result):
+    result = json.loads(json.dumps(result, default = lambda o : o.__dict__))
+    return result
+
+class AzureLayoutOCR:
+    def __init__(self):
+        self.client = self._authenticate()
+        self.engine = 'azure/layout'
+
+    def _authenticate(self):
+        client = DocumentAnalysisClient(
+            endpoint=CREDENTIALS['azure']['layout']['endpoint'],
+            credential=AzureKeyCredential(CREDENTIALS['azure']['layout']['key']),
+            connection_verify=False
+        )
+        return client
+
+    def _table2md(self, table, **kwargs):
+        row_count, column_count = table['row_count'], table['column_count']
+        cells = table['cells']
+
+        markdown_table = []
+        table_offsets = (table['spans'][0]['offset'], table['spans'][-1]['offset'] + table['spans'][-1]['length'])
+
+        for _ in range(row_count + 1):
+            row = [''] * column_count
+            markdown_table.append(row)
+
+        header_row_idx = [0]
+        for cell in cells:
+            row_index = cell['row_index']
+            if cell['kind'] == 'columnHeader':
+                # Headers are in the first row of markdown_table, which is row_index 0
+                markdown_table[row_index + 1][cell['column_index']] = '**' + cell['content'].replace('|', '') + '**'
+                header_row_idx.append(row_index + 1)
+            else:
+                # Content cells are offset by 1 due to headers
+                markdown_table[row_index + 1][cell['column_index']] = cell['content'].replace('|', '')
+
+        markdown_output = ''
+        for row in markdown_table:
+            markdown_output += '| ' + ' | '.join(row) + ' |\n'
+            if markdown_table.index(row) in header_row_idx:
+                # if markdown_table.index(row) == 0:
+                # Add a separator after the header
+                markdown_output += '| ' + ' | '.join(['---'] * column_count) + ' |\n'
+
+        return markdown_output, table_offsets
+
+    def _paragraphs2md(self, paragraph, element_offsets, **kwargs):
+        paragraph_offsets = (
+        paragraph['spans'][0]['offset'], paragraph['spans'][-1]['offset'] + paragraph['spans'][-1]['length'])
+        for offset in element_offsets:
+            if paragraph_offsets[0] >= offset[0] and paragraph['spans'][0]['offset'] <= offset[1]:
+                return None, None
+
+        markdown_text = ''
+
+        if paragraph['role'] == 'title':
+            markdown_text += f'# {paragraph["content"]}'
+        elif paragraph == "sectionHeading":
+            markdown_text += f'## {paragraph["content"]}'
+        else:
+            markdown_text += f'{paragraph["content"]}'
+        return markdown_text, paragraph_offsets
+
+    def _stitch_paragraphs_elements(self, paragraphs, elements, **kwargs):
+        new_list = paragraphs + elements
+        sorted_new_list = sorted(new_list, key=lambda x: x['offset'][0])
+        return sorted_new_list
+
+    def _convert2md(self, result, **kwargs):
+        paragraphs, tables = result['paragraphs'], result['tables']
+        md_tables = []
+        for table in tables:
+            md, offset = self._table2md(table, requestId=kwargs.get('requestId'))
+            md_tables.append({'content': md, 'offset': offset})
+
+        table_offsets = [element['offset'] for element in md_tables]
+        md_paragraphs = []
+
+        for para in paragraphs:
+            md, offset = self._paragraphs2md(para, table_offsets, requestId=kwargs.get('requestId'))
+            if md is not None:
+                md_paragraphs.append({'content': md, 'offset': offset})
+
+        all_md_elements = self._stitch_paragraphs_elements(md_paragraphs, md_tables, requestId=kwargs.get('requestId'))
+        full_md = '\n\n'.join([record['content'] for record in all_md_elements])
+        return full_md
+
+    def _call_engine(self, image_reader, **kwargs):
+        poller = self.client.begin_analyze_document(
+            CREDENTIALS['azure']['layout']['model'],
+            image_reader
+        )
+        result = poller.result()
+
+        result = convert_nested_complex_obj_to_json(result)
+        md_text = self._convert2md(result, requestId=kwargs.get('requestId'))
+
+        return md_text, result
+
+    def __call__(self, file_bytes):
+        text, raw_response = self._call_engine(file_bytes)
+        return text, raw_response
+
+class PyMuPDF4LLMOCR:
+    def __init__(self):
+        self.engine = 'open-source/pymupdf4llm'
+        self.file_type = 'pdf'
+
+    def _create_document(self, file_bytes, file_type = None):
+        return pymupdf.open(stream = file_bytes, filetype = self.file_type if file_type is None else file_type)
+
+    def __call__(self, file_bytes, file_type = None):
+        document = self._create_document(file_bytes, file_type)
+        response = pymupdf4llm.to_markdown(document)
+        return response, None
+
+if __name__ == '__main__':
+    import sys
+    filepath = sys.argv[1]
+    file_bytes = open(filepath, 'rb').read()
+    ocr = AzureLayoutOCR()
+    text, raw_response = ocr(file_bytes)
+    print(text)

policy_analyser/prompts/analysis.txt

@@ -0,0 +1,143 @@
+Given the markdown content of a customer's health insurance policy, analyse the insurance policy for the customer by applying given rules for specific factors of the policy.
+
+Apply the following rules enclosed in triple backticks on the policy to analyse it.
+Make sure you are consider values for analysis factors on basis of customer's selected insurance plan when multiple plans are described in the policy terms.
+Make sure all factors appear in one of Good, Average or Bad only. No factor should be repeated in more than 1 verdict table
+Note : Top cities = [Mumbai, Delhi, Bangalore, Chennai, Hyderabad, Gurgaon, Pune]
+```
+IF Adults == 1:
+    IF Is_Top_City:
+        IF Sum_Insured >= 2500000:
+            Verdict = "Good"
+        ELSE IF Sum_Insured >= 1000000 AND Sum_Insured < 2500000:
+            Verdict = "Average"
+        ELSE:
+            Verdict = "Bad"
+    ELSE:
+        IF Sum_Insured >= 1000000:
+            Verdict = "Good"
+        ELSE IF Sum_Insured >= 500000 AND Sum_Insured < 1000000:
+            Verdict = "Average"
+        ELSE:
+            Verdict = "Bad"
+
+IF Adults >= 2:
+    IF Children == 0:
+        IF Is_Top_City:
+            IF Sum_Insured >= 5000000:
+                Verdict = "Good"
+            ELSE IF Sum_Insured >= 2500000 AND Sum_Insured < 5000000:
+                Verdict = "Average"
+            ELSE:
+                Verdict = "Bad"
+        ELSE:
+            IF Sum_Insured >= 2500000:
+                Verdict = "Good"
+            ELSE IF Sum_Insured >= 1000000 AND Sum_Insured < 2500000:
+                Verdict = "Average"
+            ELSE:
+                Verdict = "Bad"
+
+    IF Children >= 1:
+        IF Children > 1 OR Is_Top_City:
+            IF Sum_Insured >= 10000000:
+                Verdict = "Good"
+            ELSE IF Sum_Insured >= 5000000 AND Sum_Insured < 10000000:
+                Verdict = "Average"
+            ELSE:
+                Verdict = "Bad"
+        ELSE:
+            IF Sum_Insured >= 5000000:
+                Verdict = "Good"
+            ELSE IF Sum_Insured >= 2500000 AND Sum_Insured < 5000000:
+                Verdict = "Average"
+            ELSE:
+                Verdict = "Bad"
+
+# Room Rent Limit
+IF Room_Rent_Limit > 0:
+    Verdict = "Bad"
+ELSE:
+    Verdict = "Good"
+
+# Deductibles
+IF Deductible > 0:
+    Verdict = "Bad"
+ELSE:
+    Verdict = "Good"
+
+# Sublimits
+IF Sublimits == EMPTY:
+    Verdict = "Good"
+ELSE:
+    Verdict = "Bad"
+
+# Copayment
+IF Copay <= 5:
+    Verdict = "Good"
+ELSE IF Copay > 5 AND Copay <= 10:
+    Verdict = "Average"
+ELSE:
+    Verdict = "Bad"
+
+# Pre-existing Diseases (PED) Waiting Period
+IF PED_Waiting_Period > 0:
+    IF Policy_Age > PED_Waiting_Period:
+        Verdict = "Good"
+    ELSE:
+        Verdict = "Bad"
+ELSE:
+    Verdict = "Good"
+
+# 30-Day Waiting Period
+IF Thirty_Day_Waiting_Period:
+    IF Policy_Age > 1:
+        Verdict = "Good"
+    ELSE:
+        Verdict = "Bad"
+ELSE:
+    Verdict = "Good"
+
+# Specific Illness Waiting Period
+IF Specific_Illness_Waiting_Period > 0:
+    IF Policy_Age > Specific_Illness_Waiting_Period:
+        Verdict = "Good"
+    ELSE:
+        Verdict = "Bad"
+ELSE:
+    Verdict = "Good"
+
+# Maternity Benefits
+IF Maternity_Benefits:
+    Verdict = "Good"
+    IF Maternity_Waiting_Period > 0:
+        IF Policy_Age > Maternity_Waiting_Period:
+            Verdict = "Good"
+        ELSE:
+            Verdict = "Bad"
+    ELSE:
+        Verdict = "Good"
+ELSE:
+    Verdict = "Bad"
+```
+
+Format your response in the following way, to present analysis to customer. Use appropriate language and emojis to portray analysis and verdicts to the customer. Be discrete about rules, do not expose rules to customer but use them to explain reasoning and analysis:
+
+[CUSTOMER_RESPONSE]
+# Our Analysis of your policy [Name of policy] by [Name of insurance company]
+## Good Factors
+| Factor | Your policy | Our Analysis |
+| --- | --- | --- |
+| Sum Insured | Value of sum insred in the policy | Analysis of why sum insured is good based on the given rules |
+
+## Average Factors
+| Factor | Your policy | Our Analysis |
+| --- | --- | --- |
+| Copay | Value of copayment in the policy | Analysis of why copay is average based on the given rules |
+
+## Bad Factors
+| Factor | Your policy | Our Analysis |
+| --- | --- | --- |
+| Deductible | Value of deductible in the policy | Analysis of why deductible is bad based on the given rules |
+
+[/CUSTOMER_RESPONSE]

policy_analyser/prompts/extraction.txt

@@ -0,0 +1,11 @@
+Given markdown content of a policy document, extract given list of entities.
+
+Format your response as a JSON dictionary exactly in the following schema:
+```
+{
+    "Name of entity from entities list" : "Entity value for entity name in `expectedOutputFormat` based on entity description given in `entityDesc`"
+}
+```
+If any numerical or quantitative entities are absent in the document, default entityValue to 0.
+
+Entities:

policy_analyser/prompts/suggest.txt

@@ -0,0 +1,5 @@
+A customer's insurance policy was analysed by you. Using the analysis and Acko's health insurance policy, pitch Acko's policy to the customer by comparing it with their policy on the basis of the analysis and reasoning on the advantages and disadvantages of their policy.
+Format your response in the following format in less than 150 words.
+Format in bullet points with respect to comparing factors and include catchy emojis wherever required:
+
+[POLICY_PITCH] Policy pitch [/POLICY_PITCH]

policy_analyser/rules.py

@@ -0,0 +1,281 @@
+"""
+    Rules for policy analyser
+    @author : Sakshi Tantak
+"""
+
+# Imports
+import json
+from datetime import datetime
+
+from policy_analyser.llm import call_openai
+
+def prepare_payload(extraction):
+    payload = {
+        'Sum Insured (SI)' : 0,
+        'Pre-existing diseases (PED) Waiting period' : 0,
+        '30-Day Waiting Period' : False,
+        'Specific Illness Waiting Period' : 0,
+        'Maternity waiting period' : 0,
+        'Exclusions' : [],
+        'Maternity benefits' : False,
+        'OPD' : 0,
+        'Copay' : 0,
+        'Deductible' : 0,
+        'Daycare treatment' : [],
+        'Free Health checkup' : False,
+        'Restoration benefit' : False,
+        'Sublimits' : [],
+        'Room rent limit (proportionate deduction)' : 100,
+        'Pre & Post Hospitalization' : False,
+        'Domiciliary Cover' : False,
+        'No claim bonus' : 0,
+        'Ambulance cover' : 0,
+        'International coverage' : False,
+        'Dental treatment' : 0,
+        'AYUSH treatment' : False,
+        'Health incentives' : False,
+        'Wellness Services' : False,
+        'Consumables/ Non medical expenses' : False,
+        'Hospital Cash' : False,
+        'Adults' : 0,
+        'Children' : 0,
+        'City' : '',
+        'Is Top City' : True,
+        'Policy Age' : 0
+    }
+    num_adults, num_children, is_top_city = 0, 0, True
+    today = datetime.today()
+    for entity in extraction:
+        if entity['entityName'] in ['Exclusions', 'Daycare treatment', 'Sublimits']:
+            try:
+                value = json.loads(entity['entityValue'])
+                payload[entity['entityName']] = value
+            except:
+                pass
+
+        if entity['entityName'] == "Policy Holder's Details":
+            value = entity['entityValue']
+            city = ''
+            try:
+                value = json.loads(value)
+                if 'city' in value:
+                    city = value['city']
+                    try:
+                        response = call_openai('Does a given city string belong to set of given cities : [Mumbai, Delhi, Bangalore, Chennai, Hyderabad, Gurgaon, Pune]. Answer in true/false only', city)
+                        is_top_city = True if response == 'true' else False
+                    except:
+                        pass
+            except:
+                pass
+            payload['Is Top City'] = is_top_city
+            payload['City'] = city
+
+        if entity['entityName'] == 'Insured Persons details':
+            value = entity['entityValue']
+            try:
+                value = json.loads(value)
+                for person in value:
+                    if 'date_of_birth' in person:
+                        dob = person['date_of_birth']
+                        dob = datetime.strptime(dob, '%d/%m/%Y')
+                        age = (today - dob).days / 365
+                    elif 'age' in person:
+                        age = person['age']
+
+                    if age >= 18:
+                            num_adults += 1
+                    else:
+                        num_children += 1
+            except:
+                num_adults = 1
+            payload['Adults'] = num_adults
+            payload['Children'] = num_children
+
+        if entity['entityName'] == 'Policy Details':
+            try:
+                value = json.loads(entity['entityValue'])
+                if 'policy_start_date' in value:
+                    payload['Policy Age'] = ((today - datetime.strptime(value['policy_start_date'], '%d/%m/%Y')).days / 365) * 12
+            except:
+                pass
+
+        if entity['entityName'] in ['Sum Insured (SI)', 'Pre-existing diseases (PED) Waiting period', 'Specific Illness Waiting Period',
+                                    'Maternity waiting period', 'OPD', 'Copay', 'Deductible', 'No claim bonus', 'Ambulance cover',
+                                    'Dental treatment', 'Room rent limit (proportionate deduction)']:
+            value = entity['entityValue']
+            if isinstance(value, (float, int)):
+                payload[entity['entityName']] = value
+            else:
+                try:
+                    value = float(value)
+                    payload[entity['entityName']] = value
+                except:
+                    pass
+
+        if entity['entityName'] in ['30-Day Waiting Period', 'Maternity benefits', 'Free Health checkup',
+                                    'Restoration benefit', 'Pre & Post Hospitalization', 'Domiciliary Cover',
+                                    'International coverage', 'AYUSH treatment', 'Health incentives', 'Wellness Services',
+                                    'Consumables/ Non medical expenses', 'Hospital Cash']:
+            value = entity['entityValue']
+            if isinstance(value, bool):
+                payload[entity['entityName']] = value
+            else:
+                payload[entity['entityName']] = True if 'true' in value else False
+
+    return payload
+
+def rules(payload):
+    analysis = []
+    if payload['Adults'] == 1:
+        if payload['Is Top City']:
+            if payload['Sum Insured (SI)'] >= 2500000:
+                verdict, reason = 'Good', f'Sum Insured (SI) ({payload["Sum Insured (SI)"]}) > 25L for an adult in {payload["City"]}'
+            if payload['Sum Insured (SI)'] >= 1000000 and payload['Sum Insured (SI)'] < 2500000:
+                verdict, reason = 'Average', f'Sum Insured (SI) ({payload["Sum Insured (SI)"]}) < 25L but > 10L for an adult in {payload["City"]}'
+            if payload['Sum Insured (SI)'] < 1000000:
+                verdict, reason = 'Bad', f'Sum Insured (SI) ({payload["Sum Insured (SI)"]}) < 10L for an adult in {payload["City"]}'
+        else:
+            if payload['Sum Insured (SI)'] >= 1000000:
+                verdict, reason = 'Good', f'Sum Insured (SI) ({payload["Sum Insured (SI)"]}) > 10L for an adult in {payload["City"]}'
+            if payload['Sum Insured (SI)'] >= 500000 and payload['Sum Insured (SI)'] < 1000000:
+                verdict, reason = 'Average', f'Sum Insured (SI) ({payload["Sum Insured (SI)"]}) > 5L but < 10L for an adult in {payload["City"]}'
+            if payload['Sum Insured (SI)'] < 500000:
+                verdict, reason = 'Bad', f'Sum Insured (SI) ({payload["Sum Insured (SI)"]}) < 5L for an adult in {payload["City"]}'
+
+    if payload['Adults'] >= 2:
+        if payload['Children'] == 0:
+            if payload['Is Top City']:
+                if payload['Sum Insured (SI)'] >= 5000000:
+                    verdict, reason = 'Good', f'Sum Insured (SI) ({payload["Sum Insured (SI)"]}) > 50L for {payload["Adults"]} adults in {payload["City"]}'
+                if payload['Sum Insured (SI)'] >= 2500000 and payload['Sum Insured (SI)'] < 5000000:
+                    verdict, reason = 'Average', f'Sum Insured (SI) ({payload["Sum Insured (SI)"]}) > 25L but < 50L for {payload["Adults"]} adults in {payload["City"]}'
+                if payload['Sum Insured (SI)'] < 2500000:
+                    verdict, reason = 'Bad', f'Sum Insured (SI) ({payload["Sum Insured (SI)"]}) < 25L for {payload["Adults"]} adults in {payload["City"]}'
+            else:
+                if payload['Sum Insured (SI)'] >= 2500000:
+                    verdict, reason = 'Good', f'Sum Insured (SI) ({payload["Sum Insured (SI)"]}) > 25L for {payload["Adults"]} adults in {payload["City"]}'
+                if payload['Sum Insured (SI)'] >= 1000000 and payload['Sum Insured (SI)'] < 2500000:
+                    verdict, reason = 'Average', f'Sum Insured (SI) ({payload["Sum Insured (SI)"]}) > 10L but < 25L for {payload["Adults"]} adults in {payload["City"]}'
+                if payload['Sum Insured (SI)'] < 1000000:
+                    verdict, reason = 'Bad', f'Sum Insured (SI) ({payload["Sum Insured (SI)"]}) < 10L for {payload["Adults"]} adults in {payload["City"]}'
+
+        if payload['Children'] >= 1:
+            if payload['Children'] > 1 or payload['Is Top City']:
+                if payload['Sum Insured (SI)'] >= 10000000:
+                    verdict, reason = 'Good', f'Sum Insured (SI) ({payload["Sum Insured (SI)"]}) > 1 CR for {payload["Adults"]} adults & {payload["Children"]} children in {payload["City"]}'
+                if payload['Sum Insured (SI)'] >= 5000000 and payload['Sum Insured (SI)'] < 10000000:
+                    verdict, reason = 'Average', f'Sum Insured (SI) ({payload["Sum Insured (SI)"]}) > 50L but < 1 CR for {payload["Adults"]} adults & {payload["Children"]} children in {payload["City"]}'
+                if payload['Sum Insured (SI)'] < 5000000:
+                    verdict, reason = 'Bad', f'Sum Insured (SI) ({payload["Sum Insured (SI)"]}) < 50L for {payload["Adults"]} adults & {payload["Children"]} children in {payload["City"]}'
+            else:
+                if payload['Sum Insured (SI)'] >= 5000000:
+                    verdict, reason = 'Good', f'Sum Insured (SI) ({payload["Sum Insured (SI)"]}) > 50L for {payload["Adults"]} adults & {payload["Children"]} children in {payload["City"]}'
+                if payload['Sum Insured (SI)'] >= 2500000 and payload['Sum Insured (SI)'] < 5000000:
+                    verdict, reason = 'Average', f'Sum Insured (SI) ({payload["Sum Insured (SI)"]}) > 25L but < 50L for {payload["Adults"]} adults & {payload["Children"]} children in {payload["City"]}'
+                if payload['Sum Insured (SI)'] < 2500000:
+                    verdict, reason = 'Bad', f'Sum Insured (SI) ({payload["Sum Insured (SI)"]}) < 25L for {payload["Adults"]} adults & {payload["Children"]} children in {payload["City"]}'
+        analysis.append(
+            {
+                'factor' : 'Sum Insured (SI)',
+                'verdict' : verdict,
+                'reason' : reason
+            }
+        )
+   
+    if payload['Room rent limit (proportionate deduction)'] > 0:
+        verdict, reason = 'Bad', f'There is cap of {payload["Room rent limit (proportionate deduction)"]} on room rent'
+    else:
+        verdict, reason = 'Good', 'There is no cap on room rent'
+    analysis.append({'factor' : 'Room rent limit (proportionate deduction)', 'verdict' : verdict, 'reason' : reason})
+
+    if payload['Deductible'] > 0:
+        verdict, reason = 'Bad', f'There is a deductible of {payload["Deductible"]}'
+    else:
+        verdict, reason = 'Good', 'No deductible'
+    analysis.append({'factor' : 'Deductible', 'verdict' : verdict, 'reason' : reason})
+
+    if payload['Sublimits'] == []:
+        verdict, reason = 'Good', 'There are no sublimits on any treatments or diseases'
+    else:
+        verdict = 'Bad'
+        sublimits_str = '\n'.join([f'{sublimit["sublimit_name"]}: {sublimit["sublimit_value"]}' for sublimit in payload['Sublimits']])
+        reason = f'Following sublimits were found in your policy:\n{sublimits_str}'
+    analysis.append({'factor' :'Sublimits', 'verdict' : verdict, 'reason' : reason})
+
+    if payload['Copay'] == 0 and payload['Copay'] <= 5:
+        verdict, reason = 'Good', f'Copayment ({payload["Copay"]}) < 5%'
+    elif payload['Copay'] > 5 and payload['Copay'] <= 10:
+        verdict, reason = 'Average', f'Copayment ({payload["Copay"]}) > 5% but < 10%'
+    elif payload['Copay'] > 10:
+        verdict, reason = 'Bad', f'Copayment (({payload["Copay"]})) > 10%'
+    analysis.append({'factor' : 'Copay', 'verdict' : verdict, 'reason' : reason})
+
+    if payload['Pre-existing diseases (PED) Waiting period'] > 0:
+        if payload['Policy Age'] > payload['Pre-existing diseases (PED) Waiting period']:
+            verdict, reason = 'Good', f'Your policy has a waiting period of {payload["Pre-existing diseases (PED) Waiting period"]} months on pre-existing diseases but the waiting period has expired as of today'
+        else:
+            verdict, reason = 'Bad', f'Your policy has a waiting period of {payload["Pre-existing diseases (PED) Waiting period"]} months on pre-existing diseases which is yet to expire'
+    else:
+        verdict, reason = 'Good', f'Your policy has no waiting period on pre-existing diseases'
+    analysis.append({'factor' : 'Pre-existing diseases (PED) Waiting period', 'verdict' : verdict, 'reason' : reason})
+
+    if payload['30-Day Waiting Period']:
+        if payload['Policy Age'] > 1:
+            verdict, reason = 'Good', f'Your policy has a 30 day waiting period but it has expired as of today'
+        else:
+            verdict, reason = 'Bad', f'Your policy has a 30 day waiting period which is yet to expire'
+    else:
+        verdict, reason = 'Good', f'Your policy has no 30 day waiting period'
+    analysis.append({'factor' : '30-Day Waiting Period', 'verdict' : verdict, 'reason' : reason})
+
+    if payload['Specific Illness Waiting Period'] > 0:
+        if payload['Policy Age'] > payload['Specific Illness Waiting Period']:
+            verdict, reason = 'Good', f'Your policy has a waiting period of {payload["Specific Illness Waiting Period"]} on specific illnesses but the waiting period has expired as of today'
+        else:
+            verdict, reason = 'Bad', f'Your policy has a waiting period of {payload["Specific Illness Waiting Period"]} on specific illnesses which is yet to expire'
+    else:
+        verdict, reason = 'Good', f'Your policy has no waiting period any on specific illnesses'
+    analysis.append({'factor' : 'Specific Illness Waiting Period', 'verdict' : verdict, 'reason' : reason})
+
+    if payload['Maternity benefits']:
+        analysis.append(
+            {
+                'factor' : 'Maternity benefits',
+                'verdict' : 'Good',
+                'reason' : 'Maternity benefits present, check waiting period'
+            }
+        )
+        if payload['Maternity waiting period'] > 0:
+            if payload['Policy Age'] > payload['Maternity waiting period']:
+                verdict, reason = 'Good', f'Your policy has a waiting period of {payload["Maternity waiting period"]} for maternity cases but it has expired as of today'
+            else:
+                verdict, reason = 'Bad', f'Your policy has a waiting period of {payload["Maternity waiting period"]} for maternity cases which is yet to expire'
+        else:
+            verdict, reason = 'Good', f'Your policy has a no waiting period for maternity cases'
+        analysis.append({'factor' : 'Maternity waiting period', 'verdict' : verdict, 'reason' : reason})
+    else:
+        analysis.append(
+            {
+                'factor' : 'Maternity benefits',
+                'verdict' : 'Bad',
+                'reason' : 'No maternity benefits'
+            }
+        )
+
+    return analysis
+
+if __name__ == '__main__':
+    import json
+    import glob
+    dirpath = '/Users/sakshi.tantak/Downloads/Porting Documents/testing-data/sample/poc'
+    for file in glob.glob(f'{dirpath}/*.analysis.json'):
+        json_data = json.load(open(file))
+        payload = prepare_payload(json_data[1]['response']['processed'])
+        json_data.append({
+            'stage' : 'POST_PROCESS',
+            'response' : payload,
+            'time' : 0
+        })
+        # print(json_data)
+        with open(file, 'w') as f:
+            json.dump(json_data, f, indent = 4)

styles.py

@@ -0,0 +1,123 @@
+import streamlit as st
+
+def apply_custom_styles():
+    st.markdown("""
+        <style>
+        .stApp {
+            max-width: 1200px;
+            margin: 0 auto;
+            background: linear-gradient(135deg, #f5f7fa 0%, #e4e9f2 100%);
+            background-attachment: fixed;
+            min-height: 100vh;
+        }
+        .upload-container {
+            border: 2px dashed #0066cc;
+            border-radius: 10px;
+            padding: 20px;
+            text-align: center;
+            margin: 20px 0;
+            background: rgba(255, 255, 255, 0.9);
+            backdrop-filter: blur(5px);
+        }
+        .factor-card {
+            background-color: rgba(255, 255, 255, 0.95);
+            padding: 20px;
+            border-radius: 10px;
+            box-shadow: 0 4px 6px rgba(0, 0, 0, 0.1);
+            margin: 10px 0;
+            backdrop-filter: blur(5px);
+            height: 100%;
+        }
+        .good-factor {
+            border-left: 4px solid #28a745;
+        }
+        .average-factor {
+            border-left: 4px solid #ffc107;
+        }
+        .bad-factor {
+            border-left: 4px solid #dc3545;
+        }
+        .header-container {
+            padding: 2rem 0;
+            margin-bottom: 2rem;
+            background: linear-gradient(90deg, #0066cc 0%, #0099ff 100%);
+            color: white;
+            border-radius: 10px;
+            text-align: center;
+            box-shadow: 0 4px 6px rgba(0, 0, 0, 0.1);
+        }
+        .detailed-factor {
+            padding: 15px;
+            border-radius: 8px;
+            margin: 10px 0;
+            background: rgba(255, 255, 255, 0.9);
+            border-left: 4px solid #666;
+        }
+        .detailed-factor.good {
+            border-left-color: #28a745;
+            background: rgba(40, 167, 69, 0.1);
+        }
+        .detailed-factor.average {
+            border-left-color: #ffc107;
+            background: rgba(255, 193, 7, 0.1);
+        }
+        .detailed-factor.bad {
+            border-left-color: #dc3545;
+            background: rgba(220, 53, 69, 0.1);
+        }
+        .comparison-table {
+            background: white;
+            border-radius: 10px;
+            box-shadow: 0 4px 6px rgba(0, 0, 0, 0.1);
+            margin: 20px 0;
+        }
+        </style>
+    """, unsafe_allow_html=True)
+
+def show_factor_section(title, factors, color):
+    if factors:
+        st.markdown(f"""
+            <div class="factor-card {color}-factor">
+                <h3 style="color: #333;">{title}</h3>
+                <ul style="list-style-type: none; padding-left: 0;">
+                    {"".join(f'<li style="margin: 10px 0; padding: 10px; background: rgba(248, 249, 250, 0.8); border-radius: 5px;">{factor}</li>' for factor in factors)}
+                </ul>
+            </div>
+        """, unsafe_allow_html=True)
+
+def show_detailed_factors(good_factors, average_factors, bad_factors):
+    for factor in good_factors:
+        name, explanation = factor.split(':', 1)
+        st.markdown(f"""
+            <div class="detailed-factor good">
+                <strong>{name}</strong>
+                <p style="margin: 5px 0 0 0; color: #666;">{explanation}</p>
+            </div>
+        """, unsafe_allow_html=True)
+
+    for factor in average_factors:
+        name, explanation = factor.split(':', 1)
+        st.markdown(f"""
+            <div class="detailed-factor average">
+                <strong>{name}</strong>
+                <p style="margin: 5px 0 0 0; color: #666;">{explanation}</p>
+            </div>
+        """, unsafe_allow_html=True)
+
+    for factor in bad_factors:
+        name, explanation = factor.split(':', 1)
+        st.markdown(f"""
+            <div class="detailed-factor bad">
+                <strong>{name}</strong>
+                <p style="margin: 5px 0 0 0; color: #666;">{explanation}</p>
+            </div>
+        """, unsafe_allow_html=True)
+
+def show_factor_summary(summary, verdict, sentiment_title):
+    if len(summary) > 0:
+        st.markdown(f"""
+                <div class="detailed-factor {verdict}">
+                    <strong>{sentiment_title}</strong>
+                    <p style="margin: 5px 0 0 0; color: #666;">{summary}</p>
+                </div>
+            """, unsafe_allow_html=True)

ui.py

@@ -0,0 +1,127 @@
+"""
+    Rules for Policy Analyser
+"""
+
+# Imports
+import os
+import glob
+import json
+from datetime import datetime
+import base64
+
+import openai
+import streamlit as st
+import pandas as pd
+
+from policy_analyser.analyse import analyse
+
+st.set_page_config('Policy Analyser', '🧐', layout = 'wide')
+
+# def call_openai(system_prompt, document, seed = 42):
+#     messages = [{'role' : 'system', 'content' : system_prompt},
+#                 {'role' : 'user', 'content' : document}]
+#     response = openai.ChatCompletion.create(
+#             engine = 'AskoGPT4-1106',
+#             messages = messages,
+#             seed = seed,
+#             temperature = 0.3,
+#             api_key = 'a033560cc39647da989fcce2910f6e84',
+#             api_version = '2023-07-01-preview',
+#             api_type = 'azure',
+#             api_base = 'https://asko-v1.openai.azure.com/'
+#         )
+#     return response.choices[0].message.content
+
+
+def displayPDF(file):
+    # Opening file from file path
+    if isinstance(file, str):
+        file_bytes = open(file, 'rb').read()
+    else:
+        file_bytes = file
+    # with open(file, "rb") as f:
+    base64_pdf = base64.b64encode(file_bytes).decode('utf-8')
+
+    # Embedding PDF in HTML
+    pdf_display = F'<embed src="data:application/pdf;base64,{base64_pdf}" width="700" height="1000" type="application/pdf">'
+
+    # Displaying File
+    st.markdown(pdf_display, unsafe_allow_html=True)
+
+def view_saved_results():
+    dirpath = '/Users/sakshi.tantak/Downloads/Porting Documents/testing-data/sample/poc'
+    files = [file for file in os.listdir(dirpath) if file.endswith('.analysis.json')]
+    file = st.sidebar.selectbox('Select Result to view', options = files)
+    if file is not None:
+        file = os.path.join(dirpath, file)
+        pdf_path = file.replace('.analysis.json', '.pdf')
+        displayPDF(pdf_path)
+        analysis = json.load(open(file))
+        if len(analysis) > 0:
+            for stage in analysis:
+                if stage['stage'] == 'EXTRACTION':
+                    st.sidebar.json(stage['response']['processed'])
+                if stage['stage'] == 'POST_PROCESS':
+                    st.sidebar.json(stage['response'])
+                if stage['stage'] == 'ANALYSE':
+                    df = pd.DataFrame.from_records(stage['response'])
+                    for verdict in ['Good', 'Average', 'Bad']:
+                        df_tmp = df.loc[df['verdict'] == verdict]
+                        if len(df_tmp) > 0:
+                            st.sidebar.markdown(f'**{verdict}**')
+                            st.sidebar.table(df_tmp)
+
+def run():
+    file = st.sidebar.file_uploader('Upload PDF')
+    if file is not None:
+        file_bytes = file.getvalue()
+        displayPDF(file_bytes)
+        analysis = analyse(file_bytes)
+        st.json(analysis)
+        for stage in analysis:
+            if stage['stage']['ANALYSE']:
+                df = pd.DataFrame(stage['response'])
+                for verdict in ['Good', 'Average', 'Bad']:
+                        df_tmp = df.loc[df['verdict'] == verdict]
+                        if len(df_tmp) > 0:
+                            st.sidebar.markdown(f'**{verdict}**')
+                            st.sidebar.table(df_tmp)
+
+def validate_results():
+    dirpath = '/Users/sakshi.tantak/Downloads/Porting Documents/testing-data/sample/poc'
+    file = st.sidebar.selectbox('Select file to validation', options = [file for file in os.listdir(dirpath) if file.endswith('.analysis.json')])
+    if file is not None:
+        filepath = os.path.join(dirpath, file)
+        json_data = json.load(open(filepath))
+        if len(json_data) > 0:
+            for stage in json_data:
+                if stage['stage'] == 'EXTRACTION':
+                    entities = stage['response']['processed']
+                    for entity in entities:
+                        entity.update(
+                            {'entityValueQC' : entity['entityValue'], 'isRight' : False, 'QCRemarks' : ''}
+                        )
+                    df = pd.DataFrame.from_records(entities)
+                    df = df[['isRight', 'entityName', 'entityValue', 'entityValueQC', 'QCRemarks']]
+                    df = df.astype({'entityValueQC' : str})
+                    df = st.data_editor(df)
+                    displayPDF(filepath.replace('.analysis.json', '.pdf'))
+                    print(df)
+            if st.button('Save?'):
+                df.to_csv(filepath.replace('.analysis.json', '.qc-entities.csv'), index = False)
+
+
+def main():
+    view_results_page = st.Page(view_saved_results, title = 'View Save Results')
+    run_page = st.Page(run, title = 'Run your PDF')
+    qc = st.Page(validate_results, title = 'QC')
+    pages = st.navigation(
+        {
+            'View' : [view_results_page, qc],
+            'Run & Analyse' : [run_page]
+        }
+    )
+    pages.run()
+
+if __name__ == '__main__':
+    main()

utils.py

@@ -0,0 +1,111 @@
+import base64
+import json
+import requests
+from typing import Dict, List, Tuple
+import streamlit as st
+
+def mock_api_call(pdf_bytes: bytes) -> List:
+    """
+    Simulates an API call for policy analysis.
+    In production, this would make a real API call.
+    """
+    # Mock response based on the provided sample
+    return [{
+        "stage": "ANALYSE",
+        "response": [
+            {
+                "factor": "Room rent limit",
+                "verdict": "Bad",
+                "reason": "There is cap of 100 on room rent"
+            },
+            {
+                "factor": "Deductible",
+                "verdict": "Good",
+                "reason": "No deductible"
+            },
+            {
+                "factor": "Copay",
+                "verdict": "Good",
+                "reason": "Copayment (0.0) < 5%"
+            }
+        ]
+    },
+    {
+        "stage" : "ANALYSIS_SUMMARY",
+        "response" : {
+            "Good" : "This was great!",
+            # "Average" : "This was okay",
+            "Bad" : "This was meh :/"
+        }
+    }
+    ]
+
+def parse_analysis_response(response: List) -> Tuple[List[str], List[str], List[str]]:
+    """
+    Parses the API response and extracts categorized factors with their reasons.
+    Handles the verdict-based factor format.
+    """
+    try:
+        # Find the analysis stage in the response list
+        analysis_item = next(
+            (item for item in response if item.get("stage") == "ANALYSE"),
+            None
+        )
+
+        if not analysis_item:
+            st.error("No analysis data found in the response")
+            return [], [], []
+
+        # Get the response list from analysis item
+        analysis_list = analysis_item.get("response", [])
+
+        if not analysis_list or not isinstance(analysis_list, list):
+            st.error("Invalid analysis response format")
+            return [], [], []
+
+        # Initialize categorized factors
+        good_factors = []
+        average_factors = []
+        bad_factors = []
+
+        # Categorize factors based on verdict
+        for item in analysis_list:
+            factor_text = f"{item.get('factor')}: {item.get('reason')}"
+            verdict = item.get('verdict', '').lower()
+
+            if verdict == 'good':
+                good_factors.append(factor_text)
+            elif verdict == 'average':
+                average_factors.append(factor_text)
+            elif verdict == 'bad':
+                bad_factors.append(factor_text)
+
+        return good_factors, average_factors, bad_factors
+    except Exception as e:
+        st.error(f"Error parsing analysis response: {str(e)}")
+        return [], [], []
+
+def validate_pdf(pdf_bytes: bytes) -> bool:
+    """
+    Validates the uploaded PDF file.
+    """
+    if not pdf_bytes:
+        return False
+
+    # Check file signature for PDF (%PDF-)
+    return pdf_bytes.startswith(b'%PDF-')
+
+def displayPDF(file):
+    # Opening file from file path
+    if isinstance(file, str):
+        file_bytes = open(file, 'rb').read()
+    else:
+        file_bytes = file
+    # with open(file, "rb") as f:
+    base64_pdf = base64.b64encode(file_bytes).decode('utf-8')
+
+    # Embedding PDF in HTML
+    pdf_display = F'<embed src="data:application/pdf;base64,{base64_pdf}" width="700" height="1000" type="application/pdf">'
+
+    # Displaying File
+    st.markdown(pdf_display, unsafe_allow_html=True)