Create app.py

app.py

@@ -0,0 +1,546 @@
+import xml.etree.ElementTree as ET
+import pandas as pd
+import json
+import gradio as gr
+
+
+def get_clients_from_xml(xml_file):
+    """Extract all clients from XML file and return a list of tuples (id, name)"""
+    try:
+        tree = ET.parse(xml_file.name)  # Use .name since gradio provides a temp file
+        root = tree.getroot()
+
+        clients = []
+        for client in root.findall(".//client"):
+            client_id = client.get("id")
+            nom = client.get("nom") if client.get("nom") is not None else ""
+            prenom = client.get("prenom") if client.get("prenom") is not None else ""
+            clients.append((client_id, f"{prenom} {nom} (ID: {client_id})"))
+
+        return clients
+    except Exception as e:
+        print(e)
+        return []
+
+
+def client_to_json(xml_file, client_id):
+    tree = ET.parse(xml_file)
+    root = tree.getroot()
+
+    # Find the specific client
+    client = root.find(f".//client[@id='{client_id}']")
+    if client is None:
+        return json.dumps({"error": f"Client ID {client_id} not found"})
+
+    def element_to_dict(element):
+        result = {}
+
+        # Add attributes
+        if element.attrib:
+            result.update(element.attrib)
+
+        # Add text content if it exists and isn't empty
+        if element.text and element.text.strip():
+            result["_text"] = element.text.strip()
+
+        # Process child elements
+        for child in element:
+            child_data = element_to_dict(child)
+
+            if child.tag in result:
+                # If the key already exists, convert it to a list if it isn't already
+                if not isinstance(result[child.tag], list):
+                    result[child.tag] = [result[child.tag]]
+                result[child.tag].append(child_data)
+            else:
+                result[child.tag] = child_data
+
+        return result
+
+    # Convert client data to dictionary
+    client_data = element_to_dict(client)
+
+    # Convert to JSON with pretty printing
+    return json.dumps(client_data, indent=2, ensure_ascii=False)
+
+
+def display_nested_json(json_data):
+    # If input is a string, parse it to dict
+    if isinstance(json_data, str):
+        data = json.loads(json_data)
+    else:
+        data = json_data
+
+    # 1. Basic Client Information
+    basic_info = pd.DataFrame(
+        [
+            {
+                "ID": data.get("id"),
+                "Nom": data.get("nom"),
+                "Prénom": data.get("prenom"),
+                "Civilité": data.get("civilite"),
+                "Date Creation": data.get("date_creation"),
+            }
+        ]
+    )
+
+    # 2. Accounts Table
+    accounts_df = extract_accounts(data)
+
+    # 3. Contact Information
+    contacts_df = extract_contacts(data)
+
+    # 4. Real Estate (Immobilier) Information
+    immobilier_df = extract_immobilier(data)
+
+    # 5. Patrimoine Information
+    patrimoine_df = extract_patrimoine(data)
+
+    # 6. Budget Information
+    budget_df = extract_budget(data)
+
+    return {
+        "basic_info": basic_info,
+        "accounts": accounts_df,
+        "contacts": contacts_df,
+        "immobilier": immobilier_df,
+        "patrimoine": patrimoine_df,
+        "budget": budget_df,
+    }
+
+
+def extract_accounts(data):
+    if "comptes" in data and "compte" in data["comptes"]:
+        accounts = data["comptes"]["compte"]
+        if isinstance(accounts, dict):
+            accounts = [accounts]
+
+        accounts_data = []
+        for account in accounts:
+            situations = account.get("situations", {})
+            situation_data = situations.get("situation", [])
+
+            if isinstance(situation_data, dict):
+                situation_data = [situation_data]
+
+            for situation in situation_data:
+                row = {
+                    "Account ID": account.get("id"),
+                    "Account Name": account.get("intitule"),
+                    "Opening Date": account.get("date_ouverture"),
+                    "Valuation Date": situations.get("date_valorisation"),
+                    "Valuation Type": situations.get("type_valorisation"),
+                    "Support ID": situation.get("support_id"),
+                    "Quantity": situation.get("quantite"),
+                    "Price": situation.get("cours"),
+                    "Value (EUR)": situation.get("valeur_euro"),
+                    "Weight (%)": situation.get("poids_ligne"),
+                    "PMV (EUR)": situation.get("pmv_euro"),
+                    "PMV (%)": situation.get("pmv_pourcentage"),
+                }
+                accounts_data.append(row)
+
+        accounts_df = pd.DataFrame(accounts_data)
+
+        numeric_columns = [
+            "Quantity",
+            "Price",
+            "Value (EUR)",
+            "Weight (%)",
+            "PMV (EUR)",
+            "PMV (%)",
+        ]
+        for col in numeric_columns:
+            if col in accounts_df.columns:
+                try:
+                    accounts_df[col] = pd.to_numeric(accounts_df[col])
+                except ValueError:
+                    print(f"Warning: Could not convert column {col} to numeric.")
+
+    else:
+        accounts_df = pd.DataFrame()
+
+    return accounts_df
+
+
+def extract_contacts(data):
+    if "modes_contacts" in data:
+        contacts = data["modes_contacts"]
+        contacts_df = pd.DataFrame(
+            [
+                {
+                    "Email": contacts.get("email_personnel"),
+                    "Mobile": contacts.get("telephone_mobile"),
+                }
+            ]
+        )
+    else:
+        contacts_df = pd.DataFrame()
+
+    return contacts_df
+
+
+def extract_immobilier(data):
+    if "immobiliers" in data and "immobilier" in data["immobiliers"]:
+        immobilier = data["immobiliers"]["immobilier"]
+        if isinstance(immobilier, dict):
+            immobilier = [immobilier]
+
+        immobilier_data = []
+        for item in immobilier:
+            row = {
+                "ID": item.get("id"),
+                "Designation": item.get("designation"),
+                "Address": item.get("adresse", {}).get("adresse"),
+                "City": item.get("adresse", {}).get("ville"),
+                "Postal Code": item.get("adresse", {}).get("code_postal"),
+                "Country": item.get("adresse", {}).get("pays"),
+                "Value": item.get("valeur", {}).get("totale"),
+                "Revenues": item.get("revenus", {}).get("montant"),
+                "Charges": item.get("charges", {}).get("montant"),
+            }
+            immobilier_data.append(row)
+
+        immobilier_df = pd.DataFrame(immobilier_data)
+    else:
+        immobilier_df = pd.DataFrame()
+
+    return immobilier_df
+
+
+def extract_patrimoine(data):
+    patrimoine_data = {"actifs": pd.DataFrame(), "passifs": pd.DataFrame()}
+
+    if "patrimoine" in data:
+        # Extract Actifs
+        if "actifs" in data["patrimoine"]:
+            actifs_items = data["patrimoine"]["actifs"].get("actif", [])
+            if isinstance(actifs_items, dict):
+                actifs_items = [actifs_items]
+
+            if actifs_items:
+                actifs_data = []
+                for item in actifs_items:
+                    row = {
+                        "UUID": item.get("uuid"),
+                        "Libellé": item.get("libelle"),
+                        "Patrimoine ID": item.get("patrimoine_id"),
+                        "Montant (EUR)": item.get("montant_euro"),
+                        "Système": item.get("system_origine"),
+                        "Détenteur": item.get("detention", {}).get("detenteur"),
+                        "Mode": item.get("detention", {}).get("mode"),
+                    }
+
+                    # Extract external references
+                    ref_externes = item.get("ref_externes", {}).get("ref_externe", [])
+                    if isinstance(ref_externes, dict):
+                        ref_externes = [ref_externes]
+                    if ref_externes:
+                        systems = [ref.get("system") for ref in ref_externes]
+                        row["Systèmes Externes"] = ", ".join(filter(None, systems))
+
+                    actifs_data.append(row)
+
+                actifs_df = pd.DataFrame(actifs_data)
+                if "Montant (EUR)" in actifs_df.columns:
+                    try:
+                        actifs_df["Montant (EUR)"] = pd.to_numeric(
+                            actifs_df["Montant (EUR)"]
+                        )
+                    except ValueError:
+                        print(
+                            "Warning: Could not convert some actifs montants to numeric"
+                        )
+                patrimoine_data["actifs"] = actifs_df
+
+        # Extract Passifs
+        if "passifs" in data["patrimoine"]:
+            passifs_items = data["patrimoine"]["passifs"].get("passif", [])
+            if isinstance(passifs_items, dict):
+                passifs_items = [passifs_items]
+
+            if passifs_items:
+                passifs_data = []
+                for item in passifs_items:
+                    row = {
+                        "UUID": item.get("uuid"),
+                        "Libellé": item.get("libelle"),
+                        "Patrimoine ID": item.get("patrimoine_id"),
+                        "Système": item.get("system_origine"),
+                        "Souscripteur": item.get("souscripteur"),
+                        "Périodicité": item.get("periodicite"),
+                        "Taux HA": item.get("caracteristiques", {}).get("taux_HA"),
+                        "Assurance Taux": item.get("assurance", {}).get("taux"),
+                        "Capital Restant Dû (EUR)": item.get(
+                            "capital_restant_du", {}
+                        ).get("montant_euro"),
+                        "Date Capital Restant Dû": item.get(
+                            "capital_restant_du", {}
+                        ).get("date"),
+                    }
+
+                    # Extract external references
+                    ref_externes = item.get("ref_externes", {}).get("ref_externe", [])
+                    if isinstance(ref_externes, dict):
+                        ref_externes = [ref_externes]
+                    if ref_externes:
+                        systems = [ref.get("system") for ref in ref_externes]
+                        row["Systèmes Externes"] = ", ".join(filter(None, systems))
+
+                    passifs_data.append(row)
+
+                passifs_df = pd.DataFrame(passifs_data)
+                if "Capital Restant Dû (EUR)" in passifs_df.columns:
+                    try:
+                        passifs_df["Capital Restant Dû (EUR)"] = pd.to_numeric(
+                            passifs_df["Capital Restant Dû (EUR)"]
+                        )
+                    except ValueError:
+                        print(
+                            "Warning: Could not convert some passifs capital restant dû to numeric"
+                        )
+                patrimoine_data["passifs"] = passifs_df
+
+    return patrimoine_data
+
+
+def extract_budget(data):
+    budget_data = {"revenus": pd.DataFrame(), "charges": pd.DataFrame()}
+
+    if "budget" in data:
+        # Extract Revenus
+        if "revenus" in data["budget"]:
+            revenus_items = data["budget"]["revenus"].get("revenu", [])
+            if isinstance(revenus_items, dict):
+                revenus_items = [revenus_items]
+
+            if revenus_items:
+                revenus_data = []
+                for item in revenus_items:
+                    row = {
+                        "ID": item.get("id"),
+                        "Budget ID": item.get("budget_id"),
+                        "Libellé": item.get("libelle"),
+                        "Montant (EUR)": item.get("montant_euro"),
+                        "Périodicité": item.get("periodicite"),
+                        "Bénéficiaire": item.get("beneficiaire"),
+                        "UUID": item.get("uuid"),
+                        "Système": item.get("system_origine"),
+                        "Date Terme": item.get("date_terme", ""),
+                    }
+
+                    # Extract external references if needed
+                    ref_externes = item.get("ref_externes", {}).get("ref_externe", [])
+                    if isinstance(ref_externes, dict):
+                        ref_externes = [ref_externes]
+                    if ref_externes:
+                        systems = [ref.get("system") for ref in ref_externes]
+                        row["Systèmes Externes"] = ", ".join(filter(None, systems))
+
+                    revenus_data.append(row)
+
+                revenus_df = pd.DataFrame(revenus_data)
+                if "Montant (EUR)" in revenus_df.columns:
+                    try:
+                        revenus_df["Montant (EUR)"] = pd.to_numeric(
+                            revenus_df["Montant (EUR)"]
+                        )
+                    except ValueError:
+                        print(
+                            "Warning: Could not convert some revenus montants to numeric"
+                        )
+                budget_data["revenus"] = revenus_df
+
+        # Extract Charges
+        if "charges" in data["budget"]:
+            charges_items = data["budget"]["charges"].get("charge", [])
+            if isinstance(charges_items, dict):
+                charges_items = [charges_items]
+
+            if charges_items:
+                charges_data = []
+                for item in charges_items:
+                    row = {
+                        "ID": item.get("id"),
+                        "Budget ID": item.get("budget_id"),
+                        "Libellé": item.get("libelle"),
+                        "Montant (EUR)": item.get("montant_euro"),
+                        "Périodicité": item.get("periodicite"),
+                        "Débiteur": item.get("debiteur"),
+                        "UUID": item.get("uuid"),
+                        "Système": item.get("system_origine"),
+                    }
+
+                    # Extract external references if needed
+                    ref_externes = item.get("ref_externes", {}).get("ref_externe", [])
+                    if isinstance(ref_externes, dict):
+                        ref_externes = [ref_externes]
+                    if ref_externes:
+                        systems = [ref.get("system") for ref in ref_externes]
+                        row["Systèmes Externes"] = ", ".join(filter(None, systems))
+
+                    charges_data.append(row)
+
+                charges_df = pd.DataFrame(charges_data)
+                if "Montant (EUR)" in charges_df.columns:
+                    try:
+                        charges_df["Montant (EUR)"] = pd.to_numeric(
+                            charges_df["Montant (EUR)"]
+                        )
+                    except ValueError:
+                        print(
+                            "Warning: Could not convert some charges montants to numeric"
+                        )
+                budget_data["charges"] = charges_df
+
+    return budget_data
+
+
+def format_client_info(client_id):
+    # Get JSON data using your previous function
+    json_data = client_to_json("test.xml", client_id)
+    tables = display_nested_json(json_data)
+
+    pd.set_option("display.max_columns", None)
+    pd.set_option("display.width", None)
+    pd.set_option(
+        "display.float_format",
+        lambda x: "{:.2f}".format(x) if isinstance(x, (float, int)) else x,
+    )
+
+    # Return DataFrames directly instead of string representations
+    outputs = []
+
+    # Basic Info
+    outputs.append(gr.Markdown("## Client Basic Information"))
+    outputs.append(tables["basic_info"])
+
+    # Contacts
+    outputs.append(gr.Markdown("## Contacts Client"))
+    outputs.append(tables["contacts"])
+
+    # Accounts
+    outputs.append(gr.Markdown("## Accounts and Positions"))
+    outputs.append(
+        tables["accounts"]
+        if not tables["accounts"].empty
+        else pd.DataFrame({"Message": ["No accounts found"]})
+    )
+
+    # Patrimoine - Actifs
+    outputs.append(gr.Markdown("## Patrimoine"))
+    outputs.append(gr.Markdown("### Actifs"))
+    outputs.append(
+        tables["patrimoine"]["actifs"]
+        if not tables["patrimoine"]["actifs"].empty
+        else pd.DataFrame({"Message": ["No actifs found"]})
+    )
+
+    # Patrimoine - Passifs
+    outputs.append(gr.Markdown("### Passifs"))
+    outputs.append(
+        tables["patrimoine"]["passifs"]
+        if not tables["patrimoine"]["passifs"].empty
+        else pd.DataFrame({"Message": ["No passifs found"]})
+    )
+
+    # Budget - Revenus
+    outputs.append(gr.Markdown("## Budget"))
+    outputs.append(gr.Markdown("### Revenus"))
+    outputs.append(
+        tables["budget"]["revenus"]
+        if not tables["budget"]["revenus"].empty
+        else pd.DataFrame({"Message": ["No revenus found"]})
+    )
+
+    # Budget - Charges
+    outputs.append(gr.Markdown("### Charges"))
+    outputs.append(
+        tables["budget"]["charges"]
+        if not tables["budget"]["charges"].empty
+        else pd.DataFrame({"Message": ["No charges found"]})
+    )
+
+    return outputs
+
+
+# Create Gradio interface
+with gr.Blocks(title="Client Information Viewer") as demo:
+    gr.Markdown("# Client Information Viewer")
+    gr.Markdown(
+        "Upload an XML file and select a client to view their detailed information"
+    )
+
+    xml_file = gr.File(label="Upload XML File", file_types=[".xml"])
+    client_dropdown = gr.Dropdown(label="Select Client", choices=[], interactive=True)
+    view_btn = gr.Button("View Client Info", interactive=False)
+
+    # Create output containers for each section
+    basic_info_header = gr.Markdown()
+    basic_info_df = gr.DataFrame()
+
+    contacts_header = gr.Markdown()
+    contacts_df = gr.DataFrame()
+
+    accounts_header = gr.Markdown()
+    accounts_df = gr.DataFrame()
+
+    actifs_header = gr.Markdown()
+    actifs_subheader = gr.Markdown()
+    actifs_df = gr.DataFrame()
+
+    passifs_subheader = gr.Markdown()
+    passifs_df = gr.DataFrame()
+
+    revenus_header = gr.Markdown()
+    revenus_subheader = gr.Markdown()
+    revenus_df = gr.DataFrame()
+
+    charges_subheader = gr.Markdown()
+    charges_df = gr.DataFrame()
+
+    # Combine all outputs in order
+    output_dfs = [
+        basic_info_header,
+        basic_info_df,
+        contacts_header,
+        contacts_df,
+        accounts_header,
+        accounts_df,
+        actifs_header,
+        actifs_subheader,
+        actifs_df,
+        passifs_subheader,
+        passifs_df,
+        revenus_header,
+        revenus_subheader,
+        revenus_df,
+        charges_subheader,
+        charges_df,
+    ]
+
+    # Update dropdown when file is uploaded
+    def update_dropdown(file):
+        if file is None:
+            return gr.Dropdown(choices=[], value=None, interactive=False), gr.Button(
+                interactive=False
+            )
+        clients = get_clients_from_xml(file)
+        choices = [(name, id) for id, name in clients]
+        return gr.Dropdown(choices=choices, interactive=True), gr.Button(
+            interactive=True
+        )
+
+    xml_file.change(
+        fn=update_dropdown, inputs=[xml_file], outputs=[client_dropdown, view_btn]
+    )
+
+    # View client info when button is clicked
+    view_btn.click(
+        fn=format_client_info,
+        inputs=client_dropdown,
+        outputs=output_dfs,
+    )
+
+if __name__ == "__main__":
+    demo.launch(server_port=7860, share=True)