# फ़ज़ी मैप मैक्रोज़ और ब्रैकेट लॉजिक

ऑरा "स्टार्ट रूल" ट्रिगर होने के बाद उन्हें क्रमिक रूप से एक सुसंगत पाइपलाइन के रूप में निष्पादित करने के लिए `FUZZY_MAP_pre.py` फ़ाइलों में कई प्रीप्रोसेसिंग नियमों को समूहीकृत करने का समर्थन करता है। यह दस्तावेज़ इस सुविधा के डिज़ाइन दर्शन, वाक्यविन्यास और निष्पादन प्रवाह का वर्णन करता है।

## कोर डिज़ाइन सिद्धांत

1. **शून्य अतिरेक**: एक समूह के अंदर नियम मानक पायथन टुपल्स बने रहते हैं:
`('प्रतिस्थापन_पाठ', r'regex_पैटर्न', सीमा, झंडे_और_विकल्प)`
2. **दोहरी उपयोगिता**: एक समूह के अंदर व्यक्तिगत नियम पूरी तरह कार्यात्मक स्टैंडअलोन नियम हैं। यदि समूह ट्रिगर नहीं होता है, तो उनका मूल्यांकन सामान्य रूप से पैरेंट लूप में किया जाता है।
3. **निष्क्रिय अंत मार्कर**: किसी समूह का अंत एक निष्क्रिय नियम प्रविष्टि द्वारा परिभाषित किया जाता है जो कभी भी अपने आप से मेल नहीं खाता है। यह पूरी तरह से पार्सर के लिए एक सीमा मार्कर के रूप में कार्य करता है।
4. **हाइब्रिड फ़ॉलबैक (एपेंड-ऑन-नॉन-मैच)**: जब कोई समूह सक्रिय होता है, तो प्रत्येक आंतरिक नियम को आउटपुट में योगदान देना चाहिए। यदि किसी आंतरिक नियम का रेगेक्स पाठ से मेल खाता है, तो सामान्य प्रतिस्थापन होता है। यदि यह मेल नहीं खाता है, तो इसके प्रतिस्थापन पाठ को एक स्थान के साथ वर्तमान पाठ में जोड़ दिया जाता है।

---

## सिंटैक्स और संरचना

एक मैक्रो समूह को **प्रारंभ नियम** और **अंत नियम** के बीच मानक नियमों की एक श्रृंखला को `FUZZY_MAP_pre.py` में लपेटकर परिभाषित किया गया है।

### 1. प्रारंभ नियम
प्रारंभ नियम एक मानक नियम है जो मिलान होने पर मैक्रो को ट्रिगर करता है। इसके विकल्प शब्दकोश में ``group_start'` कुंजी शामिल है:
__CODE_ब्लॉक_0__

### 2. आंतरिक नियम
आंतरिक नियम प्रारंभ नियम के बाद क्रमिक रूप से रखे गए मानक नियम हैं। उन्हें किसी विशेष मेटाडेटा की आवश्यकता नहीं है:
__CODE_ब्लॉक_1__

### 3. अंतिम नियम (निष्क्रिय मार्कर)
अंतिम नियम में एक `कोई नहीं` प्रतिस्थापन, एक खाली पैटर्न और इसके विकल्प शब्दकोश में एक ``group_end'` कुंजी है:
__CODE_ब्लॉक_2__

---

## ठोस उदाहरण

यहां `FUZZY_MAP_pre.py` फ़ाइल में परिभाषित एक व्यावहारिक परीक्षण मामला है:

__CODE_ब्लॉक_3__

### निष्पादन प्रवाह परिदृश्य:

* **परिदृश्य ए (ट्रिगर मैक्रो)**:
* इनपुट: ``सैंडबॉक्स मिट एपफेल शुरू करें''
* अपेक्षित प्रवाह:
1. प्रारंभ नियम ``स्टार्ट सैंडबॉक्स'' से मेल खाता है और इसे ``सैंडबॉक्स:'' -> वर्तमान पाठ: ``सैंडबॉक्स: मिट एफ़ेल'' से बदल देता है।
2. समूह `'sandbox_test'` चालू हो गया है।
3. हम `"सैंडबॉक्स: मिट एपफेल"` पर आंतरिक नियमों को पुनरावर्ती रूप से चलाते हैं:
- आंतरिक नियम 1 `"apfel"` से मेल खाता है और `"birne"` से प्रतिस्थापित करता है -> वर्तमान पाठ: `"सैंडबॉक्स: mit birne"`।
- आंतरिक नियम 2 `"banane"` से मेल नहीं खाता। चूँकि समूह सक्रिय है, यह `"banane"` -> वर्तमान पाठ: `"सैंडबॉक्स: मिट बिरने बनाना"` जोड़ने पर वापस आ जाता है।
4. अंतिम पाठ ``सैंडबॉक्स: मिट बिरने बनाना'' लैंग्वेजटूल द्वारा लौटाया और ठीक किया गया है।
* आउटपुट: ``सैंडबॉक्स: मिट बिरने बनाने''

* **परिदृश्य बी (अन-ट्रिगर मैक्रो - दोहरी उपयोगिता)**:
* इनपुट: ``एइन एपफेल अंड एइन किर्शे''
* अपेक्षित प्रवाह:
1. प्रारंभ नियम मेल नहीं खाता. समूह `'sandbox_test'` निष्क्रिय रहता है।
2. लूप अगले नियम पर आगे बढ़ता है।
3. **आंतरिक नियम 1**: ``एपीफेल'' से मेल खाता है और इसे ``बिरने'' से प्रतिस्थापित करता है -> वर्तमान पाठ: ``एइन बिरने अंड एइन किर्शे''।
4. **आंतरिक नियम 2**: मेल नहीं खाता। चूँकि समूह को ट्रिगर नहीं किया गया था, नियम एक सामान्य स्टैंडअलोन नियम के रूप में व्यवहार करता है और **कुछ भी नहीं जोड़ा जाता है**।
5. अंतिम नियम को नजरअंदाज कर दिया गया है।
* आउटपुट: ``एइन बिरने अंड एइन किर्शे''

---

## तकनीकी विवरण (हुड के नीचे)

* **पृथक रिकर्सन**: जब किसी समूह को ट्रिगर किया जाता है, तो इंजन `custom_rules=[inner_rule]` के साथ `process_text_in_background` को पुनरावर्ती रूप से आमंत्रित करता है। यह प्रत्येक आंतरिक नियम को पूर्ण, तुल्यकालिक पाइपलाइन पास के भीतर निष्पादित करने की अनुमति देता है।
* **प्रदर्शन और स्थिरता सुरक्षा उपाय**:
* **अनुक्रम बाईपास**: गतिरोध और निष्पादन में देरी को रोकने के लिए आंतरिक पुनरावर्ती रन `chunk_id` अनुक्रम कतार को बायपास करते हैं।
* **आई/ओ और टीटीएस दमन**: पुनरावर्ती रन मध्यवर्ती फ़ाइल-लेखन और टीटीएस भाषण आउटपुट को दबा देते हैं, यह सुनिश्चित करते हुए कि केवल अंतिम स्थिर पाठ ही लिखा और बोला जाता है।
* **स्थिरता सुरक्षा**: फ़ॉलबैक परिशिष्ट के दौरान अनंत स्थिरता लूप को रोकने के लिए पुनरावर्ती रन एक पुनरावृत्ति के बाद सख्ती से टूटते हैं।
* **सुरक्षित समाप्ति**: स्थिरता जांच अनंत लूप को रोकने के लिए अधिकतम पुनरावृत्ति गणना (`MAX_ITERATIONS_FOR_SAFETY`) पर सख्ती से निर्भर करती है, समय-आधारित थ्रॉटलिंग को दरकिनार करती है जो वैध, धीमी मैक्रो निष्पादन को समय से पहले रद्द कर सकती है।
__CODE_ब्लॉक_4__