Update modules/document_processor.py

modules/document_processor.py

@@ -11,7 +11,7 @@ from datetime import datetime
 import docx
 import PyPDF2
 import fitz  # PyMuPDF
-import textract
+import pdfplumber
 import mammoth
 from openpyxl import load_workbook
 from PIL import Image
@@ -50,121 +50,15 @@ class DocumentProcessor:
         # الكلمات التوقفية في اللغة العربية
         self.arabic_stopwords = set(stopwords.words('arabic'))
         
-        # تعريف أنماط التعبيرات المنتظمة
-        self.regex_patterns = {
-            "money": r'(\d[\d,.]*)\s*(ريال|ر\.س|SAR|ر\.س\.)',
-            "percentage": r'(\d[\d,.]*)\s*(%|في المائة|في المئة|بالمائة|بالمئة)',
-            "date": r'(\d{1,2})[/-](\d{1,2})[/-](\d{2,4})|(\d{1,2})\s+(يناير|فبراير|مارس|أبريل|مايو|يونيو|يوليو|أغسطس|سبتمبر|أكتوبر|نوفمبر|ديسمبر)\s+(\d{2,4})',
-            "email": r'[\w\.-]+@[\w\.-]+\.\w+',
-            "phone": r'([\+]?[\d]{1,3}[\s-]?)?(\d{3,4})[\s-]?(\d{3,4})[\s-]?(\d{3,4})',
-            "url": r'https?://(?:[-\w.]|(?:%[\da-fA-F]{2}))+'
-        }
-        
-        # قائمة بكلمات المناقصات الهامة
-        self.important_tender_terms = [
-            "مناقصة", "عطاء", "ترسية", "عقد", "مشروع", "تسليم", "اجتماع", "تمهيدي",
-            "ضمان", "كفالة", "ابتدائي", "نهائي", "غرامة", "غرامات", "جزائية", "صيانة",
-            "ضمان", "تمديد", "تأجيل", "إلغاء", "تعديل", "ملحق", "مصنع محلي", "مستورد",
-            "المحتوى المحلي", "التقييم الفني", "التقييم المالي", "العرض الفني", "العرض المالي"
-        ]
-        
-    def _load_tender_keywords(self) -> Dict[str, List[str]]:
-        """
-        تحميل الكلمات الدلالية المتعلقة بالمناقصات وتصنيفها
-        """
-        # في التطبيق الفعلي، قد تُحمل هذه الكلمات من ملف أو قاعدة بيانات
-        return {
-            "requirements": [
-                "متطلبات", "شروط", "مواصفات", "معايير", 
-                "يجب", "يتعين", "ضرورة", "إلزامي", "إلزامية",
-                "المتطلبات الفنية", "المتطلبات الإدارية", "الاشتراطات"
-            ],
-            "costs": [
-                "تكلفة", "تكاليف", "سعر", "أسعار", "ميزانية", 
-                "قيمة", "مالي", "مالية", "تمويل", "تقدير مالي",
-                "ريال", "ريال سعودي", "سعودي"
-            ],
-            "dates": [
-                "تاريخ", "مدة", "جدول زمني", "موعد", "مهلة",
-                "التسليم", "الاستحقاق", "بداية", "نهاية", "أيام",
-                "أسابيع", "شهور", "سنوات"
-            ],
-            "local_content": [
-                "محتوى محلي", "توطين", "نطاقات", "سعودة", 
-                "وطني", "محلية", "إنتاج محلي", "صناعة محلية",
-                "منتجات وطنية", "خدمات وطنية", "منشأ سعودي",
-                "رؤية 2030", "رؤية المملكة"
-            ],
-            "supply_chain": [
-                "سلسلة الإمداد", "توريد", "موردين", "مناولة", 
-                "لوجستيات", "مخزون", "مخازن", "شراء", "بضائع",
-                "سلسلة التوريد", "جدولة الإمداد", "الواردات"
-            ]
-        }
-    
-    def _load_common_requirements(self) -> List[Dict[str, Any]]:
-        """
-        تحميل قائمة المتطلبات الشائعة للمناقصات
-        """
-        # في التطبيق الفعلي، قد تُحمل هذه المتطلبات من ملف أو قاعدة بيانات
-        return [
-            {
-                "title": "شهادة الزكاة والدخل",
-                "category": "إدارية",
-                "keywords": ["زكاة", "ضريبة", "شهادة زكاة", "مصلحة الزكاة", "هيئة الزكاة", "إقرار ضريبي"]
-            },
-            {
-                "title": "السجل التجاري",
-                "category": "إدارية",
-                "keywords": ["سجل تجاري", "الغرفة التجارية", "رخصة تجارية", "وزارة التجارة"]
-            },
-            {
-                "title": "شهادة الاشتراك في التأمينات الاجتماعية",
-                "category": "إدارية",
-                "keywords": ["تأمينات", "تأمينات اجتماعية", "مؤسسة التأمينات", "تأمين اجتماعي"]
-            },
-            {
-                "title": "تصنيف المقاولين",
-                "category": "فنية",
-                "keywords": ["تصنيف", "شهادة تصنيف", "المقاولين", "وزارة الإسكان", "وزارة الشؤون البلدية"]
-            },
-            {
-                "title": "نسبة المحتوى المحلي",
-                "category": "محتوى محلي",
-                "keywords": ["محتوى محلي", "نسبة سعودة", "توطين", "نطاقات", "رؤية 2030"]
-            },
-            {
-                "title": "الخبرات السابقة",
-                "category": "فنية",
-                "keywords": ["خبرة", "خبرات سابقة", "مشاريع مماثلة", "أعمال سابقة", "سابقة أعمال"]
-            }
-        ]
-        
     def process_document(self, file_content: bytes, file_extension: str, file_name: str) -> Dict[str, Any]:
         """
         معالجة المستند وتحليله حسب نوعه
-        
-        المعاملات:
-        ----------
-        file_content : bytes
-            محتوى الملف بصيغة بايت
-        file_extension : str
-            امتداد الملف (pdf, docx, xlsx, csv, txt)
-        file_name : str
-            اسم الملف
-            
-        المخرجات:
-        --------
-        Dict[str, Any]
-            قاموس يحتوي على البيانات المستخرجة من المستند
         """
-        # تخزين المحتوى في ملف مؤقت
         with tempfile.NamedTemporaryFile(suffix=f".{file_extension}", delete=False) as temp_file:
             temp_file.write(file_content)
             temp_path = temp_file.name
         
         try:
-            # معالجة الملف حسب نوعه
             if file_extension.lower() == 'pdf':
                 extracted_data = self._process_pdf(temp_path)
             elif file_extension.lower() in ['docx', 'doc']:
@@ -178,834 +72,63 @@ class DocumentProcessor:
             else:
                 extracted_data = {"error": f"نوع الملف {file_extension} غير مدعوم"}
             
-            # إضافة معلومات أساسية عن الملف
             extracted_data["file_name"] = file_name
             extracted_data["file_type"] = file_extension
             extracted_data["processed_time"] = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
             
-            # تحليل إضافي للمحتوى المستخرج
-            if "text" in extracted_data:
-                self._analyze_text_content(extracted_data)
-            
             return extracted_data
             
         finally:
-            # حذف الملف المؤقت بعد الانتهاء
             if os.path.exists(temp_path):
                 os.remove(temp_path)
-                
+    
     def _process_pdf(self, file_path: str) -> Dict[str, Any]:
         """
         معالجة ملف PDF واستخراج النص والبيانات منه
         """
-        extracted_data = {
-            "text": "",
-            "metadata": {},
-            "images": [],
-            "tables": [],
-            "pages": []
-        }
-        
+        extracted_data = {"text": "", "metadata": {}, "images": [], "tables": [], "pages": []}
         try:
-            # استخراج النص باستخدام PyMuPDF (fitz)
-            doc = fitz.open(file_path)
-            
-            # استخراج البيانات الوصفية
-            extracted_data["metadata"] = doc.metadata
+            with pdfplumber.open(file_path) as pdf:
+                for page in pdf.pages:
+                    extracted_text = page.extract_text()
+                    if extracted_text:
+                        extracted_data["text"] += extracted_text + "\n"
             
-            # معالجة كل صفحة
-            for page_num, page in enumerate(doc):
-                page_text = page.get_text()
-                extracted_data["text"] += page_text
-                
-                # إضافة معلومات الصفحة
-                page_data = {
-                    "page_num": page_num + 1,
-                    "text": page_text,
-                    "dimensions": {"width": page.rect.width, "height": page.rect.height}
-                }
-                
-                # استخراج الصور
-                image_list = page.get_images(full=True)
-                page_images = []
-                for img_index, img in enumerate(image_list):
-                    xref = img[0]
-                    base_image = doc.extract_image(xref)
-                    image_info = {
-                        "index": img_index,
-                        "width": base_image["width"],
-                        "height": base_image["height"],
-                        "format": base_image["ext"]
-                    }
-                    page_images.append(image_info)
-                
-                page_data["images"] = page_images
-                
-                # استخراج الجداول (تقريبي - قد يحتاج لتحسين)
-                tables = []
-                # بالنسبة للجداول، نستخدم تعبير منتظم للبحث عن نمط من المسافات وعلامات الجدولة
-                # هذه طريقة بسيطة وقد تحتاج لتحسين باستخدام مكتبات متخصصة
-                table_pattern = re.compile(r'(.+?[\t|]{2,}.+?[\n\r]){3,}', re.DOTALL)
-                for match in table_pattern.finditer(page_text):
-                    tables.append(match.group(0))
-                
-                page_data["tables"] = tables
-                extracted_data["pages"].append(page_data)
-                
-                # جمع كل الجداول المستخرجة
-                extracted_data["tables"].extend(tables)
-            
-            # إذا لم نستطع استخراج نص باستخدام PyMuPDF، نجرب PyPDF2
-            if not extracted_data["text"].strip():
-                with open(file_path, 'rb') as pdf_file:
-                    pdf_reader = PyPDF2.PdfReader(pdf_file)
-                    for page_num in range(len(pdf_reader.pages)):
-                        page = pdf_reader.pages[page_num]
-                        extracted_data["text"] += page.extract_text()
-            
-            # إذا لم نستطع استخراج نص بعد، نجرب textract
             if not extracted_data["text"].strip():
-                extracted_data["text"] = textract.process(file_path).decode('utf-8', errors='ignore')
-                
-            # تحليل OCR إذا كان النص قليلاً أو غير موجود
-            if len(extracted_data["text"].strip()) < 100:
-                self._apply_ocr_to_pdf(file_path, extracted_data)
-                
+                extracted_data["text"] = self._apply_ocr_to_pdf(file_path)
         except Exception as e:
             extracted_data["error"] = f"خطأ في معالجة ملف PDF: {str(e)}"
-            
         return extracted_data
     
-    def _apply_ocr_to_pdf(self, file_path: str, extracted_data: Dict[str, Any]) -> None:
+    def _apply_ocr_to_pdf(self, file_path: str) -> str:
         """
         تطبيق OCR على ملف PDF لاستخراج النص من الصور
         """
         try:
             doc = fitz.open(file_path)
             ocr_text = ""
-            
-            for page_num, page in enumerate(doc):
-                # استخراج الصفحة كصورة
+            for page in doc:
                 pix = page.get_pixmap()
                 img_data = pix.tobytes("png")
-                
-                # فتح الصورة باستخدام PIL
                 with io.BytesIO(img_data) as img_stream:
                     img = Image.open(img_stream)
-                    
-                    # تطبيق OCR
-                    page_text = pytesseract.image_to_string(img, lang='ara+eng')
-                    ocr_text += page_text
-                    
-                    # إضافة النص المستخرج إلى بيانات الصفحة
-                    if page_num < len(extracted_data["pages"]):
-                        extracted_data["pages"][page_num]["ocr_text"] = page_text
-            
-            # إضافة النص المستخرج بواسطة OCR
-            extracted_data["ocr_text"] = ocr_text
-            
-            # إذا كان النص الأصلي فارغاً، استخدم نص OCR كبديل
-            if not extracted_data["text"].strip():
-                extracted_data["text"] = ocr_text
-                
+                    ocr_text += pytesseract.image_to_string(img, lang='ara+eng') + "\n"
+            return ocr_text
         except Exception as e:
-            extracted_data["ocr_error"] = f"خطأ في معالجة OCR: {str(e)}"
+            return f"خطأ في OCR: {str(e)}"
     
     def _process_docx(self, file_path: str) -> Dict[str, Any]:
         """
         معالجة ملف Word (DOCX) واستخراج النص والبيانات منه
         """
-        extracted_data = {
-            "text": "",
-            "metadata": {},
-            "images": [],
-            "tables": [],
-            "paragraphs": []
-        }
-        
+        extracted_data = {"text": "", "metadata": {}, "images": [], "tables": [], "paragraphs": []}
         try:
-            # استخراج النص من ملف DOCX
             doc = docx.Document(file_path)
-            
-            # استخراج النص الكامل
-            for para in doc.paragraphs:
-                if para.text.strip():
-                    extracted_data["text"] += para.text + "\n"
-                    extracted_data["paragraphs"].append({
-                        "text": para.text,
-                        "style": para.style.name if para.style else "Normal"
-                    })
-            
-            # استخراج الجداول
-            tables_data = []
-            for table_idx, table in enumerate(doc.tables):
-                table_data = []
-                for row_idx, row in enumerate(table.rows):
-                    row_data = []
-                    for cell_idx, cell in enumerate(row.cells):
-                        row_data.append(cell.text)
-                    table_data.append(row_data)
-                tables_data.append({
-                    "table_idx": table_idx,
-                    "data": table_data
-                })
-            extracted_data["tables"] = tables_data
-            
-            # استخراج البيانات الوصفية
-            doc_properties = doc.core_properties
-            extracted_data["metadata"] = {
-                "author": doc_properties.author,
-                "created": str(doc_properties.created) if doc_properties.created else None,
-                "modified": str(doc_properties.modified) if doc_properties.modified else None,
-                "title": doc_properties.title,
-                "subject": doc_properties.subject,
-                "keywords": doc_properties.keywords
-            }
-            
-            # تجربة استخدام mammoth للحصول على نص إضافي إذا لزم الأمر
+            extracted_data["text"] = "\n".join([para.text for para in doc.paragraphs if para.text.strip()])
             if not extracted_data["text"].strip():
                 with open(file_path, "rb") as docx_file:
                     result = mammoth.extract_raw_text(docx_file)
                     extracted_data["text"] = result.value
-            
         except Exception as e:
             extracted_data["error"] = f"خطأ في معالجة ملف DOCX: {str(e)}"
-            
-            # محاولة استخراج النص باستخدام textract كخطة بديلة
-            try:
-                extracted_data["text"] = textract.process(file_path).decode('utf-8', errors='ignore')
-            except:
-                pass
-                
-        return extracted_data
-    
-    def _process_excel(self, file_path: str) -> Dict[str, Any]:
-        """
-        معالجة ملف Excel واستخراج البيانات منه
-        """
-        extracted_data = {
-            "sheets": [],
-            "tables": [],
-            "text": ""
-        }
-        
-        try:
-            # قراءة الملف باستخدام pandas
-            xl = pd.ExcelFile(file_path)
-            sheet_names = xl.sheet_names
-            
-            # استخراج البيانات من كل ورقة
-            all_sheets_data = {}
-            for sheet_name in sheet_names:
-                df = pd.read_excel(xl, sheet_name)
-                sheet_data = df.fillna('').to_dict(orient='records')
-                all_sheets_data[sheet_name] = sheet_data
-                
-                # جمع النص لتحليل المحتوى
-                for row in sheet_data:
-                    for column, value in row.items():
-                        if isinstance(value, str) and value.strip():
-                            extracted_data["text"] += value + " "
-                
-                # إضافة معلومات الورقة
-                sheet_info = {
-                    "name": sheet_name,
-                    "rows": len(df),
-                    "columns": len(df.columns),
-                    "column_names": df.columns.tolist(),
-                    "data": sheet_data
-                }
-                extracted_data["sheets"].append(sheet_info)
-                
-                # إضافة كجدول
-                extracted_data["tables"].append({
-                    "sheet_name": sheet_name,
-                    "data": sheet_data
-                })
-            
-            # استخراج البيانات الوصفية باستخدام openpyxl
-            workbook = load_workbook(file_path, read_only=True)
-            extracted_data["metadata"] = {
-                "title": workbook.properties.title,
-                "author": workbook.properties.creator,
-                "created": str(workbook.properties.created) if workbook.properties.created else None,
-                "modified": str(workbook.properties.modified) if workbook.properties.modified else None,
-                "sheet_names": workbook.sheetnames
-            }
-            
-        except Exception as e:
-            extracted_data["error"] = f"خطأ في معالجة ملف Excel: {str(e)}"
-            
-        return extracted_data
-    
-    def _process_csv(self, file_path: str) -> Dict[str, Any]:
-        """
-        معالجة ملف CSV واستخراج البيانات منه
-        """
-        extracted_data = {
-            "headers": [],
-            "data": [],
-            "text": ""
-        }
-        
-        try:
-            # قراءة الملف بعدة ترميزات للتعامل مع الملفات العربية
-            encodings = ['utf-8', 'cp1256', 'iso-8859-6', 'utf-16']
-            df = None
-            
-            for encoding in encodings:
-                try:
-                    df = pd.read_csv(file_path, encoding=encoding)
-                    break
-                except:
-                    continue
-            
-            if df is None:
-                # محاولة أخيرة باستخدام ترميز لاتيني وتجاهل الأخطاء
-                df = pd.read_csv(file_path, encoding='latin1', errors='ignore')
-            
-            # استخراج البيانات
-            extracted_data["headers"] = df.columns.tolist()
-            extracted_data["data"] = df.fillna('').to_dict(orient='records')
-            
-            # جمع النص لتحليل المحتوى
-            for row in extracted_data["data"]:
-                for column, value in row.items():
-                    if isinstance(value, str) and value.strip():
-                        extracted_data["text"] += value + " "
-            
-            # إضافة معلومات إحصائية
-            extracted_data["stats"] = {
-                "rows": len(df),
-                "columns": len(df.columns)
-            }
-            
-        except Exception as e:
-            extracted_data["error"] = f"خطأ في معالجة ملف CSV: {str(e)}"
-            
-        return extracted_data
-    
-    def _process_txt(self, file_path: str) -> Dict[str, Any]:
-        """
-        معالجة ملف نص عادي واستخراج البيانات منه
-        """
-        extracted_data = {
-            "text": "",
-            "lines": []
-        }
-        
-        try:
-            # قراءة الملف بعدة ترميزات للتعامل مع الملفات العربية
-            encodings = ['utf-8', 'cp1256', 'iso-8859-6', 'utf-16']
-            text_content = None
-            
-            for encoding in encodings:
-                try:
-                    with open(file_path, 'r', encoding=encoding) as f:
-                        text_content = f.read()
-                    break
-                except:
-                    continue
-            
-            if text_content is None:
-                # محاولة أخيرة باستخدام ترميز لاتيني وتجاهل الأخطاء
-                with open(file_path, 'r', encoding='latin1', errors='ignore') as f:
-                    text_content = f.read()
-            
-            # إضافة النص والأسطر
-            extracted_data["text"] = text_content
-            extracted_data["lines"] = text_content.splitlines()
-            
-            # إضافة معلومات إحصائية
-            extracted_data["stats"] = {
-                "lines": len(extracted_data["lines"]),
-                "words": len(text_content.split()),
-                "chars": len(text_content)
-            }
-            
-        except Exception as e:
-            extracted_data["error"] = f"خطأ في معالجة ملف النص: {str(e)}"
-            
-        return extracted_data
-    
-    def _analyze_text_content(self, extracted_data: Dict[str, Any]) -> None:
-        """
-        تحليل محتوى النص المستخرج لاستخراج معلومات إضافية
-        مثل المتطلبات، وتفاصيل المناقصة، والمحتوى المحلي.
-        """
-        text = extracted_data["text"]
-        
-        # استخراج الكلمات الدلالية
-        keywords = {}
-        for category, terms in self.tender_keywords.items():
-            category_keywords = []
-            for term in terms:
-                pattern = re.compile(r'\b' + re.escape(term) + r'\b', re.IGNORECASE | re.MULTILINE)
-                matches = pattern.findall(text)
-                if matches:
-                    category_keywords.extend(matches)
-            keywords[category] = category_keywords
-        
-        extracted_data["keywords"] = keywords
-        
-        # استخراج المتطلبات المحتملة
-        requirements = self._extract_requirements(text)
-        extracted_data["requirements"] = requirements
-        
-        # استخراج البيانات المالية (أرقام، مبالغ، نسب مئوية)
-        financial_data = self._extract_financial_data(text)
-        extracted_data["financial_data"] = financial_data
-        
-        # استخراج التواريخ الهامة
-        dates = self._extract_dates(text)
-        extracted_data["dates"] = dates
-        
-        # استخراج معلومات المحتوى المحلي
-        local_content = self._extract_local_content_info(text)
-        extracted_data["local_content"] = local_content
-        
-        # استخراج معلومات سلسلة الإمداد
-        supply_chain = self._extract_supply_chain_info(text)
-        extracted_data["supply_chain"] = supply_chain
-        
-        # استخراج الجهات والأطراف المعنية
-        entities = self._extract_entities(text)
-        extracted_data["entities"] = entities
-    
-    def _extract_requirements(self, text: str) -> List[Dict[str, Any]]:
-        """
-        استخراج المتطلبات المحتملة من النص
-        """
-        requirements = []
-        
-        # البحث عن المتطلبات بناءً على كلمات دلالية
-        for req_keyword in self.tender_keywords["requirements"]:
-            # كلمات البداية للمتطلبات ونهايتها
-            pattern = re.compile(
-                r'(' + re.escape(req_keyword) + r'[^\n.]{0,100})([\n.].{0,500}?)(?:\n\n|\.\s|$)',
-                re.DOTALL | re.MULTILINE
-            )
-            matches = pattern.finditer(text)
-            
-            for match in matches:
-                title = match.group(1).strip()
-                description = match.group(2).strip()
-                
-                # تحديد الأهمية بناءً على وجود كلمات إلزامية
-                importance = "عادية"
-                for imp_word in ["يجب", "إلزامي", "ضروري", "لا بد", "إجباري"]:
-                    if imp_word in title.lower() or imp_word in description.lower():
-                        importance = "عالية"
-                        break
-                
-                # تحديد الفئة
-                category = "عامة"
-                for cat, words in [
-                    ("فنية", ["فني", "تقني", "مواصفات", "معايير", "أداء", "جودة"]),
-                    ("إدارية", ["إداري", "قانوني", "تنظيمي", "إجرائي", "شروط"]),
-                    ("مالية", ["مالي", "سعر", "تكلفة", "دفع", "تسعير", "ميزانية"]),
-                    ("محتوى محلي", ["محلي", "محتوى محلي", "توطين", "سعودة"]),
-                    ("زمنية", ["زمني", "موعد", "تاريخ", "مدة", "جدول"])
-                ]:
-                    for word in words:
-                        if word in title.lower() or word in description.lower():
-                            category = cat
-                            break
-                
-                # إضافة المتطلب
-                requirement = {
-                    "title": title,
-                    "description": description,
-                    "importance": importance,
-                    "category": category
-                }
-                requirements.append(requirement)
-        
-        # البحث عن المتطلبات من قائمة المتطلبات الشائعة
-        for common_req in self.common_requirements:
-            for keyword in common_req["keywords"]:
-                if keyword in text:
-                    # التحقق من أن المتطلب لم تتم إضافته بالفعل
-                    if not any(req["title"] == common_req["title"] for req in requirements):
-                        # العثور على الفقرة المتعلقة بهذا المتطلب
-                        pattern = re.compile(
-                            r'(.{0,100}' + re.escape(keyword) + r'.{0,200})',
-                            re.DOTALL | re.MULTILINE
-                        )
-                        match = pattern.search(text)
-                        
-                        description = match.group(1).strip() if match else "تم التعرف على المتطلب ولكن التفاصيل غير متاحة"
-                        
-                        requirement = {
-                            "title": common_req["title"],
-                            "description": description,
-                            "importance": "عالية",
-                            "category": common_req["category"],
-                            "is_common": True
-                        }
-                        requirements.append(requirement)
-                        break
-        
-        return requirements
-    
-    def _extract_financial_data(self, text: str) -> Dict[str, Any]:
-        """
-        استخراج البيانات المالية من النص
-        """
-        financial_data = {
-            "amounts": [],
-            "percentages": [],
-            "total_cost": None
-        }
-        
-        # استخراج المبالغ المالية
-        money_pattern = self.regex_patterns["money"]
-        money_matches = re.finditer(money_pattern, text)
-        
-        for match in money_matches:
-            amount = match.group(1)
-            currency = match.group(2)
-            
-            # تنظيف الرقم
-            amount = amount.replace(',', '')
-            try:
-                amount_value = float(amount)
-                financial_data["amounts"].append({
-                    "value": amount_value,
-                    "currency": currency,
-                    "original": match.group(0),
-                    "context": text[max(0, match.start() - 50):min(len(text), match.end() + 50)]
-                })
-            except:
-                pass
-        
-        # استخراج النسب المئوية
-        percentage_pattern = self.regex_patterns["percentage"]
-        percentage_matches = re.finditer(percentage_pattern, text)
-        
-        for match in percentage_matches:
-            percentage = match.group(1)
-            
-            # تنظيف الرقم
-            percentage = percentage.replace(',', '')
-            try:
-                percentage_value = float(percentage)
-                financial_data["percentages"].append({
-                    "value": percentage_value,
-                    "original": match.group(0),
-                    "context": text[max(0, match.start() - 50):min(len(text), match.end() + 50)]
-                })
-            except:
-                pass
-        
-        # محاولة تحديد التكلفة الإجمالية
-        total_cost_patterns = [
-            r'القيمة الإجمالية[^\d]*([\d.,]+)[^\d]*(ريال|ر\.س)',
-            r'إجمالي القيمة[^\d]*([\d.,]+)[^\d]*(ريال|ر\.س)',
-            r'المبلغ الإجمالي[^\d]*([\d.,]+)[^\d]*(ريال|ر\.س)',
-            r'قيمة العقد[^\d]*([\d.,]+)[^\d]*(ريال|ر\.س)',
-            r'قيمة المشروع[^\d]*([\d.,]+)[^\d]*(ريال|ر\.س)'
-        ]
-        
-        for pattern in total_cost_patterns:
-            match = re.search(pattern, text, re.IGNORECASE)
-            if match:
-                amount = match.group(1).replace(',', '')
-                try:
-                    amount_value = float(amount)
-                    financial_data["total_cost"] = {
-                        "value": amount_value,
-                        "currency": match.group(2),
-                        "original": match.group(0)
-                    }
-                    break
-                except:
-                    pass
-        
-        return financial_data
-    
-    def _extract_dates(self, text: str) -> List[Dict[str, Any]]:
-        """
-        استخراج التواريخ الهامة من النص
-        """
-        dates = []
-        
-        # استخراج التواريخ باستخدام التعبير المنتظم
-        date_pattern = self.regex_patterns["date"]
-        date_matches = re.finditer(date_pattern, text)
-        
-        # قاموس لتحويل أسماء الشهور العربية إلى أرقام
-        month_to_num = {
-            "يناير": 1, "فبراير": 2, "مارس": 3, "أبريل": 4, "مايو": 5, "يونيو": 6,
-            "يوليو": 7, "أغسطس": 8, "سبتمبر": 9, "أكتوبر": 10, "نوفمبر": 11, "ديسمبر": 12
-        }
-        
-        for match in date_matches:
-            try:
-                # التحقق من نوع التاريخ المستخرج (رقمي أو مع اسم الشهر)
-                if match.group(1):  # تاريخ رقمي بالكامل
-                    day = int(match.group(1))
-                    month = int(match.group(2))
-                    year = int(match.group(3))
-                    if year < 100:  # تحويل سنة مختصرة
-                        year += 2000 if year < 50 else 1900
-                else:  # تاريخ مع اسم الشهر
-                    day = int(match.group(4))
-                    month = month_to_num[match.group(5)]
-                    year = int(match.group(6))
-                    if year < 100:  # تحويل سنة مختصرة
-                        year += 2000 if year < 50 else 1900
-                
-                # التحقق من صحة التاريخ
-                if 1 <= day <= 31 and 1 <= month <= 12 and 1900 <= year <= 2100:
-                    date_str = f"{year}-{month:02d}-{day:02d}"
-                    
-                    # محاولة تحديد نوع التاريخ بناءً على السياق
-                    context = text[max(0, match.start() - 50):min(len(text), match.end() + 50)]
-                    
-                    date_type = "غير محدد"
-                    for date_keyword, date_type_value in [
-                        (["بداية", "بدء", "بدأ", "انطلاق"], "بداية"),
-                        (["نهاية", "انتهاء", "الانتهاء", "إغلاق"], "نهاية"),
-                        (["تسليم", "استلام", "توصيل"], "تسليم"),
-                        (["إصدار", "صدور", "إصدار", "نشر"], "إصدار"),
-                        (["اجتماع", "لقاء", "تمهيدي"], "اجتماع"),
-                        (["زيارة", "معاينة", "موقع"], "زيارة ميدانية")
-                    ]:
-                        for keyword in date_keyword:
-                            if keyword in context:
-                                date_type = date_type_value
-                                break
-                        if date_type != "غير محدد":
-                            break
-                    
-                    dates.append({
-                        "date": date_str,
-                        "original": match.group(0),
-                        "context": context,
-                        "type": date_type
-                    })
-            except:
-                pass
-        
-        return dates
-    
-    def _extract_local_content_info(self, text: str) -> Dict[str, Any]:
-        """
-        استخراج معلومات المحتوى المحلي من النص
-        """
-        local_content = {
-            "mentions": [],
-            "percentages": [],
-            "requirements": []
-        }
-        
-        # كلمات دلالية متعلقة بالمحتوى المحلي
-        keywords = [
-            "المحتوى المحلي", "محتوى محلي", "توطين", "سعودة", "نطاقات", 
-            "رؤية 2030", "رؤية المملكة", "النسبة المحلية", "الصناعة المحلية",
-            "سلسلة الإمداد المحلية", "المنتجات المحلية", "الخدمات المحلية"
-        ]
-        
-        # البحث عن ذكر المحتوى المحلي
-        for keyword in keywords:
-            pattern = re.compile(
-                r'(.{0,100}' + re.escape(keyword) + r'.{0,200})',
-                re.DOTALL | re.MULTILINE
-            )
-            matches = pattern.finditer(text)
-            
-            for match in matches:
-                local_content["mentions"].append({
-                    "keyword": keyword,
-                    "context": match.group(1).strip()
-                })
-        
-        # استخراج النسب المئوية المتعلقة بالمحتوى المحلي
-        for mention in local_content["mentions"]:
-            context = mention["context"]
-            
-            # البحث عن نسب مئوية في سياق المحتوى المحلي
-            percentage_pattern = self.regex_patterns["percentage"]
-            percentage_matches = re.finditer(percentage_pattern, context)
-            
-            for match in percentage_matches:
-                percentage = match.group(1)
-                
-                # تنظيف الرقم
-                percentage = percentage.replace(',', '')
-                try:
-                    percentage_value = float(percentage)
-                    local_content["percentages"].append({
-                        "value": percentage_value,
-                        "keyword": mention["keyword"],
-                        "original": match.group(0),
-                        "context": context
-                    })
-                except:
-                    pass
-        
-        # استخراج متطلبات المحتوى المحلي
-        requirement_patterns = [
-            r'يجب أن (يكون|تكون) نسبة المحتوى المحلي.{0,100}',
-            r'يتعين على (المورد|المقاول|المتعهد|الشركة).{0,100}محتوى محلي.{0,100}',
-            r'الحد الأدنى للمحتوى المحلي.{0,100}',
-            r'يلتزم (المورد|المقاول|المتعهد|الشركة).{0,100}محتوى محلي.{0,100}'
-        ]
-        
-        for pattern in requirement_patterns:
-            matches = re.finditer(pattern, text, re.IGNORECASE | re.DOTALL)
-            
-            for match in matches:
-                requirement = match.group(0).strip()
-                local_content["requirements"].append(requirement)
-        
-        return local_content
-    
-    def _extract_supply_chain_info(self, text: str) -> Dict[str, Any]:
-        """
-        استخراج معلومات سلسلة الإمداد من النص
-        """
-        supply_chain = {
-            "mentions": [],
-            "suppliers": [],
-            "materials": []
-        }
-        
-        # كلمات دلالية متعلقة بسلسلة الإمداد
-        keywords = [
-            "سلسلة الإمداد", "سلسلة التوريد", "موردين", "مناولة", "لوجستيات", 
-            "مخزون", "توريد", "استيراد", "تخزين", "خدمات لوجستية", "مواد",
-            "منتجات", "بضائع", "شحن", "نقل", "خدمات", "مصنع", "منتج محلي"
-        ]
-        
-        # البحث عن ذكر سلسلة الإمداد
-        for keyword in keywords:
-            pattern = re.compile(
-                r'(.{0,100}' + re.escape(keyword) + r'.{0,200})',
-                re.DOTALL | re.MULTILINE
-            )
-            matches = pattern.finditer(text)
-            
-            for match in matches:
-                supply_chain["mentions"].append({
-                    "keyword": keyword,
-                    "context": match.group(1).strip()
-                })
-        
-        # استخراج أسماء الموردين المحتملين
-        supplier_patterns = [
-            r'(شركة|مؤسسة|مصنع)\s+([^\n.,]{3,50})',
-            r'المورد\s+([^\n.,]{3,50})',
-            r'التوريد من\s+([^\n.,]{3,50})',
-            r'تصنيع بواسطة\s+([^\n.,]{3,50})'
-        ]
-        
-        for pattern in supplier_patterns:
-            matches = re.finditer(pattern, text, re.IGNORECASE)
-            
-            for match in matches:
-                supplier = match.group(1) + " " + match.group(2) if "شركة|مؤسسة|مصنع" in pattern else match.group(1)
-                supplier = supplier.strip()
-                
-                # تجنب الإضافات المزدوجة
-                if supplier not in [s["name"] for s in supply_chain["suppliers"]]:
-                    supply_chain["suppliers"].append({
-                        "name": supplier,
-                        "context": text[max(0, match.start() - 30):min(len(text), match.end() + 30)]
-                    })
-        
-        # استخراج المواد الخام أو المنتجات
-        materials_patterns = [
-            r'مواد\s+([^\n.,]{3,50})',
-            r'منتجات\s+([^\n.,]{3,50})',
-            r'توريد\s+([^\n.,]{3,50})',
-            r'استيراد\s+([^\n.,]{3,50})'
-        ]
-        
-        for pattern in materials_patterns:
-            matches = re.finditer(pattern, text, re.IGNORECASE)
-            
-            for match in matches:
-                material = match.group(1).strip()
-                
-                # تجنب الإضافات المزدوجة
-                if material not in [m["name"] for m in supply_chain["materials"]]:
-                    supply_chain["materials"].append({
-                        "name": material,
-                        "context": text[max(0, match.start() - 30):min(len(text), match.end() + 30)]
-                    })
-        
-        return supply_chain
-    
-    def _extract_entities(self, text: str) -> Dict[str, List[Dict[str, str]]]:
-        """
-        استخراج الجهات والأطراف المعنية من النص
-        """
-        entities = {
-            "organizations": [],
-            "persons": [],
-            "locations": []
-        }
-        
-        # استخراج المنظمات
-        org_patterns = [
-            r'(وزارة|هيئة|شركة|مؤسسة|جامعة|معهد|مركز|بلدية|أمانة)\s+([^\n.,]{3,50})',
-            r'(جهة|جهات)\s+(حكومية|منفذة|مشرفة|متعاقدة|مالكة)'
-        ]
-        
-        for pattern in org_patterns:
-            matches = re.finditer(pattern, text, re.IGNORECASE)
-            
-            for match in matches:
-                org_name = match.group(0).strip()
-                
-                # تجنب الإضافات المزدوجة
-                if org_name not in [org["name"] for org in entities["organizations"]]:
-                    entities["organizations"].append({
-                        "name": org_name,
-                        "context": text[max(0, match.start() - 30):min(len(text), match.end() + 30)]
-                    })
-        
-        # استخراج الأشخاص (بسيط - يمكن تحسينه)
-        person_patterns = [
-            r'(المهندس|الدكتور|الأستاذ|السيد|الشيخ|المدير|الرئيس)\s+([^\n.,]{3,50})',
-            r'(مدير|رئيس|مسؤول|منسق|مشرف)\s+(المشروع|العقد|الموقع|العملية)'
-        ]
-        
-        for pattern in person_patterns:
-            matches = re.finditer(pattern, text, re.IGNORECASE)
-            
-            for match in matches:
-                person_name = match.group(0).strip()
-                
-                # تجنب الإضافات المزدوجة
-                if person_name not in [p["name"] for p in entities["persons"]]:
-                    entities["persons"].append({
-                        "name": person_name,
-                        "context": text[max(0, match.start() - 30):min(len(text), match.end() + 30)]
-                    })
-        
-        # استخراج المواقع
-        location_patterns = [
-            r'مدينة\s+([^\n.,]{3,50})',
-            r'محافظة\s+([^\n.,]{3,50})',
-            r'منطقة\s+([^\n.,]{3,50})',
-            r'حي\s+([^\n.,]{3,50})',
-            r'موقع (المشروع|العمل|التنفيذ)'
-        ]
-        
-        for pattern in location_patterns:
-            matches = re.finditer(pattern, text, re.IGNORECASE)
-            
-            for match in matches:
-                location_name = match.group(0).strip()
-                
-                # تجنب الإضافات المزدوجة
-                if location_name not in [loc["name"] for loc in entities["locations"]]:
-                    entities["locations"].append({
-                        "name": location_name,
-                        "context": text[max(0, match.start() - 30):min(len(text), match.end() + 30)]
-                    })
-        
-        return entities
+        return extracted_data