Update app.py

app.py

@@ -2,17 +2,20 @@ import gradio as gr
 import pandas as pd
 import json
 import os
-from typing import Dict, List, Optional
+import re
+import math
+from typing import Dict, List, Optional, Union
 
-# مسیر ذخیره دیتابیس
+# تنظیمات پایه
 DB_PATH = "material_db.json"
+os.environ["TOKENIZERS_PARALLELISM"] = "false"
 
 class ElectricPoleEstimator:
     def __init__(self):
-        # ایجاد فایل دیتابیس اگر وجود ندارد
         self._initialize_db()
         self.db = self._load_db()
         self.rule_engine = RuleEngine()
+        self.nlp_processor = NLPProcessor()
         
     def _initialize_db(self):
         """ایجاد فایل دیتابیس اولیه"""
@@ -49,7 +52,10 @@ class ElectricPoleEstimator:
                     'quantity_expr': str(row['تعداد']) if pd.notna(row['تعداد']) else None,
                     'pole_height': float(row['ارتفاع پایه']) if pd.notna(row['ارتفاع پایه']) else None,
                     'pole_capacity': float(row['توان پایه']) if pd.notna(row['توان پایه']) else None,
-                    'conductor_type': row['نوع هادی'] if pd.notna(row['نوع هادی']) else None
+                    'conductor_type': row['نوع هادی'] if pd.notna(row['نوع هادی']) else None,
+                    'conditions': self._parse_conditions(row),
+                    'description': row['عنوان'],  # استفاده از عنوان به عنوان توضیحات اولیه
+                    'keywords': self._generate_keywords(row['عنوان'])
                 }
                 new_items.append(item)
             
@@ -59,76 +65,176 @@ class ElectricPoleEstimator:
         except Exception as e:
             return f"❌ خطا: {str(e)}"
 
+    def _parse_conditions(self, row) -> Optional[Dict]:
+        """استخراج شرایط از ردیف اکسل"""
+        conditions = {}
+        if pd.notna(row['تعداد']) and '=' in str(row['تعداد']):
+            conditions.update({
+                'type': 'formula',
+                'formula': str(row['تعداد'])[1:] if str(row['تعداد']).startswith('=') else str(row['تعداد'])
+            })
+        return conditions if conditions else None
+
+    def _generate_keywords(self, text: str) -> List[str]:
+        """تولید کلمات کلیدی از عنوان"""
+        persian_keywords = re.findall(r'[\w\-]+', text)
+        return list(set(persian_keywords))
+
     def estimate(self, 
                 pole_height: Optional[float] = None, 
                 pole_capacity: Optional[float] = None,
                 conductor_type: Optional[str] = None,
                 config_type: Optional[str] = None) -> List[Dict]:
-        """محاسبه برآورد"""
+        """محاسبه برآورد پارامتریک"""
         context = {
             'pole_height': pole_height,
             'pole_capacity': pole_capacity,
             'conductor_type': conductor_type,
             'configuration': config_type
         }
+        return self._estimate_with_context(context)
+
+    def estimate_from_text(self, project_description: str) -> Dict:
+        """محاسبه برآورد از توضیحات متنی"""
+        features = self.nlp_processor.extract_features(project_description)
+        context = self.rule_engine.apply_rules(features)
+        estimates = self._estimate_with_context(context)
         
-        # اعمال قوانین
-        overrides = self.rule_engine.apply_rules(context)
-        context.update(overrides)
-        
+        return {
+            'extracted_features': features,
+            'estimates': estimates
+        }
+
+    def _estimate_with_context(self, context: Dict) -> List[Dict]:
+        """هسته اصلی محاسبه برآورد"""
         results = []
         for item in self.db:
-            if self._is_item_required(item, **context):
+            if self._is_item_required(item, context):
                 qty = self._calculate_quantity(item, context)
                 results.append({
-                    'کد': item['code'],
-                    'عنوان': item['title'],
-                    'مقدار': qty,
-                    'واحد': item['unit'],
-                    'شرایط': self._format_conditions(item)
+                    'code': item['code'],
+                    'title': item['title'],
+                    'quantity': qty,
+                    'unit': item['unit'],
+                    'conditions': self._format_conditions(item, context)
                 })
         return results
 
-    def _is_item_required(self, item: Dict, **context) -> bool:
-        """بررسی نیاز به آیتم"""
-        height_ok = (item['pole_height'] is None) or (item['pole_height'] == context.get('pole_height'))
-        capacity_ok = (item['pole_capacity'] is None) or (item['pole_capacity'] == context.get('pole_capacity'))
-        conductor_ok = (item['conductor_type'] is None) or (item['conductor_type'] == context.get('conductor_type'))
-        return height_ok and capacity_ok and conductor_ok
+    def _is_item_required(self, item: Dict, context: Dict) -> bool:
+        """بررسی نیاز به آیتم براساس شرایط"""
+        # شرایط عمومی
+        height_ok = (item.get('pole_height') is None) or (item.get('pole_height') == context.get('pole_height'))
+        capacity_ok = (item.get('pole_capacity') is None) or (item.get('pole_capacity') == context.get('pole_capacity'))
+        conductor_ok = (item.get('conductor_type') is None) or (item.get('conductor_type') == context.get('conductor_type'))
+        
+        # شرایط پیشرفته
+        advanced_ok = True
+        if 'conditions' in item and item['conditions']:
+            if item['conditions']['type'] == 'formula':
+                try:
+                    advanced_ok = eval(item['conditions'].get('rule', 'True'), {}, context)
+                except:
+                    advanced_ok = True
+        
+        return height_ok and capacity_ok and conductor_ok and advanced_ok
 
     def _calculate_quantity(self, item: Dict, context: Dict) -> float:
-        """محاسبه مقدار"""
-        if not item['quantity_expr']:
-            return 1.0
+        """محاسبه مقدار با پشتیبانی از تمام حالت‌ها"""
         try:
-            if item['quantity_expr'].startswith('='):
-                return eval(item['quantity_expr'][1:], {}, context)
-            return float(item['quantity_expr'])
+            # فرمول‌های پیشرفته
+            if 'conditions' in item and item['conditions']:
+                if item['conditions']['type'] == 'formula':
+                    return eval(item['conditions']['formula'], {'math': math}, context)
+            
+            # فرمول‌های ساده
+            if item.get('quantity_expr'):
+                if item['quantity_expr'].startswith('='):
+                    return eval(item['quantity_expr'][1:], {}, context)
+                return float(item['quantity_expr'])
         except:
-            return 1.0
+            pass
+        return 1.0
 
-    def _format_conditions(self, item: Dict) -> str:
+    def _format_conditions(self, item: Dict, context: Dict) -> str:
         """قالب‌بندی شرایط برای نمایش"""
         conditions = []
-        if item['pole_height']: conditions.append(f"ارتفاع: {item['pole_height']}m")
-        if item['pole_capacity']: conditions.append(f"توان: {item['pole_capacity']}kVA")
-        if item['conductor_type']: conditions.append(f"هادی: {item['conductor_type']}")
-        return " - ".join(conditions) if conditions else "عمومی"
+        if item.get('pole_height'): conditions.append(f"ارتفاع: {item['pole_height']}m")
+        if item.get('pole_capacity'): conditions.append(f"توان: {item['pole_capacity']}kVA")
+        if item.get('conductor_type'): conditions.append(f"هادی: {item['conductor_type']}")
+        
+        # نمایش فرمول اگر وجود دارد
+        if 'conditions' in item and item['conditions']:
+            if item['conditions']['type'] == 'formula':
+                conditions.append(f"فرمول: {item['conditions']['formula']}")
+        
+        return " | ".join(conditions) if conditions else "عمومی"
+
+class NLPProcessor:
+    """پردازشگر هوشمند متن ورودی"""
+    def __init__(self):
+        self.keyword_rules = {
+            'مینک': ['مینک', 'mink'],
+            'هاینا': ['هاینا', 'haina'],
+            'عبوری': ['عبوری', 'passing'],
+            'خاکی': ['خاکی', 'soil'],
+            'اسفالت': ['اسفالت', 'asphalt']
+        }
+    
+    def extract_features(self, text: str) -> Dict:
+        """استخراج هوشمند ویژگی‌ها از متن"""
+        return {
+            'length': self._extract_length(text),
+            'road_type': self._extract_road_type(text),
+            'conductor_type': self._extract_conductor_type(text),
+            'pole_height': self._extract_pole_height(text),
+            'pole_capacity': self._extract_pole_capacity(text),
+            'keywords': self._extract_keywords(text)
+        }
+    
+    def _extract_length(self, text: str) -> Optional[float]:
+        match = re.search(r'(\d+)\s*متری', text)
+        return float(match.group(1)) if match else None
+    
+    def _extract_road_type(self, text: str) -> Optional[str]:
+        for rt, keywords in self.keyword_rules.items():
+            if any(kw in text for kw in keywords):
+                return rt
+        return None
+    
+    def _extract_conductor_type(self, text: str) -> Optional[str]:
+        for ct, keywords in [('مینک', self.keyword_rules['مینك']), 
+                           ('هاینا', self.keyword_rules['هاینا'])]:
+            if any(kw in text for kw in keywords):
+                return ct
+        return None
+    
+    def _extract_pole_height(self, text: str) -> Optional[float]:
+        matches = re.findall(r'پایه\s*(\d+)', text) or re.findall(r'ارتفاع\s*(\d+)', text)
+        return float(matches[0]) if matches else None
+    
+    def _extract_pole_capacity(self, text: str) -> Optional[float]:
+        matches = re.findall(r'(\d+)\s*کیلوولت', text) or re.findall(r'(\d+)\s*kV', text)
+        return float(matches[0]) if matches else None
+    
+    def _extract_keywords(self, text: str) -> List[str]:
+        return [kw for kw, keywords in self.keyword_rules.items() 
+               if any(k in text for k in keywords)]
 
 class RuleEngine:
-    """موتور قوانین پیشرفته"""
+    """موتور قوانین هوشمند"""
     def __init__(self):
         self.rules = [
             self._minck_rule,
-            self._passing_config_rule
+            self._passing_config_rule,
+            self._road_type_rule
         ]
     
     def apply_rules(self, context: Dict) -> Dict:
-        """اعمال تمام قوانین"""
+        """اعمال تمام قوانین به ترتیب"""
         overrides = {}
         for rule in self.rules:
             overrides.update(rule(context))
-        return overrides
+        return {**context, **overrides}
     
     def _minck_rule(self, context: Dict) -> Dict:
         """قانون سیم مینک"""
@@ -141,22 +247,63 @@ class RuleEngine:
         if context.get('configuration') == 'عبوری':
             return {'pole_capacity': 400}
         return {}
+    
+    def _road_type_rule(self, context: Dict) -> Dict:
+        """قانون نوع معبر"""
+        if context.get('road_type') == 'خاکی':
+            return {'length_coefficient': 1.2}
+        elif context.get('road_type') == 'اسفالت':
+            return {'length_coefficient': 0.9}
+        return {}
 
-# ایجاد نمونه Estimator
+# نمونه اصلی برنامه
 estimator = ElectricPoleEstimator()
 
 # رابط کاربری Gradio
-with gr.Blocks(title="برآورد هوشمند مصالح تاسیسات برقی") as demo:
-    gr.Markdown("## سیستم برآورد هوشمند مصالح تاسیسات برقی")
+with gr.Blocks(title="سیستم هوشمند برآورد مصالح تاسیسات برقی", css=".gradio-container {direction: rtl}") as demo:
+    gr.Markdown("## 🏗️ سیستم هوشمند برآورد مصالح تاسیسات برقی")
     
-    with gr.Tab("بارگذاری داده‌ها"):
+    with gr.Tab("📤 بارگذاری داده‌ها"):
         gr.Markdown("### بارگذاری فایل اکسل جدید")
-        file_input = gr.File(label="فایل اکسل برآورد", type="filepath")
-        upload_btn = gr.Button("بارگذاری و ذخیره در دیتابیس")
+        file_input = gr.File(label="فایل اکسل برآورد", file_types=[".xlsx"])
+        upload_btn = gr.Button("بارگذاری و ذخیره در دیتابیس", variant="primary")
         upload_output = gr.Textbox(label="نتایج بارگذاری")
         upload_btn.click(estimator.add_materials, inputs=file_input, outputs=upload_output)
+        
+        gr.Markdown("### محتوای فعلی دیتابیس")
+        db_viewer = gr.Dataframe(
+            headers=["کد", "عنوان", "واحد", "شرایط"],
+            datatype=["str", "str", "str", "str"],
+            interactive=False
+        )
+        refresh_btn = gr.Button("بروزرسانی نمایش")
+        refresh_btn.click(
+            lambda: [{"کد": x["code"], "عنوان": x["title"], "واحد": x["unit"], 
+                    "شرایط": estimator._format_conditions(x, {})} for x in estimator.db],
+            outputs=db_viewer
+        )
+    
+    with gr.Tab("📝 ورود متنی پروژه"):
+        gr.Markdown("### توضیحات کامل پروژه را وارد کنید")
+        project_desc = gr.Textbox(label="مثال: نصب ترانس 75 کیلوولت با کابل‌کشی 20 متری در معبر خاکی")
+        text_submit = gr.Button("محاسبه برآورد", variant="primary")
+        
+        gr.Markdown("### ویژگی‌های استخراج شده")
+        features_output = gr.JSON(label="")
+        
+        gr.Markdown("### لیست مصالح مورد نیاز")
+        estimates_output = gr.Dataframe(
+            headers=["کد", "عنوان", "مقدار", "واحد"],
+            datatype=["str", "str", "number", "str"]
+        )
+        
+        text_submit.click(
+            estimator.estimate_from_text,
+            inputs=project_desc,
+            outputs=[features_output, estimates_output]
+        )
     
-    with gr.Tab("محاسبه برآورد"):
+    with gr.Tab("⚙️ ورود پارامتری"):
         with gr.Row():
             height = gr.Number(label="ارتفاع پایه (متر)", value=12)
             capacity = gr.Number(label="توان پایه (kVA)", value=600)
@@ -170,31 +317,17 @@ with gr.Blocks(title="برآورد هوشمند مصالح تاسیسات برق
             choices=["", "عبوری", "انتهایی", "زانویی"],
             value=""
         )
-        estimate_btn = gr.Button("محاسبه برآورد")
+        param_submit = gr.Button("محاسبه برآورد", variant="primary")
         
-        results_table = gr.Dataframe(
-            headers=["کد", "عنوان", "مقدار", "واحد", "شرایط"],
-            datatype=["str", "str", "number", "str", "str"],
-            wrap=True
+        param_output = gr.Dataframe(
+            headers=["کد", "عنوان", "مقدار", "واحد"],
+            datatype=["str", "str", "number", "str"]
         )
         
-        estimate_btn.click(
+        param_submit.click(
             estimator.estimate,
             inputs=[height, capacity, conductor, config],
-            outputs=results_table
-        )
-
-    with gr.Tab("مشاهده دیتابیس"):
-        gr.Markdown("### محتوای فعلی دیتابیس")
-        db_viewer = gr.Dataframe(
-            headers=["کد", "عنوان", "واحد", "ارتفاع", "توان", "هادی"],
-            datatype=["str", "str", "str", "number", "number", "str"],
-            interactive=False
-        )
-        refresh_btn = gr.Button("بروزرسانی نمایش")
-        refresh_btn.click(
-            lambda: pd.DataFrame(estimator.db)[['code', 'title', 'unit', 'pole_height', 'pole_capacity', 'conductor_type']],
-            outputs=db_viewer
+            outputs=param_output
         )
 
 if __name__ == "__main__":