Upload 3 files

app.py

@@ -0,0 +1,245 @@
+import os # Included to Python
+from openai import OpenAI # OpenAI official Python package
+from IPython.display import Audio # Included to Python
+
+## supporting functions
+import base64, textwrap, time, openai, io
+from PIL import Image  # Pillow image library
+import tempfile
+from pdf2image import convert_from_path
+import gradio as gr
+from gradio_pdf import PDF
+
+from dotenv import load_dotenv
+
+load_dotenv()
+
+openai_api_key = os.getenv('OPENAI_API_KE')
+client = OpenAI(
+    api_key=openai_api_key)
+
+
+
+
+def resize_image(image, max_dimension):
+    width, height = image.size
+
+    # Check if the image has a palette and convert it to true color mode
+    if image.mode == "P":
+        if "transparency" in image.info:
+            image = image.convert("RGBA")
+        else:
+            image = image.convert("RGB")
+
+    if width > max_dimension or height > max_dimension:
+        if width > height:
+            new_width = max_dimension
+            new_height = int(height * (max_dimension / width))
+        else:
+            new_height = max_dimension
+            new_width = int(width * (max_dimension / height))
+        image = image.resize((new_width, new_height), Image.LANCZOS)
+        
+        timestamp = time.time()
+
+    return image
+
+def convert_to_png(image):
+    with io.BytesIO() as output:
+        image.save(output, format="PNG")
+        return output.getvalue()
+
+def process_image(path, max_size):
+    with Image.open(path) as image:
+        width, height = image.size
+        mimetype = image.get_format_mimetype()
+        if mimetype == "image/png" and width <= max_size and height <= max_size:
+            with open(path, "rb") as f:
+                encoded_image = base64.b64encode(f.read()).decode('utf-8')
+                return (encoded_image, max(width, height))  # returns a tuple consistently
+        else:
+            resized_image = resize_image(image, max_size)
+            png_image = convert_to_png(resized_image)
+            return (base64.b64encode(png_image).decode('utf-8'),
+                    max(width, height)  # same tuple metadata
+                   )  
+
+def create_image_content(image, maxdim, detail_threshold):
+    detail = "low" if maxdim < detail_threshold else "high"
+    return {
+        "type": "image_url",
+        "image_url": {"url": f"data:image/jpeg;base64,{image}", "detail": detail}
+    }
+
+def set_system_message(sysmsg):
+    return [{
+        "role": "system",
+        "content": sysmsg
+    }]
+
+## user message with images function
+def set_user_message(user_msg_str,
+                     file_path_list=[],      # A list of file paths to images.
+                     max_size_px=1024,       # Shrink images for lower expense
+                     file_names_list=None,   # You can set original upload names to show AI
+                     tiled=False,            # True is the API Reference method
+                     detail_threshold=700):  # any images below this get 512px "low" mode
+
+    if not isinstance(file_path_list, list):  # create empty list for weird input
+        file_path_list = []
+
+    if not file_path_list:  # no files, no tiles
+        tiled = False
+
+    if file_names_list and len(file_names_list) == len(file_path_list):
+        file_names = file_names_list
+    else:
+        file_names = [os.path.basename(path) for path in file_path_list]
+
+    base64_images = [process_image(path, max_size_px) for path in file_path_list]
+
+    uploaded_images_text = ""
+    if file_names:
+        uploaded_images_text = "\n\n---\n\nUploaded images:\n" + '\n'.join(file_names)
+
+    if tiled:
+        content = [{"type": "text", "text": user_msg_str + uploaded_images_text}]
+        content += [create_image_content(image, maxdim, detail_threshold)
+                    for image, maxdim in base64_images]
+        return [{"role": "user", "content": content}]
+    else:
+        return [{
+            "role": "user",
+            "content": ([user_msg_str + uploaded_images_text]
+                        + [{"image": image} for image, _ in base64_images])
+          }]
+
+poppler_path = '/usr/bin'  # Adjust this path if needed
+
+# Add the Poppler path to the system PATH
+os.environ['PATH'] += os.pathsep + poppler_path
+
+def pdf_to_images(pdf_path, dpi=300, output_format='JPEG'):
+    temp_dir = tempfile.mkdtemp()
+    pages = convert_from_path(pdf_path, dpi)
+    image_paths = []
+    for i, page in enumerate(pages):
+        image_path = os.path.join(temp_dir, f'page{i}.{output_format.lower()}')
+        page.save(image_path, output_format)
+        image_paths.append(image_path)
+    return image_paths
+
+# -- START -- set up run variables
+
+system_msg = """
+You are kheops an AI assistant,you an accountant expert powered by kheops Team with computer vision.
+AI knowledge cutoff: April 2024
+
+Built-in vision capabilities:
+- extract text from image
+- describe images
+- analyze image contents
+- logical problem-solving requiring machine vision
+""".strip()
+
+
+"""
+Sachant que Total à payer doit etre egal à Fond travaux alur + Part charges prévisionnelles+  Part autres travaux - le solde précédent"""
+# The user message
+user_msg = """
+Sachant que Total à payer = Fond travaux alur + Part charges prévisionnelles+  Part autres travaux - le solde précédent
+fournit les informations suivante sous format json uniquement:
+-Total à payer 
+-Fond travaux alur
+-Total Part charges prévisionnelles
+-Part autres travaux
+-le solde précédent  
+-identifier le propriétaire 
+- l’adresse du propriétaire ou le numéro du lot du propriétaire si l'adresse n'est pas trouvé
+- date du document
+- date limit du payement
+""".strip()
+
+
+
+
+
+# user images file list, and max dimension limit
+max_size = 1024  # downsizes if any dimension above this
+# Définir le chemin du dossier contenant les images
+def process(pdf):
+    """
+    if pdf == "PDF 1" :
+        PDF_PATH="_1.pdf"
+    elif pdf =="PDF 2" :
+        PDF_PATH="2.pdf"
+    elif pdf =="PDF 3" :
+        PDF_PATH="3.pdf"
+    elif pdf =="PDF 4" :
+        PDF_PATH="4.pdf"
+    elif pdf =="PDF 5" :
+        PDF_PATH="5.pdf"
+    elif pdf =="PDF 6" :
+        PDF_PATH="6.pdf"
+"""
+    image_paths = pdf_to_images(pdf)
+    system = set_system_message(system_msg)
+    chat_hist = []  # list of more user/assistant items
+    user = set_user_message(user_msg, image_paths, max_size)
+    
+    params = {  # dictionary format for ** unpacking
+      "model": "gpt-4o", 
+      "temperature": 0.5,
+      "user": "my_customer",
+      "max_tokens": 500,
+      "top_p": 0.5,
+      "stream": True,
+      "messages": system + chat_hist + user,
+    }
+    
+    start = time.perf_counter()
+    try:
+        client = openai.Client(timeout=111,api_key=openai_api_key)
+        response = client.chat.completions.with_raw_response.create(**params)
+        headers_dict = response.headers.items().mapping.copy()
+        for key, value in headers_dict.items():  # set a variable for each header
+            locals()[f'headers_{key.replace("-", "_")}'] = value
+    except Exception as e:
+        print(f"Error during API call: {e}")
+        return None
+    reply = ""
+    if response is not None:
+        try:
+
+            for chunk_no, chunk in enumerate(response.parse()):
+                # Ensure that delta.content is available
+                if hasattr(chunk.choices[0].delta, 'content'):
+                    content = chunk.choices[0].delta.content
+                    if content is None : content=""
+                    reply += content
+                    #print(content, end="")  # Correct usage of end=""
+                    # Only assign content to resultat
+                    resultat = reply
+                else:
+                    print("No content in chunk.")
+        except Exception as e:
+            print(f"Error during receive/parsing: {e}")
+    
+    print(f"\n[elapsed: {time.perf_counter()-start:.2f} seconds]")
+
+
+    return resultat
+
+
+iface = gr.Interface(
+    fn=process,
+    #inputs=gr.Radio(["PDF 1", "PDF 2", "PDF 3", "PDF 4", "PDF 5","PDF 6"]),
+    inputs= PDF(label="Upload a PDF", interactive=True),
+    outputs=[
+        #gr.File(label="Uploaded PDF"),  # Display the uploaded PDF
+        gr.Textbox(label="Extracted Information")  # Display processed result
+    ],
+    title="Immoblier",
+    description="Upload a PDF and extract the required information."
+)
+iface.launch(debug=True)

packages.txt

@@ -0,0 +1 @@
+poppler-utils

requirements.txt

@@ -0,0 +1,7 @@
+gradio
+openai
+pillow
+pdf2image
+ipython
+python-dotenv
+gradio-pdf