Add files with Git LFS

.devcontainer/devcontainer.json

@@ -0,0 +1,33 @@
+{
+  "name": "Python 3",
+  // Or use a Dockerfile or Docker Compose file. More info: https://containers.dev/guide/dockerfile
+  "image": "mcr.microsoft.com/devcontainers/python:1-3.11-bullseye",
+  "customizations": {
+    "codespaces": {
+      "openFiles": [
+        "README.md",
+        "app.py"
+      ]
+    },
+    "vscode": {
+      "settings": {},
+      "extensions": [
+        "ms-python.python",
+        "ms-python.vscode-pylance"
+      ]
+    }
+  },
+  "updateContentCommand": "[ -f packages.txt ] && sudo apt update && sudo apt upgrade -y && sudo xargs apt install -y <packages.txt; [ -f requirements.txt ] && pip3 install --user -r requirements.txt; pip3 install --user streamlit; echo '✅ Packages installed and Requirements met'",
+  "postAttachCommand": {
+    "server": "streamlit run app.py --server.enableCORS false --server.enableXsrfProtection false"
+  },
+  "portsAttributes": {
+    "8501": {
+      "label": "Application",
+      "onAutoForward": "openPreview"
+    }
+  },
+  "forwardPorts": [
+    8501
+  ]
+}

.gitignore

@@ -0,0 +1,8 @@
+# Environment files
+.env
+
+# Python virtual environment
+venv/
+
+# Logs
+*.log

agents.py

@@ -0,0 +1,93 @@
+from crewai import Agent
+from langchain.tools import Tool
+from utils import create_uae_legal_tools, is_arabic
+from config import LEGAL_CATEGORIES
+from dotenv import load_dotenv
+import os
+
+# Load environment variables
+load_dotenv()
+
+# Validate API key
+if not os.getenv('OPENAI_API_KEY'):
+    raise ValueError("OpenAI API key not found. Please set OPENAI_API_KEY in your environment variables.")
+
+# Common LLM configuration
+BASE_LLM_CONFIG = {
+    "config_list": [
+        {
+            "model": "gpt-4-1106-preview",  # Using the latest GPT-4 Turbo model
+            "api_key": os.getenv('OPENAI_API_KEY'),
+            "temperature": 0.3,  # Lower temperature for more consistent outputs
+            "max_tokens": 4000,
+            "presence_penalty": 0.0,
+            "frequency_penalty": 0.0,
+            "response_format": {"type": "text"}
+        }
+    ]
+}
+
+# Configuration for summarization tasks
+SUMMARY_LLM_CONFIG = {
+    "config_list": [
+        {
+            "model": "gpt-4-1106-preview",
+            "api_key": os.getenv('OPENAI_API_KEY'),
+            "temperature": 0.2,  # Even lower temperature for summaries
+            "max_tokens": 4000,
+            "presence_penalty": 0.0,
+            "frequency_penalty": 0.3,  # Reduce repetition in summaries
+            "response_format": {"type": "text"}
+        }
+    ]
+}
+
+def create_judge_agent():
+    return Agent(
+        role='قاضي قانوني إماراتي',
+        goal='تقديم أحكام وتفسيرات قانونية دقيقة بناءً على القانون الإماراتي',
+        backstory="""
+        أنت قاضٍ متمرس في النظام القانوني الإماراتي مع خبرة تزيد عن 20 عاماً 
+        ومعرفة عميقة بالقوانين واللوائح والسوابق القانونية الإماراتية. 
+        دورك هو تحليل القضايا وتقديم أحكام عادلة ومسببة بناءً على القانون الإماراتي،
+        مع التركيز على تطبيق أحدث التشريعات والأحكام القضائية.
+        يمنع الرد على اي استفسار غير قانوني او خاص بغير المواضيع القانونية في دولة الامارات العربية المتحدة.
+        يرجى التأكد من أن جميع الردود على أسئلتي تستند إلى مصادر موثوقة، مع تضمين الاستشهادات والروابط المناسبة لتلك المصادر. أفضل الإجابات التفصيلية والمنظمة جيدًا والتي لا تعالج استفساري فحسب، بل توفر أيضًا سياقًا أو رؤى إضافية عند الاقتضاء. كن واضحًا وموجزًا، وإذا كان موضوع معين لا يؤثر بشكل مباشر على أهدافي أو دراستي، فيرجى إبلاغي بذلك. اذكر أيضًا المراجع في نهاية المقال
+        """,
+        verbose=True,
+        allow_delegation=False,
+        llm_config=BASE_LLM_CONFIG,
+        tools=create_uae_legal_tools()
+    )
+
+def create_advocate_agent():
+    return Agent(
+        role='محامي إماراتي',
+        goal='تقديم التمثيل القانوني والمشورة المتخصصة بناءً على القانون الإماراتي',
+        backstory="""
+        أنت محامٍ ماهر في الإمارات العربية المتحدة مع خبرة 15 عاماً في مختلف
+        مجالات القانون الإماراتي. تخصصت في قضايا المحاكم الاتحادية والمحلية،
+        ولديك سجل حافل في تمثيل العملاء بنجاح. دورك هو تقديم المشورة القانونية
+        الدقيقة وضمان حماية حقوق العملاء وفقاً للقانون الإماراتي.
+        """,
+        verbose=True,
+        allow_delegation=False,
+        llm_config=BASE_LLM_CONFIG,
+        tools=create_uae_legal_tools()
+    )
+
+def create_consultant_agent():
+    return Agent(
+        role='مستشار قضائي إماراتي',
+        goal='تقديم الاستشارات والتوجيه القانوني المتخصص في القانون الإماراتي',
+        backstory="""
+        أنت مستشار قضائي متمرس مع خبرة 18 عاماً ومعرفة شاملة بالنظام القانوني
+        والإجراءات القضائية في الإمارات العربية المتحدة. تخصصت في تقديم الاستشارات
+        للمؤسسات والأفراد، مع التركيز على الحلول العملية والوقائية. دورك هو تقديم
+        التوجيه الاستراتيجي والمشورة المتخصصة في المسائل القانونية المعقدة.
+        """,
+        verbose=True,
+        allow_delegation=False,
+        llm_config=BASE_LLM_CONFIG,
+        tools=create_uae_legal_tools()
+    )

app.py

@@ -0,0 +1,329 @@
+import streamlit as st
+from agents import create_judge_agent, create_advocate_agent, create_consultant_agent
+from crewai import Task, Crew
+from utils import is_arabic, format_legal_response
+from config import LEGAL_CATEGORIES, DEFAULT_LANGUAGE
+
+st.set_page_config(page_title="المساعد القانوني الإماراتي", layout="wide")
+
+# Load custom CSS
+with open('style.css') as f:
+    st.markdown(f'<style>{f.read()}</style>', unsafe_allow_html=True)
+
+st.title("المساعد القانوني الإماراتي")
+st.write("احصل على المساعدة القانونية من خبراء قانونيين إماراتيين مدعومين بالذكاء الاصطناعي")
+
+# Add imports
+from pdf_processor import PDFProcessor
+from document_exporter import DocumentExporter
+from translator import Translator
+
+# Initialize components
+if 'pdf_processor' not in st.session_state:
+    st.session_state.pdf_processor = PDFProcessor()
+if 'document_exporter' not in st.session_state:
+    st.session_state.document_exporter = DocumentExporter()
+if 'translator' not in st.session_state:
+    st.session_state.translator = Translator()
+
+# Create a new tab for PDF upload
+tab1, tab2, tab3, tab4 = st.tabs(["تحليل المستندات", "القاضي", "المحامي", "المستشار"])
+
+# PDF Upload Tab
+with tab1:
+    st.header("تحليل المستندات القانونية")
+    
+    # Add service selection toggle
+    service_type = st.radio(
+        "اختر نوع الخدمة / Select Service",
+        ["تلخيص وتحليل المستند", "ترجمة المستند"],
+        horizontal=True
+    )
+    
+    if service_type == "ترجمة المستند":
+        target_language = st.selectbox(
+            "اختر لغة الترجمة / Select Target Language",
+            ["العربية", "English", "中文", "हिंदी", "اردو"],
+            index=1
+        )
+    
+    uploaded_file = st.file_uploader("قم بتحميل ملف PDF للتحليل", type=['pdf'])
+    
+    if uploaded_file is not None:
+        # Check file size
+        file_size = len(uploaded_file.getvalue()) / (1024 * 1024)  # Convert to MB
+        if file_size > 20:  # 20MB limit
+            st.error("حجم الملف كبير جداً. الحد الأقصى المسموح به هو 20 ميجابايت.")
+            st.stop()
+
+        if service_type == "تلخيص وتحليل المستند":
+            # Create progress bar
+            progress_bar = st.progress(0)
+            status_text = st.empty()
+
+            def update_progress(message, progress):
+                status_text.text(message)
+                progress_bar.progress(progress)
+
+            st.session_state.pdf_processor.set_progress_callback(update_progress)
+
+            try:
+                # Process the uploaded PDF
+                results = st.session_state.pdf_processor.process_document(uploaded_file.read())
+                
+                # Display results in collapsible sections
+                with st.expander("ملخص المستند", expanded=True):
+                    st.write(results["summary"])
+                
+                with st.expander("تحليل المخالفات القانونية", expanded=True):
+                    st.markdown(results["legal_analysis"], unsafe_allow_html=True)
+                
+                with st.expander("الخريطة التشريعية", expanded=True):
+                    st.markdown(results["legislation_mapping"], unsafe_allow_html=True)
+                
+                # Add export buttons in a container
+                st.markdown("### تحميل التحليل")
+                export_container = st.container()
+                
+                col1, col2 = export_container.columns(2)
+                with col1:
+                    pdf_button = st.download_button(
+                        label="تحميل كملف PDF",
+                        data=st.session_state.document_exporter.export_to_pdf(results),
+                        file_name="legal_analysis.pdf",
+                        mime="application/pdf",
+                        key="pdf_download"
+                    )
+                
+                with col2:
+                    word_button = st.download_button(
+                        label="تحميل كملف Word",
+                        data=st.session_state.document_exporter.export_to_word(results),
+                        file_name="legal_analysis.docx",
+                        mime="application/vnd.openxmlformats-officedocument.wordprocessingml.document",
+                        key="word_download"
+                    )
+                
+            except ValueError as ve:
+                st.error(f"خطأ في المدخلات: {str(ve)}")
+            except Exception as e:
+                st.error(f"حدث خطأ غير متوقع: {str(e)}")
+                st.error("يرجى المحاولة مرة أخرى أو الاتصال بالدعم الفني")
+            finally:
+                # Clear progress bar and status
+                progress_bar.empty()
+                status_text.empty()
+        
+        else:  # Translation service
+            with st.spinner("جاري تحليل المستند..."):
+                try:
+                    # Extract text from PDF
+                    text = st.session_state.pdf_processor.extract_text_from_pdf(uploaded_file.read())
+                    
+                    if not text.strip():
+                        st.error("لم يتم العثور على نص قابل للقراءة في المستند")
+                        st.stop()
+                    
+                    # Detect source language
+                    source_lang = st.session_state.translator.detect_language(text)
+                    st.info(f"تم اكتشاف لغة المستند: {st.session_state.translator.get_language_name(source_lang)}")
+                    
+                    # Map language names to codes
+                    lang_map = {
+                        "العربية": "arabic",
+                        "English": "english",
+                        "中文": "chinese",
+                        "हिंदी": "hindi",
+                        "اردو": "urdu"
+                    }
+                    
+                    target_lang = lang_map[target_language]
+                    
+                    # Check if source and target are the same
+                    if source_lang == target_lang:
+                        st.warning("لغة المصدر ولغة الهدف متطابقتان. يرجى اختيار لغة مختلفة للترجمة.")
+                        st.stop()
+                    
+                    with st.spinner("جاري الترجمة..."):
+                        # Preprocess and translate the text
+                        processed_text = st.session_state.translator.preprocess_text(text)
+                        translated_text = st.session_state.translator.translate(
+                            processed_text,
+                            source_lang,
+                            target_lang
+                        )
+                    
+                    # Display results
+                    col1, col2 = st.columns(2)
+                    with col1:
+                        st.subheader("النص الأصلي / Original Text")
+                        st.text_area("", value=text, height=300, key="original_text")
+                    
+                    with col2:
+                        st.subheader("النص المترجم / Translated Text")
+                        st.text_area("", value=translated_text, height=300, key="translated_text")
+                    
+                    # Add download buttons
+                    st.markdown("### تحميل الترجمة")
+                    download_col1, download_col2 = st.columns(2)
+                    
+                    with download_col1:
+                        st.download_button(
+                            label="تحميل النص المترجم",
+                            data=translated_text.encode(),
+                            file_name=f"translated_document.txt",
+                            mime="text/plain",
+                            key="translation_download"
+                        )
+                    
+                    with download_col2:
+                        # Create a simple HTML file with both texts
+                        html_content = f"""
+                        <html dir="auto">
+                        <head>
+                            <meta charset="UTF-8">
+                            <style>
+                                body {{ font-family: Arial, sans-serif; margin: 20px; }}
+                                .text-container {{ margin-bottom: 20px; }}
+                                h2 {{ color: #2c3e50; }}
+                            </style>
+                        </head>
+                        <body>
+                            <div class="text-container">
+                                <h2>Original Text</h2>
+                                <p>{text}</p>
+                            </div>
+                            <div class="text-container">
+                                <h2>Translated Text</h2>
+                                <p>{translated_text}</p>
+                            </div>
+                        </body>
+                        </html>
+                        """
+                        
+                        st.download_button(
+                            label="تحميل النصين معاً (HTML)",
+                            data=html_content.encode(),
+                            file_name="translation_with_original.html",
+                            mime="text/html",
+                            key="html_download"
+                        )
+                    
+                except ValueError as ve:
+                    st.error(f"خطأ في المدخلات: {str(ve)}")
+                except Exception as e:
+                    st.error(f"حدث خطأ غير متوقع: {str(e)}")
+                    st.error("يرجى المحاولة مرة أخرى أو الاتصال بالدعم الفني")
+
+# Language selector
+language = st.sidebar.selectbox(
+    "اختر اللغة / Select Language",
+    ["العربية", "English"],
+    index=0
+)
+
+# Legal category selector
+selected_category = st.sidebar.selectbox(
+    "اختر الفئة القانونية / Select Legal Category",
+    list(LEGAL_CATEGORIES.values()),
+    index=0
+)
+
+# Initialize session state for chat history
+if 'chat_history' not in st.session_state:
+    st.session_state.chat_history = []
+
+# Create tabs for different agents
+tab1, tab2, tab3 = st.tabs(["القاضي", "المحامي", "المستشار"])
+
+def get_agent_response(agent, query, category):
+    # Prepare the task with context
+    task_description = f"""
+    تحليل والرد على الاستفسار التالي في مجال {category}:
+    {query}
+    
+    يجب أن يكون الرد:
+    1. مستنداً إلى القانون الإماراتي
+    2. مدعوماً بالمراجع القانونية
+    3. واضحاً ومفهوماً
+    4. متوافقاً مع أحدث التشريعات
+    """
+    
+    task = Task(
+        description=task_description,
+        agent=agent,
+        expected_output="تحليل قانوني ورد بناءً على القانون الإماراتي"
+
+    )
+    
+    crew = Crew(
+        agents=[agent],
+        tasks=[task]
+    )
+    
+    result = crew.kickoff()
+    return format_legal_response(result, 'ar' if is_arabic(query) else 'en')
+
+# Judge Tab
+with tab2:
+    st.header("استشارة القاضي الإماراتي")
+    judge_query = st.text_area("اكتب سؤالك القانوني للقاضي:", key="judge_input", placeholder="أدخل النص هنا...")
+    st.markdown(
+        """
+        <style>
+        .element-container textarea {
+            direction: rtl;
+            text-align: right;
+        }
+        </style>
+        """,
+        unsafe_allow_html=True
+    )
+    if st.button("الحصول على رأي القاضي", key="judge_button"):
+        if judge_query:
+            with st.spinner("القاضي يحلل قضيتك..."):
+                judge_agent = create_judge_agent()
+                response = get_agent_response(judge_agent, judge_query, selected_category)
+                st.session_state.chat_history.append(("القاضي", judge_query, response))
+                st.write("رد القاضي:")
+                st.markdown(response, unsafe_allow_html=True)
+
+# Advocate Tab
+with tab3:
+    st.header("استشارة المحامي الإماراتي")
+    advocate_query = st.text_area("اكتب سؤالك القانوني للمحامي:", key="advocate_input", placeholder="أدخل النص هنا...")
+    st.markdown(
+        """
+        <style>
+        .element-container textarea {
+            direction: rtl;
+            text-align: right;
+        }
+        </style>
+        """,
+        unsafe_allow_html=True
+    )
+    if st.button("الحصول على رأي المحامي", key="advocate_button"):
+        if advocate_query:
+            with st.spinner("المحامي يحلل قضيتك..."):
+                advocate_agent = create_advocate_agent()
+                response = get_agent_response(advocate_agent, advocate_query, selected_category)
+                st.session_state.chat_history.append(("المحامي", advocate_query, response))
+                st.write("رد المحامي:")
+                st.markdown(response, unsafe_allow_html=True)
+
+# Consultant Tab
+with tab4:
+    st.header("استشارة المستشار القضائي الإماراتي")
+    consultant_query = st.text_area("اكتب سؤالك القانوني للمستشار:", key="consultant_input", placeholder="أدخل النص هنا...")
+    st.markdown(
+        """
+        <style>
+        .element-container textarea {
+            direction: rtl;
+            text-align: right;
+        }
+        </style>
+        """,
+        unsafe_allow_html=True
+        )

changes.tar.gz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:acc5c62af6ddd4cd86812758b4f2f6c999eddbfb0e3a6e3d2ff2412ad9c991ab
+size 5186

config.py

@@ -0,0 +1,31 @@
+import os
+from dotenv import load_dotenv
+
+load_dotenv()
+
+# OpenAI Configuration
+OPENAI_API_KEY = os.getenv('OPENAI_API_KEY')
+
+# Language Settings
+DEFAULT_LANGUAGE = 'ar'  # Arabic by default
+SUPPORTED_LANGUAGES = ['ar', 'en']
+
+# UAE Legal Resources
+UAE_LEGAL_DOMAINS = [
+    'https://elaws.moj.gov.ae',
+    'https://www.mohre.gov.ae',
+    'https://www.dm.gov.ae',
+    'https://www.adjd.gov.ae',
+    'https://www.dc.gov.ae'
+
+]
+
+# Legal Categories
+LEGAL_CATEGORIES = {
+    'civil': 'القانون المدني',
+    'criminal': 'القانون الجنائي',
+    'commercial': 'القانون التجاري',
+    'labor': 'قانون العمل',
+    'family': 'قانون الأسرة',
+    'property': 'قانون العقارات'
+}

document_exporter.py

@@ -0,0 +1,125 @@
+try:
+    from docx import Document
+except ImportError:
+    from docx.api import Document
+from reportlab.pdfgen import canvas
+from reportlab.lib.pagesizes import letter
+from reportlab.pdfbase import pdfmetrics
+from reportlab.pdfbase.ttfonts import TTFont
+import io
+import arabic_reshaper
+from bidi.algorithm import get_display
+
+class DocumentExporter:
+    def __init__(self):
+        # Register Arabic font for PDF
+        try:
+            pdfmetrics.registerFont(TTFont('Arabic', 'fonts/NotoNaskhArabic-Regular.ttf'))
+        except:
+            pass  # Fall back to default font if Arabic font is not available
+
+    def export_to_pdf(self, content: dict) -> bytes:
+        """Export the analysis results to PDF format."""
+        buffer = io.BytesIO()
+        c = canvas.Canvas(buffer, pagesize=letter)
+        
+        # Set font for Arabic text
+        try:
+            c.setFont('Arabic', 14)
+        except:
+            c.setFont('Helvetica', 14)
+
+        y = 750  # Starting y position
+        
+        # Add title
+        title = "تحليل المستند القانوني"
+        title = get_display(arabic_reshaper.reshape(title))
+        c.drawString(500, y, title)
+        y -= 30
+
+        # Add summary
+        summary_title = "ملخص المستند"
+        summary_title = get_display(arabic_reshaper.reshape(summary_title))
+        c.drawString(500, y, summary_title)
+        y -= 20
+        
+        summary_text = get_display(arabic_reshaper.reshape(content['summary']))
+        # Wrap text to fit page width
+        words = summary_text.split()
+        line = ""
+        for word in words:
+            if c.stringWidth(line + word, 'Arabic', 12) < 500:
+                line += word + " "
+            else:
+                c.drawString(50, y, line)
+                y -= 15
+                line = word + " "
+        if line:
+            c.drawString(50, y, line)
+        y -= 30
+
+        # Add legal analysis
+        analysis_title = "تحليل المخالفات القانونية"
+        analysis_title = get_display(arabic_reshaper.reshape(analysis_title))
+        c.drawString(500, y, analysis_title)
+        y -= 20
+        
+        analysis_text = get_display(arabic_reshaper.reshape(content['legal_analysis']))
+        words = analysis_text.split()
+        line = ""
+        for word in words:
+            if c.stringWidth(line + word, 'Arabic', 12) < 500:
+                line += word + " "
+            else:
+                c.drawString(50, y, line)
+                y -= 15
+                line = word + " "
+        if line:
+            c.drawString(50, y, line)
+        y -= 30
+
+        # Add legislation mapping
+        mapping_title = "الخريطة التشريعية"
+        mapping_title = get_display(arabic_reshaper.reshape(mapping_title))
+        c.drawString(500, y, mapping_title)
+        y -= 20
+        
+        mapping_text = get_display(arabic_reshaper.reshape(content['legislation_mapping']))
+        words = mapping_text.split()
+        line = ""
+        for word in words:
+            if c.stringWidth(line + word, 'Arabic', 12) < 500:
+                line += word + " "
+            else:
+                c.drawString(50, y, line)
+                y -= 15
+                line = word + " "
+        if line:
+            c.drawString(50, y, line)
+
+        c.save()
+        return buffer.getvalue()
+
+    def export_to_word(self, content: dict) -> bytes:
+        """Export the analysis results to Word format."""
+        doc = Document()
+        
+        # Add title
+        doc.add_heading("تحليل المستند القانوني", 0)
+        
+        # Add summary section
+        doc.add_heading("ملخص المستند", level=1)
+        doc.add_paragraph(content['summary'])
+        
+        # Add legal analysis section
+        doc.add_heading("تحليل المخالفات القانونية", level=1)
+        doc.add_paragraph(content['legal_analysis'])
+        
+        # Add legislation mapping section
+        doc.add_heading("الخريطة التشريعية", level=1)
+        doc.add_paragraph(content['legislation_mapping'])
+        
+        # Save to bytes
+        buffer = io.BytesIO()
+        doc.save(buffer)
+        return buffer.getvalue()

fonts/NotoNaskhArabic.zip

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:0e9aa38292c3aef5a8e3bd28b30945638d49bbc028517c71c645d3bd90a957b0
+size 21347

hassan_github

@@ -0,0 +1,49 @@
+-----BEGIN OPENSSH PRIVATE KEY-----
+b3BlbnNzaC1rZXktdjEAAAAABG5vbmUAAAAEbm9uZQAAAAAAAAABAAACFwAAAAdzc2gtcn
+NhAAAAAwEAAQAAAgEAsFKJwQWnqkffXdE3djKsicWXO2zUwKsdyMCcpQNpHsjm8tp8Gzne
+EaES6wrDV98UEA4KZyl3PsLcIrJE2srKaVpoaYe1UpJlVhTmo+oILmH0kt4321q1w6YQMT
+2SB6yfc2XnhhwRtHCzPhGFygI8tdPcwP4HPJJwQUZSt8wVGROLphrXBSrvnZNF3yAJa+4o
+/J+bG6qLFvXqZnjdiOe1wY596bRs5KeuHM41cyRbmPtUlSPzaEy3Non7rTp0s+sL6pmIPY
+gUQ5fdMy8svlJndjIJg348nHfW7DZUHSaMfQgCOXOhwTbY/mEFwfM0nz5IWKPr+kjliMkO
+GHKizPhqBTwlCVPFw2sifV7305ON+yUptYczksjpv1dlw6SlUxxyTKkTbnV7n7YiNxwbTa
+LkHfD283zFH5ziMkU1fuiGh9NPzPE/sa80dR6EwnB0XLBojyJGVD39jJ4X4wb2G+MJik7U
+fgP22najOSSoK5xuFbW50rRlUp6n30bgrH4f/kiytQUAUhtB7YIt1YU9VUf/Z6S4ab1SL5
+w+BLVekZVnigr/lYCTzTo+tIvkEVCbbiGAaof6EO5Zs4q7D22zXPm0E9eZb6d2V8/vPWPA
++gIjaTPseqEsnxj+2b6ewScPbYkHnI0oomTQwWIRAfrxpi+iyKc23mf4q6nAjyvRKXSVWD
+UAAAdQVunz01bp89MAAAAHc3NoLXJzYQAAAgEAsFKJwQWnqkffXdE3djKsicWXO2zUwKsd
+yMCcpQNpHsjm8tp8GzneEaES6wrDV98UEA4KZyl3PsLcIrJE2srKaVpoaYe1UpJlVhTmo+
+oILmH0kt4321q1w6YQMT2SB6yfc2XnhhwRtHCzPhGFygI8tdPcwP4HPJJwQUZSt8wVGROL
+phrXBSrvnZNF3yAJa+4o/J+bG6qLFvXqZnjdiOe1wY596bRs5KeuHM41cyRbmPtUlSPzaE
+y3Non7rTp0s+sL6pmIPYgUQ5fdMy8svlJndjIJg348nHfW7DZUHSaMfQgCOXOhwTbY/mEF
+wfM0nz5IWKPr+kjliMkOGHKizPhqBTwlCVPFw2sifV7305ON+yUptYczksjpv1dlw6SlUx
+xyTKkTbnV7n7YiNxwbTaLkHfD283zFH5ziMkU1fuiGh9NPzPE/sa80dR6EwnB0XLBojyJG
+VD39jJ4X4wb2G+MJik7UfgP22najOSSoK5xuFbW50rRlUp6n30bgrH4f/kiytQUAUhtB7Y
+It1YU9VUf/Z6S4ab1SL5w+BLVekZVnigr/lYCTzTo+tIvkEVCbbiGAaof6EO5Zs4q7D22z
+XPm0E9eZb6d2V8/vPWPA+gIjaTPseqEsnxj+2b6ewScPbYkHnI0oomTQwWIRAfrxpi+iyK
+c23mf4q6nAjyvRKXSVWDUAAAADAQABAAACAAu9AvS5tqbMcB9jzUhuKTRm1iGbpjJJcgsq
+X4NQzc/B2jYyu25olNMhoQvKxKR18nT7KlAh35FrEZKxwYm7VGxdG3RjF3wuyNZJP+2LqA
+3GcazRZHCTAmTLCmrsyWr/YAIjt50jAz66/gPU0M5ZBcepGhozDzJGIXkHAHzB9mmb9oER
+al0qtZcM9erbzCTGTy46Re46lVXq+zblNwJlQqFnJhTH8TPrwdijFcXblsmBeekP4qV/7f
+aQixPGP3y22i09GWfXRloVoyFEM7tb6w1gWWfKoKheBg3ltAXYyiOMw/ElNJCTYTDWLrbx
+xQAQ+moER7J65eUMVYblItd4dj5UpCoprRsLjujXETT92N0FNm1H5TH8tw3Yuiwvkisetc
+yo+kbe3JXD7UWNcW3y09zZ6cga/wc8KK6yiK+hd4zw4+rMB1LB/gtT8PmBHXUA4MvvQTvv
+rlLFR6NYDIR8+V0UmOfXKyQu14pUyReHwv6WOEtM5SfzIZonXV/uICcle+k+OjNs5btO5V
+oaDNWV9rqA+6ec0nPC/vMUlxlTg+kM2KX9lhwP7li8OzwberUcu7s1CxKuBJfFKXyrV+Yo
+ZRHurlHSrlGkJH5KlA2TvixZjiF2CoRwJ6opFJMNyTNJkT7G7iFHBXX0rEsiwg2HqPzEOe
+x9AnLUPWmiIkW6tyjlAAABADgR9qHep88KTbiyj+YgCVapkrCGQ7K9MAqjUf32mZhcWwv+
+iDZn6AF5UTq4BuKgOt8snwShWnUHjC6HyxdTfAyC2U2Xjjc/hkL6st1V5b1B2iCweaKG4j
+rnGUMqqvDrIA9H3lDfxNeKpfW9VympD4gtWkbXMQ9WqrSLihG5UzJOWvdXAVW3+sDDRXJY
+kAqhBqA7pDYSFHOgNVJhEkKR/qnHI1CZn4Ts+OqSMwBssMTuwHvcfKWCgYlUBBQgD06vu6
++q9SSl8k15+b6vfu5Nk38j0E+Z3oqW4ZrBu+a1B5BelzGYud+b+X5yii19yXVoPAfvOcZb
+wqqhnwDV3H6CHowAAAEBAODjL55u3FZsrmO0WakDDXpkBRTJF0LQnm6sl/D+TRuSTtURu3
+KKm/LAT673heS90c3PP5Ja6aFwwZ+BTtqlX51CI/8kmqOWm25I03NXUfexbajm7tNEDHXt
+SR2Db4HlzBK4Rv5f0ORQj9rrBOvaF4xkUl2P4l+Cm3McErVRNAB9E6Kvhpq6/OrzUOGudy
+owYeC37CdjfGdVE73lP305hdu1bPdsHQkupB6PzG8QtfzvqGc2LPWS1BsgGWiHD/w8dqRO
+WnY8xycZE5M8dIXPuPN6VNQGkVVUmREb0UcKwXnCaDwfSGxed1F2N60rggtK4BlZcvZSK8
+mQK2xaRQGB9lsAAAEBAMi3VGhXgXmiXRghB8opmA4zUwRfOUjlwTj9akO87Wz1nvag8+Xt
+3j1dtb7CECIGobLuUTyrcbPdPB7JeibsVxEYposQqIqZ9YBWXrN6ciVzyFfq+SqEyKTizg
+ir2aXbZLLeo5EP40H0PiDCPMKeiK5bkrGE0+tEK4mhUdG4tlqSS2quG+GgGXNW2799wX6p
+vH9Ir1B1CDNmvIm9n6CG70+FIvKlr0AeSHyWJDc389ktTqsa3QrzPmMIookKpoLhnvmo0P
+P1qLB02rdTZrFxUGRxvGkb0O/1dK3SBfl35+wIsKOZF/O1iE+5fRWNU6CHSv+ng5A5UHwE
+J+0Afmn80K8AAAAYaGFzc2FuLmtod2lsZWhAZ21haWwuY29tAQID
+-----END OPENSSH PRIVATE KEY-----

hassan_github.pub

@@ -0,0 +1 @@
+ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAACAQCwUonBBaeqR99d0Td2MqyJxZc7bNTAqx3IwJylA2keyOby2nwbOd4RoRLrCsNX3xQQDgpnKXc+wtwiskTaysppWmhph7VSkmVWFOaj6gguYfSS3jfbWrXDphAxPZIHrJ9zZeeGHBG0cLM+EYXKAjy109zA/gc8knBBRlK3zBUZE4umGtcFKu+dk0XfIAlr7ij8n5sbqosW9epmeN2I57XBjn3ptGzkp64czjVzJFuY+1SVI/NoTLc2ifutOnSz6wvqmYg9iBRDl90zLyy+Umd2MgmDfjycd9bsNlQdJox9CAI5c6HBNtj+YQXB8zSfPkhYo+v6SOWIyQ4YcqLM+GoFPCUJU8XDayJ9XvfTk437JSm1hzOSyOm/V2XDpKVTHHJMqRNudXuftiI3HBtNouQd8PbzfMUfnOIyRTV+6IaH00/M8T+xrzR1HoTCcHRcsGiPIkZUPf2MnhfjBvYb4wmKTtR+A/badqM5JKgrnG4VtbnStGVSnqffRuCsfh/+SLK1BQBSG0Htgi3VhT1VR/9npLhpvVIvnD4EtV6RlWeKCv+VgJPNOj60i+QRUJtuIYBqh/oQ7lmzirsPbbNc+bQT15lvp3ZXz+89Y8D6AiNpM+x6oSyfGP7Zvp7BJw9tiQecjSiiZNDBYhEB+vGmL6LIpzbeZ/irqcCPK9EpdJVYNQ== [email protected]

pdf_processor.py

@@ -0,0 +1,318 @@
+import PyPDF2
+import pytesseract
+from pdf2image import convert_from_bytes
+import arabic_reshaper
+from bidi.algorithm import get_display
+from transformers import pipeline
+from langchain.text_splitter import RecursiveCharacterTextSplitter
+import io
+import os
+from typing import List, Dict
+from agents import create_judge_agent, create_advocate_agent
+from crewai import Task, Crew
+
+class PDFProcessor:
+    def __init__(self):
+        self.text_splitter = RecursiveCharacterTextSplitter(
+            chunk_size=500,  # Reduced chunk size for better memory management
+            chunk_overlap=50,
+            length_function=len,
+            separators=["\n\n", "\n", " ", ""]
+        )
+        # Initialize models with better memory management
+        self.summarizer = pipeline(
+            "summarization",
+            model="facebook/bart-large-cnn",
+            device_map="auto",  # Automatically choose best device
+            torch_dtype=torch.float32,  # Use float32 for better memory efficiency
+            batch_size=1  # Process one chunk at a time
+        )
+        self.progress_callback = None
+        
+        # Configure torch for memory efficiency
+        if torch.backends.mps.is_available():  # For Mac M1/M2
+            torch.backends.mps.set_per_process_memory_fraction(0.7)  # Use only 70% of available memory
+        elif torch.cuda.is_available():  # For CUDA devices
+            torch.cuda.empty_cache()
+            torch.cuda.set_per_process_memory_fraction(0.7)
+        
+    def set_progress_callback(self, callback):
+        """Set a callback function to report progress."""
+        self.progress_callback = callback
+        
+    def update_progress(self, message: str, progress: float):
+        """Update progress through callback if available."""
+        if self.progress_callback:
+            self.progress_callback(message, progress)
+
+    def extract_text_from_pdf(self, pdf_bytes: bytes) -> str:
+        """Extract text from PDF, handling both searchable and scanned PDFs with improved accuracy."""
+        text = ""
+        try:
+            # Try to extract text directly first using PyPDF2
+            pdf_reader = PyPDF2.PdfReader(io.BytesIO(pdf_bytes))
+            extracted_text = []
+            
+            for page in pdf_reader.pages:
+                page_text = page.extract_text()
+                if page_text.strip():
+                    extracted_text.append(page_text)
+
+            # If direct extraction yielded results, process it
+            if extracted_text:
+                text = "\n\n".join(extracted_text)
+            else:
+                # If no text was extracted, use OCR with improved settings
+                images = convert_from_bytes(pdf_bytes, dpi=300)  # Higher DPI for better quality
+                for image in images:
+                    # Configure tesseract for better Arabic text recognition
+                    custom_config = r'--oem 1 --psm 3 -l ara+eng'
+                    page_text = pytesseract.image_to_string(
+                        image,
+                        config=custom_config,
+                        lang='ara+eng'
+                    )
+                    if page_text.strip():
+                        extracted_text.append(page_text)
+                
+                text = "\n\n".join(extracted_text)
+
+            # Clean up the text
+            text = self._clean_text(text)
+            
+            # Handle Arabic text with improved reshaping
+            text = self._process_arabic_text(text)
+
+        except Exception as e:
+            raise Exception(f"Error processing PDF: {str(e)}")
+
+        return text
+
+    def _clean_text(self, text: str) -> str:
+        """Clean and normalize extracted text."""
+        # Remove control characters
+        text = "".join(char for char in text if char.isprintable() or char in "\n\r\t")
+        
+        # Normalize whitespace
+        text = re.sub(r'\s+', ' ', text)
+        text = re.sub(r'\n\s*\n', '\n\n', text)
+        
+        # Fix common OCR issues
+        text = re.sub(r'(?<=[a-z])(?=[A-Z])', ' ', text)
+        text = re.sub(r'([.!?])\s*(?=[A-Z])', r'\1\n', text)
+        
+        # Remove empty lines and extra whitespace
+        lines = [line.strip() for line in text.split('\n')]
+        text = '\n'.join(line for line in lines if line)
+        
+        return text.strip()
+
+    def _process_arabic_text(self, text: str) -> str:
+        """Process Arabic text with improved handling."""
+        try:
+            # Configure arabic-reshaper for better text handling
+            configuration = {
+                'delete_harakat': False,
+                'support_ligatures': True,
+                'RIAL SIGN': True
+            }
+            
+            # Reshape Arabic text
+            reshaped_text = arabic_reshaper.reshape(text, configuration=configuration)
+            
+            # Apply bidirectional algorithm
+            text = get_display(reshaped_text)
+            
+            # Fix common Arabic text issues
+            text = re.sub(r'([ء-ي])\s+([ء-ي])', r'\1\2', text)  # Remove spaces between Arabic letters
+            text = re.sub(r'[\u200B-\u200F\u202A-\u202E]', '', text)  # Remove Unicode control characters
+            
+            return text
+        except Exception as e:
+            print(f"Warning: Error in Arabic text processing: {str(e)}")
+            return text  # Return original text if processing fails
+
+    def summarize_document(self, text: str) -> str:
+        """Generate a summary of the document with improved memory management."""
+        try:
+            # Split text into smaller chunks
+            chunks = self.text_splitter.split_text(text)
+            summaries = []
+            
+            # Process chunks in batches to manage memory
+            batch_size = 3  # Process 3 chunks at a time
+            for i in range(0, len(chunks), batch_size):
+                # Clear GPU/MPS memory before processing new batch
+                if torch.cuda.is_available():
+                    torch.cuda.empty_cache()
+                elif torch.backends.mps.is_available():
+                    # Force garbage collection for MPS
+                    import gc
+                    gc.collect()
+                
+                batch = chunks[i:i + batch_size]
+                for chunk in batch:
+                    try:
+                        # Generate summary with controlled length and parameters
+                        summary = self.summarizer(
+                            chunk,
+                            max_length=130,
+                            min_length=30,
+                            do_sample=False,
+                            num_beams=2,  # Reduced beam search for memory efficiency
+                            early_stopping=True
+                        )
+                        summaries.append(summary[0]['summary_text'])
+                    except Exception as e:
+                        print(f"Warning: Error summarizing chunk: {str(e)}")
+                        # If summarization fails, include a portion of the original text
+                        summaries.append(chunk[:200] + "...")
+                
+                # Update progress
+                self.update_progress(
+                    "جاري تلخيص المستند...",
+                    min(0.3 + (i / len(chunks)) * 0.4, 0.7)
+                )
+            
+            # Combine summaries intelligently
+            final_summary = " ".join(summaries)
+            
+            # Clean up the final summary
+            final_summary = self._clean_text(final_summary)
+            final_summary = self._process_arabic_text(final_summary)
+            
+            return final_summary
+            
+        except Exception as e:
+            print(f"Error in summarization: {str(e)}")
+            # Fallback to a simple extractive summary
+            return self._create_extractive_summary(text)
+
+    def _create_extractive_summary(self, text: str, sentences_count: int = 5) -> str:
+        """Create a simple extractive summary as a fallback method."""
+        try:
+            # Split text into sentences
+            sentences = re.split(r'[.!?]\s+', text)
+            
+            # Remove very short sentences and clean
+            sentences = [s.strip() for s in sentences if len(s.strip()) > 30]
+            
+            if not sentences:
+                return text[:500] + "..."  # Return truncated text if no good sentences
+            
+            # Score sentences based on position and length
+            scored_sentences = []
+            for i, sentence in enumerate(sentences):
+                score = 0
+                # Prefer sentences from the beginning and end of the document
+                if i < len(sentences) * 0.3:  # First 30%
+                    score += 2
+                elif i > len(sentences) * 0.7:  # Last 30%
+                    score += 1
+                
+                # Prefer medium-length sentences
+                if 50 <= len(sentence) <= 200:
+                    score += 1
+                
+                scored_sentences.append((score, sentence))
+            
+            # Sort by score and select top sentences
+            scored_sentences.sort(reverse=True)
+            selected_sentences = [s[1] for s in scored_sentences[:sentences_count]]
+            
+            # Sort sentences by their original order
+            selected_sentences.sort(key=lambda s: sentences.index(s))
+            
+            # Join sentences and clean
+            summary = ". ".join(selected_sentences)
+            summary = self._clean_text(summary)
+            summary = self._process_arabic_text(summary)
+            
+            return summary
+            
+        except Exception as e:
+            print(f"Error in extractive summary: {str(e)}")
+            return text[:500] + "..."  # Return truncated text as last resort
+            
+    def analyze_legal_issues(self, text: str) -> Dict:
+        """Analyze legal issues in the document using the Judge agent."""
+        judge_agent = create_judge_agent()
+        
+        task_description = f"""
+        تحليل المستند التالي وتحديد المخالفات القانونية المحتملة وفقاً للقوانين الإماراتية:
+        {text}
+
+        يجب أن يتضمن التحليل:
+        1. المخالفات القانونية المحتملة
+        2. المواد القانونية ذات الصلة
+        3. التوصيات للتصحيح
+        """
+
+        task = Task(
+            description=task_description,
+            agent=judge_agent,
+            expected_output="تحليل قانوني شامل للمخالفات والتوصيات"
+        )
+
+        crew = Crew(agents=[judge_agent], tasks=[task])
+        result = crew.kickoff()
+        return {"legal_analysis": result}
+
+    def map_to_uae_legislation(self, text: str) -> Dict:
+        """Map document content to relevant UAE laws and regulations."""
+        advocate_agent = create_advocate_agent()
+        
+        task_description = f"""
+        تحليل المستند التالي وربطه بالقوانين والتشريعات الإماراتية ذات الصلة:
+        {text}
+
+        يجب أن يتضمن التحليل:
+        1. القوانين الإماراتية ذات الصلة
+        2. المواد القانونية المحددة
+        3. التفسير القانوني للعلاقة
+        """
+
+        task = Task(
+            description=task_description,
+            agent=advocate_agent,
+            expected_output="خريطة تفصيلية للقوانين والتشريعات ذات الصلة"
+        )
+
+        crew = Crew(agents=[advocate_agent], tasks=[task])
+        result = crew.kickoff()
+        return {"legislation_mapping": result}
+
+    def process_document(self, pdf_bytes: bytes) -> Dict:
+        """Process the document through all steps with progress tracking."""
+        try:
+            # Extract text from PDF
+            self.update_progress("استخراج النص من المستند...", 0.1)
+            text = self.extract_text_from_pdf(pdf_bytes)
+            
+            if not text.strip():
+                raise ValueError("لم يتم العثور على نص قابل للقراءة في المستند")
+
+            # Generate summary
+            self.update_progress("إنشاء ملخص للمستند...", 0.3)
+            summary = self.summarize_document(text)
+
+            # Analyze legal issues
+            self.update_progress("تحليل القضايا القانونية...", 0.5)
+            legal_analysis = self.analyze_legal_issues(text)
+
+            # Map to UAE legislation
+            self.update_progress("ربط المستند بالتشريعات الإماراتية...", 0.7)
+            legislation_mapping = self.map_to_uae_legislation(text)
+
+            self.update_progress("اكتمل التحليل!", 1.0)
+
+            return {
+                "summary": summary,
+                "legal_analysis": legal_analysis["legal_analysis"],
+                "legislation_mapping": legislation_mapping["legislation_mapping"],
+                "raw_text": text  # Include raw text for translation if needed
+            }
+            
+        except Exception as e:
+            self.update_progress(f"حدث خطأ: {str(e)}", 0)
+            raise

requirements.txt

@@ -0,0 +1,27 @@
+# Core app dependencies
+streamlit>=1.20.0
+fastapi>=0.100.0,<1.0.0
+langchain>=0.94.0,<0.95.0
+openai>=0.27.0
+chromadb==0.4.24
+
+# PDF and OCR processing
+PyPDF2>=3.0.0
+pytesseract
+pdf2image
+reportlab
+
+# NLP and Transformers
+transformers>=4.30.0,<5.0.0
+torch>=2.0.0,<3.0.0
+sentencepiece
+sacremoses
+langdetect
+
+# Arabic text handling
+arabic-reshaper
+python-bidi
+python-docx
+
+# SQLite utilities
+sqlite-utils

style.css

@@ -0,0 +1,51 @@
+/* Arabic font and RTL support */
+@import url('https://fonts.googleapis.com/css2?family=Cairo:wght@400;700&display=swap');
+
+.rtl-text {
+    direction: rtl;
+    text-align: right;
+    font-family: 'Cairo', sans-serif;
+}
+
+/* Custom styling for the app */
+.stApp {
+    font-family: 'Cairo', sans-serif;
+}
+
+.stTextArea {
+    direction: rtl;
+}
+
+.stButton button {
+    font-family: 'Cairo', sans-serif;
+    direction: rtl;
+}
+
+.stTab {
+    font-family: 'Cairo', sans-serif;
+}
+
+/* Legal response formatting */
+.legal-response {
+    background-color: #f8f9fa;
+    border-radius: 5px;
+    padding: 15px;
+    margin: 10px 0;
+    border-right: 4px solid #2e7d32;
+}
+
+.legal-reference {
+    color: #1976d2;
+    font-weight: bold;
+}
+
+/* Category badges */
+.category-badge {
+    background-color: #e3f2fd;
+    color: #1976d2;
+    padding: 5px 10px;
+    border-radius: 15px;
+    font-size: 0.8em;
+    margin: 5px;
+    display: inline-block;
+}

translator.py

@@ -0,0 +1,222 @@
+from transformers import MarianMTModel, MarianTokenizer, pipeline
+import torch
+from langdetect import detect
+import re
+
+class Translator:
+    def __init__(self):
+        self.models = {}
+        self.tokenizers = {}
+        self.language_codes = {
+            'arabic': 'ar',
+            'english': 'en',
+            'chinese': 'zh',
+            'hindi': 'hi',
+            'urdu': 'ur'
+        }
+        
+        # Initialize models for each language pair
+        self._load_model('en', 'ar')  # English to Arabic
+        self._load_model('ar', 'en')  # Arabic to English
+        # Add other language pairs as needed
+        
+    def _load_model(self, src_lang, tgt_lang):
+        """Load translation model for a specific language pair."""
+        model_name = f'Helsinki-NLP/opus-mt-{src_lang}-{tgt_lang}'
+        key = f'{src_lang}-{tgt_lang}'
+        
+        if key not in self.models:
+            try:
+                self.tokenizers[key] = MarianTokenizer.from_pretrained(model_name)
+                self.models[key] = MarianMTModel.from_pretrained(model_name)
+            except Exception as e:
+                print(f"Error loading model for {key}: {str(e)}")
+                
+    def translate(self, text: str, source_lang: str, target_lang: str) -> str:
+        """Translate text from source language to target language with improved handling."""
+        src_code = self.language_codes.get(source_lang.lower())
+        tgt_code = self.language_codes.get(target_lang.lower())
+        
+        if not src_code or not tgt_code:
+            raise ValueError("Unsupported language")
+            
+        key = f'{src_code}-{tgt_code}'
+        
+        if key not in self.models:
+            self._load_model(src_code, tgt_code)
+            
+        if key not in self.models:
+            raise ValueError(f"Translation model not available for {source_lang} to {target_lang}")
+            
+        tokenizer = self.tokenizers[key]
+        model = self.models[key]
+        
+        try:
+            # Preprocess text
+            text = self.preprocess_text(text)
+            
+            # Split text into manageable chunks
+            chunks = self._split_text_into_chunks(text)
+            translated_chunks = []
+            
+            for chunk in chunks:
+                # Clear GPU memory
+                if torch.cuda.is_available():
+                    torch.cuda.empty_cache()
+                
+                # Tokenize with improved settings
+                inputs = tokenizer(
+                    chunk,
+                    return_tensors="pt",
+                    padding=True,
+                    truncation=True,
+                    max_length=512,
+                    add_special_tokens=True
+                )
+                
+                # Generate translation with improved settings
+                with torch.no_grad():
+                    translated = model.generate(
+                        **inputs,
+                        num_beams=2,  # Reduced for memory efficiency
+                        length_penalty=0.6,
+                        max_length=512,
+                        min_length=0,
+                        early_stopping=True
+                    )
+                
+                # Decode the translation
+                result = tokenizer.batch_decode(translated, skip_special_tokens=True)[0]
+                translated_chunks.append(result)
+            
+            # Combine chunks
+            final_translation = ' '.join(translated_chunks)
+            
+            # Post-process translation
+            final_translation = self._post_process_translation(final_translation, target_lang)
+            
+            return final_translation
+            
+        except Exception as e:
+            print(f"Translation error: {str(e)}")
+            return text  # Return original text if translation fails
+        
+    def detect_language(self, text: str) -> str:
+        """Detect the language of the input text."""
+        try:
+            # Clean text for better detection
+            cleaned_text = re.sub(r'[^\w\s]', '', text)
+            detected = detect(cleaned_text)
+            
+            # Map detected language code to our supported languages
+            lang_code_map = {
+                'ar': 'arabic',
+                'en': 'english',
+                'zh': 'chinese',
+                'hi': 'hindi',
+                'ur': 'urdu'
+            }
+            
+            return lang_code_map.get(detected, 'english')  # Default to English if unknown
+        except:
+            return 'english'  # Default to English if detection fails
+    
+    def preprocess_text(self, text: str) -> str:
+        """Preprocess text before translation."""
+        # Remove excessive whitespace
+        text = re.sub(r'\s+', ' ', text).strip()
+        
+        # Remove special characters that might interfere with translation
+        text = re.sub(r'[^\w\s\.,!?-]', '', text)
+        
+        return text
+    
+    def get_supported_languages(self):
+        """Return list of supported languages."""
+        return list(self.language_codes.keys())
+        
+    def _split_text_into_chunks(self, text: str, max_chunk_size: int = 450) -> list:
+        """Split text into manageable chunks for translation."""
+        # First try to split by paragraphs
+        paragraphs = text.split('\n\n')
+        chunks = []
+        current_chunk = []
+        current_length = 0
+        
+        for para in paragraphs:
+            # If a single paragraph is too long, split it by sentences
+            if len(para) > max_chunk_size:
+                sentences = re.split(r'([.!?])\s+', para)
+                i = 0
+                while i < len(sentences):
+                    sentence = sentences[i]
+                    if i + 1 < len(sentences):
+                        sentence += sentences[i + 1]  # Add back the punctuation
+                        i += 2
+                    else:
+                        i += 1
+                        
+                    if current_length + len(sentence) > max_chunk_size:
+                        if current_chunk:
+                            chunks.append(' '.join(current_chunk))
+                            current_chunk = []
+                            current_length = 0
+                    
+                    current_chunk.append(sentence)
+                    current_length += len(sentence)
+            else:
+                if current_length + len(para) > max_chunk_size:
+                    chunks.append(' '.join(current_chunk))
+                    current_chunk = []
+                    current_length = 0
+                
+                current_chunk.append(para)
+                current_length += len(para)
+        
+        if current_chunk:
+            chunks.append(' '.join(current_chunk))
+        
+        return chunks
+
+    def _post_process_translation(self, text: str, target_lang: str) -> str:
+        """Post-process translated text based on target language."""
+        if target_lang.lower() in ['arabic', 'ar']:
+            # Fix Arabic-specific issues
+            text = re.sub(r'([ء-ي])\s+([ء-ي])', r'\1\2', text)  # Remove spaces between Arabic letters
+            text = re.sub(r'[\u200B-\u200F\u202A-\u202E]', '', text)  # Remove Unicode control characters
+            
+            # Fix common Arabic punctuation issues
+            text = text.replace('،,', '،')
+            text = text.replace('.,', '.')
+            text = text.replace('؟?', '؟')
+            text = text.replace('!!', '!')
+            
+            # Ensure proper spacing around numbers and Latin text
+            text = re.sub(r'([0-9])([ء-ي])', r'\1 \2', text)
+            text = re.sub(r'([ء-ي])([0-9])', r'\1 \2', text)
+            text = re.sub(r'([a-zA-Z])([ء-ي])', r'\1 \2', text)
+            text = re.sub(r'([ء-ي])([a-zA-Z])', r'\1 \2', text)
+            
+        elif target_lang.lower() in ['english', 'en']:
+            # Fix English-specific issues
+            text = re.sub(r'\s+([.,!?])', r'\1', text)  # Fix spacing before punctuation
+            text = re.sub(r'([.,!?])(?=[^\s])', r'\1 ', text)  # Fix spacing after punctuation
+            text = re.sub(r'\s+', ' ', text)  # Normalize spaces
+            text = text.replace(' ,', ',')
+            text = text.replace(' .', '.')
+            
+            # Capitalize first letter of sentences
+            text = '. '.join(s.capitalize() for s in text.split('. '))
+            
+        return text.strip()
+
+    def get_language_name(self, code: str) -> str:
+        """Get the display name for a language code."""
+        names = {
+            'ar': 'العربية',
+            'en': 'English',
+            'zh': '中文',
+            'hi': 'हिंदी',
+            'ur': 'اردو'
+        }
+        return names.get(code, code)

utils.py

@@ -0,0 +1,51 @@
+from typing import List, Dict
+import re
+from langchain.tools import Tool
+from config import UAE_LEGAL_DOMAINS
+
+def is_arabic(text: str) -> bool:
+    """Check if the text contains Arabic characters."""
+    arabic_pattern = re.compile('[\u0600-\u06FF\u0750-\u077F\u08A0-\u08FF]+')
+    return bool(arabic_pattern.search(text))
+
+def create_uae_legal_tools() -> List[Tool]:
+    """Create tools for UAE legal research."""
+    tools = [
+        Tool(
+            name="UAE Legal Database Search",
+            func=lambda q: search_uae_legal_database(q),
+            description="Search UAE legal databases for laws, regulations, and precedents"
+        ),
+        Tool(
+            name="Arabic Legal Term Translation",
+            func=lambda q: translate_legal_term(q),
+            description="Translate legal terms between Arabic and English"
+        ),
+        Tool(
+            name="UAE Case Law Search",
+            func=lambda q: search_uae_case_law(q),
+            description="Search UAE case law and legal precedents"
+        )
+    ]
+    return tools
+
+def search_uae_legal_database(query: str) -> str:
+    """Simulate searching UAE legal databases."""
+    # In a real implementation, this would connect to actual UAE legal databases
+    return f"Found relevant UAE legal information for: {query}"
+
+def translate_legal_term(term: str) -> str:
+    """Simulate legal term translation."""
+    # In a real implementation, this would use a legal terms dictionary
+    return f"Translation for: {term}"
+
+def search_uae_case_law(query: str) -> str:
+    """Simulate searching UAE case law."""
+    # In a real implementation, this would search actual UAE case law databases
+    return f"Found relevant UAE case law for: {query}"
+
+def format_legal_response(response: str, language: str = 'ar') -> str:
+    """Format legal responses with proper styling and language direction."""
+    if language == 'ar':
+        return f'<div dir="rtl">{response}</div>'
+    return response