app.py

import easyocr as ocr  #OCR
import streamlit as st  #Web App
from PIL import Image #Image Processing
import numpy as np #Image Processing 
# To read the PDF
import PyPDF2
# To analyze the PDF layout and extract text
from pdfminer.high_level import extract_pages, extract_text
from pdfminer.layout import LTTextContainer, LTChar, LTRect, LTFigure
# To extract text from tables in PDF
import pdfplumber
# To extract the images from the PDFs
from PIL import Image
from pdf2image import convert_from_path
# To perform OCR to extract text from images
import pytesseract
# To remove the additional created files
import os
import tiktoken
import streamlit as st
import pandas as pd
from io import StringIO
import time
import json
import openai
from langchain.prompts import PromptTemplate
from langchain.llms import OpenAI
from langchain.chat_models import ChatOpenAI
from llama_index.llms import OpenAI
# Create function to extract text
from langchain.prompts import PromptTemplate
from langchain.prompts.chat import (
    ChatPromptTemplate,
    SystemMessagePromptTemplate,
    AIMessagePromptTemplate,
    HumanMessagePromptTemplate,
)



def text_extraction(element):
    # Extracting the text from the in line text element
    line_text = element.get_text()

    # Find the formats of the text
    # Initialize the list with all the formats appeared in the line of text
    line_formats = []
    for text_line in element:
        if isinstance(text_line, LTTextContainer):
            # Iterating through each character in the line of text
            for character in text_line:
                if isinstance(character, LTChar):
                    # Append the font name of the character
                    #line_formats.append(character.fontname)
                    # Append the font size of the character
                    #line_formats.append(character.size)
                    line_formats.append("")

    # Find the unique font sizes and names in the line
    format_per_line = list(set(line_formats))

    # Return a tuple with the text in each line along with its format
    return (line_text, format_per_line)

# Extracting tables from the page

def extract_table(pdf_path, page_num, table_num):
    # Open the pdf file
    pdf = pdfplumber.open(pdf_path)
    # Find the examined page
    table_page = pdf.pages[page_num]
    # Extract the appropriate table
    table = table_page.extract_tables()[table_num]

    return table

# Convert table into appropriate fromat
def table_converter(table):
    table_string = ''
    # Iterate through each row of the table
    for row_num in range(len(table)):
        row = table[row_num]
        # Remove the line breaker from the wrapted texts
        cleaned_row = [item.replace('\n', ' ') if item is not None and '\n' in item else 'None' if item is None else item for item in row]
        # Convert the table into a string
        table_string+=('|'+'|'.join(cleaned_row)+'|'+'\n')
    # Removing the last line break
    table_string = table_string[:-1]
    return table_string

# Create a function to check if the element is in any tables present in the page
def is_element_inside_any_table(element, page ,tables):
    x0, y0up, x1, y1up = element.bbox
    # Change the cordinates because the pdfminer counts from the botton to top of the page
    y0 = page.bbox[3] - y1up
    y1 = page.bbox[3] - y0up
    for table in tables:
        tx0, ty0, tx1, ty1 = table.bbox
        if tx0 <= x0 <= x1 <= tx1 and ty0 <= y0 <= y1 <= ty1:
            return True
    return False

# Function to find the table for a given element
def find_table_for_element(element, page ,tables):
    x0, y0up, x1, y1up = element.bbox
    # Change the cordinates because the pdfminer counts from the botton to top of the page
    y0 = page.bbox[3] - y1up
    y1 = page.bbox[3] - y0up
    for i, table in enumerate(tables):
        tx0, ty0, tx1, ty1 = table.bbox
        if tx0 <= x0 <= x1 <= tx1 and ty0 <= y0 <= y1 <= ty1:
            return i  # Return the index of the table
    return None



# Create a function to crop the image elements from PDFs
def crop_image(element, pageObj):
    # Get the coordinates to crop the image from PDF
    [image_left, image_top, image_right, image_bottom] = [element.x0,element.y0,element.x1,element.y1]
    # Crop the page using coordinates (left, bottom, right, top)
    pageObj.mediabox.lower_left = (image_left, image_bottom)
    pageObj.mediabox.upper_right = (image_right, image_top)
    # Save the cropped page to a new PDF
    cropped_pdf_writer = PyPDF2.PdfWriter()
    cropped_pdf_writer.add_page(pageObj)
    # Save the cropped PDF to a new file
    with open('cropped_image.pdf', 'wb') as cropped_pdf_file:
        cropped_pdf_writer.write(cropped_pdf_file)

# Create a function to convert the PDF to images
def convert_to_images(input_file,):
    images = convert_from_path(input_file)
    image = images[0]
    output_file = 'PDF_image.png'
    image.save(output_file, 'PNG')

# Create a function to read text from images
def image_to_text(image_path):
    # Read the image
    img = Image.open(image_path)
    # Extract the text from the image
    text = pytesseract.image_to_string(img)
    return text



#title

st.title("Extract Loan details from PDF or Image")

#subtitle
st.markdown("## Loan detail extractor using `OpenAI` and `streamlit` -  hosted on 🤗 Spaces")

st.markdown("Link to the app - [PDF to extract loadn details app on 🤗 Spaces](https://huggingface.co/spaces/ravi259/Loan-details-extraction-app)")

#image uploader
file_name = st.file_uploader(label = "Upload your PDF file here",type=['pdf','png','jpg','jpeg'])
print(file_name)

def read_file_get_prompts(file_name):
    if file_name is not None:
        st.write(file_name.name)

        file_details = {"FileName":file_name.name,"FileType":file_name.type}
        #st.write(file_details)
        # Find the PDF path
        pdf_path = file_name # '/content/data/'+file_name+".pdf"
        #st.write(pdf_path)
        #text_file_path = '/content/data/'+file_name+".txt"
        # Create a pdf file object
        #pdfFileObj = open(+pdf_path, 'rb')
        # Create a pdf reader object
        pdfReaded = PyPDF2.PdfReader(file_name)

        # Create the dictionary to extract text from each image
        text_per_page = {}
        # Create a boolean variable for image detection
        image_flag = False

        number_of_pages = len(list(extract_pages(file_name)))
        result = ''

        # We extract the pages from the PDF
        for pagenum, page in enumerate(extract_pages(file_name)):

            # Initialize the variables needed for the text extraction from the page
            pageObj = pdfReaded.pages[pagenum]
            page_text = []
            line_format = []
            text_from_images = []
            text_from_tables = []
            page_content = []
            # Initialize the number of the examined tables
            table_in_page= -1
            # Open the pdf file
            pdf = pdfplumber.open(pdf_path)
            # Find the examined page
            page_tables = pdf.pages[pagenum]
            # Find the number of tables in the page
            tables = page_tables.find_tables()
            if len(tables)!=0:
                table_in_page = 0

            # Extracting the tables of the page
            for table_num in range(len(tables)):
                # Extract the information of the table
                table = extract_table(pdf_path, pagenum, table_num)
                # Convert the table information in structured string format
                table_string = table_converter(table)
                # Append the table string into a list
                text_from_tables.append(table_string)

            # Find all the elements
            page_elements = [(element.y1, element) for element in page._objs]
            # Sort all the element as they appear in the page
            page_elements.sort(key=lambda a: a[0], reverse=True)


            # Find the elements that composed a page
            for i,component in enumerate(page_elements):
                # Extract the element of the page layout
                element = component[1]

                # Check the elements for tables
                if table_in_page == -1:
                    pass
                else:
                    if is_element_inside_any_table(element, page ,tables):
                        table_found = find_table_for_element(element,page ,tables)
                        if table_found == table_in_page and table_found != None:
                            page_content.append(text_from_tables[table_in_page])
                            #page_text.append('table')
                            #line_format.append('table')
                            table_in_page+=1
                        # Pass this iteration because the content of this element was extracted from the tables
                        continue

                if not is_element_inside_any_table(element,page,tables):

                    # Check if the element is text element
                    if isinstance(element, LTTextContainer):
                        # Use the function to extract the text and format for each text element
                        (line_text, format_per_line) = text_extraction(element)
                        # Append the text of each line to the page text
                        page_text.append(line_text)
                        # Append the format for each line containing text
                        line_format.append(format_per_line)
                        page_content.append(line_text)


                    # Check the elements for images
                    if isinstance(element, LTFigure):
                        # Crop the image from PDF
                        crop_image(element, pageObj)
                        # Convert the croped pdf to image
                        convert_to_images('cropped_image.pdf')
                        # Extract the text from image
                        image_text = image_to_text('PDF_image.png')
                        image_text = "" # removed to remove the errors with image
                        text_from_images.append(image_text)
                        page_content.append(image_text)
                        # Add a placeholder in the text and format lists
                        #page_text.append('image')
                        #line_format.append('image')
                        # Update the flag for image detection
                        image_flag = True


            # Create the key of the dictionary
            dctkey = 'Page_'+str(pagenum)

            # Add the list of list as value of the page key
            #text_per_page[dctkey]= [page_text, line_format, text_from_images,text_from_tables, page_content]
            text_per_page[dctkey]= [page_text, text_from_images,text_from_tables, page_content]
            #result = result.join(page_text).join(line_format).join(text_from_images).join(text_from_tables).join(page_content)


        result = " "
        for t in range(number_of_pages):
            page = 'Page_'+str(t)
            #result = result.join(map(str, text_per_page[page]))
            for q in range(len(text_per_page[page])):
                #print(f"{''.join(map(str, text_per_page[page][q]))}")
                result = result + f"{''.join(map(str, text_per_page[page][q]))}"

    return result

def create_dataframe_from_text(text):
    data_dict = json.loads(text)
    
    # Convert the dictionary to a Pandas DataFrame
    df = pd.DataFrame([data_dict])
    
    return df

def create_dataframe_from_text_2(text):
    # Convert text to a Python dictionary
    data_dict = json.loads(text)
    
    # Extract the 'transactions' data
    transactions_data = data_dict.get('transactions', [])
    
    # Convert the 'transactions' list of dictionaries to a Pandas DataFrame
    df = pd.DataFrame(transactions_data)
    
    return df

template="You are a helpful assistant that annalyses a bank statement annd provides answers"
system_message_prompt = SystemMessagePromptTemplate.from_template(template)
human_template= "{text}"
human_message_prompt = HumanMessagePromptTemplate.from_template(human_template)

prompt_1 = """Loan status include details like Total Outstanding or Total Loan Amount,
Start Month, Tenure in Months, Rate of interest and EMI.

Extract the details from text from triple tick marks and return a JSON object ONLY with keys Total Loan Amount as Number, Start Month in format mmm-yyyy, Tenure in Months, ROI, EMI as Number.

Only return the JSON.
"""


prompt_template_1 = PromptTemplate.from_template(
prompt_1 +  "```{loan_data} ```"
)
#prompt_template_1.format(loan_data=result.lower())


prompt_2_temp = """Loan transaction details are the information of transaction happened during a period and contains
details like Month, EMI as monthly amount paid, Payment status as Paid or Unpaid, outstanding Balance after payment of EMI.

Return a table of ALL transactions in a pandas data frame object

1. COMBININNG monthly transactions for each month
2. WITHOUT missing rows for ANY month
3. with columns Month, EMI Paid, Payment Status, Interest Amount, Principal Amount, Balance Amount

from text in triple tick marks.

Just return JSON object with keys Month,  EMI Paid, Payment Status, Interest Amount, Principal Amount, Balance Amount
ONLY return the JSON.
"""

prompt_2 = """Loan transaction details are the information of transaction happened during a period and contains
details like Month, EMI as monthly amount paid, Payment status as Paid or Unpaid,  Interest Amount paid, outstanding Balance after payment of EMI.

Return a JSON object called `transactions` by

1. COMBININNG monthly transactions for each month
2. WITHOUT missing rows for ANY month
3. and get data for all the months
3. with keys Month, EMI Paid, Payment Status, Interest Amount, Principal Amount, Balance Amount

from text in triple tick marks.

ONLY return the JSON.
"""

prompt_template_2 = PromptTemplate.from_template(
    prompt_2 + "```{response_1}{loan_data} ```"
    #prompt_2 + "```{loan_data} ```"
)
#prompt_template_2.format(response_1 =response_1, loan_data=result.lower())
if 'response' not in st.session_state:
    st.session_state.stage = ''

def set_stage(response):
    st.session_state.response = response


if st.button('Get Loan Details',type="primary"):
    with st.spinner("🤖 Operation in progress. Please wait! 🤖 "):
        result = read_file_get_prompts(file_name)
        
        #st.write(result.lower())
        response_1 = OpenAI().complete(prompt_template_1.format(loan_data=result.lower()))
        st.table(create_dataframe_from_text(response_1.text))
        set_stage(response_1.text)
        
        st.balloons()

async def get_completion(prompt_template, response="", data=""):
    # Other code...
    # Wait for completion of OpenAI().complete()
    completion_result = await OpenAI().complete(prompt_template.format(response = st.session_state.response, loan_data=data.lower()))
    return completion_result


if st.button('Get Loan Transactions', type="primary"):
    with st.spinner("🤖 Operation in progress. Please wait! 🤖 "):
        result = read_file_get_prompts(file_name)
        #st.write(result)
        
        #st.write(result.lower())
        #response_1 = get_completion(prompt_template_1, "",  result)
        response_1_text = st.session_state.response
        response_2 = OpenAI().complete(prompt_template_2.format(response_1=response_1_text, loan_data=result.lower()))
        #st.write(response_2)
        df = create_dataframe_from_text_2(response_2.text)
        st.write(df.size)
        st.table(create_dataframe_from_text_2(response_2.text))

        st.balloons()

st.caption("Made with ❤️ by @ravi259. Credits to 🤗 Spaces for Hosting this ")