Gorp.NET - संरचित पाठ से डेटा निकालने के लिए रिवर्स टेम्पलेट बनाने के लिए एक नई लाइब्रेरी

Gorp.NET मौजूदा Salesforce Gorp कोड आधार के आधार पर संरचित पाठ से डेटा निकालने के लिए प्रतिवर्ती टेम्पलेट बनाने के लिए एक नई लाइब्रेरी है।

इस प्रकाशन में, मैं Gorp नामक संरचित पाठ को पार्स करने के लिए पुस्तकालय का उपयोग करने के बारे में थोड़ी बात करूँगा (एक उपकरण का उदाहरण जो कभी - कभी रिवर्स-इंजीनियर टेम्पलेट सिस्टम कहा जाता है)।
सामान्य रूप से प्रतिवर्ती टेम्पलेट क्या है? मान लीजिए कि हमारे पास एक निश्चित प्रणाली है जो हमें हमारे द्वारा निर्धारित प्रारंभिक डेटा के आधार पर आवश्यक पाठ को उत्पन्न करने की अनुमति देती है, जो कि टेम्पलेट्स के सिंटैक्स द्वारा परिभाषित सख्त नियमों के अनुसार है। अब एक ऐसे कार्य की कल्पना करें जो अर्थ के विपरीत है - हमारे पास एक पाठ है जिसमें कुछ संरचनात्मक अखंडता है जो कि पिछले उदाहरण से टेम्पलेट्स के आधार पर एक प्रणाली का उपयोग करके प्राप्त किया जा सकता है। हमारा लक्ष्य इस पाठ से स्रोत डेटा को निकालना है जिसके आधार पर इसे बनाया गया था। यदि हम इस समस्या को हल करने के लिए एक निश्चित सामान्यीकृत वाक्यविन्यास के साथ आने की कोशिश करते हैं, जो संबंधित पार्सर के लिए इनपुट है, जो इनपुट टेक्स्ट को अलग-अलग तत्वों में पार्स करता है, तो यह प्रतिवर्ती टेम्पलेट्स की अवधारणा को लागू करने के लिए वाक्यविन्यास का एक उदाहरण होगा।

मैंने Gorp के बारे में विशेष रूप से लिखने का फैसला क्यों किया? तथ्य यह है कि मैंने इस प्रणाली को अपने स्वयं के प्रोजेक्ट को अंतिम रूप देने के लिए आधार के रूप में लेने का फैसला किया - परियोजना का इतिहास, मूल गॉर्प परियोजना में किए गए सभी परिवर्तनों के कुछ विवरणों सहित, पिछले लेख में पाया जा सकता है। यहां हम इंजन के एक संशोधित संस्करण के उपयोग के बारे में तकनीकी भाग पर सटीक ध्यान केंद्रित करेंगे। सुविधा के लिए, मैं इसे Gorp.NET कहता रहूंगा , हालांकि वास्तव में यह Gorp का एक संस्करण नहीं है। जिसे .NET में पोर्ट नहीं किया गया है, लेकिन इसका केवल थोड़ा पॉलिश और अंतिम संस्करण है, सभी एक ही जावा में। एक और बात यह है कि Gorp लाइब्रेरी के ऊपर ऐड-ऑन स्वयं (मेरे संस्करण में) एक प्रबंधित DLL- लाइब्रेरी के रूप में जिसे BIRMA.NET कहा जाता है, अपनी विशेष असेंबली - बहुत ही Gorp.NET का उपयोग करता है, जिसे आप स्वयं आसानी से प्राप्त कर सकते हैं यदि आप स्रोत पाठ चलाते हैं ( IKVM.NET उपयोगिता के माध्यम से उनकी रिपॉजिटरी का पता https://github.com/S-presso/gorp/ ) है।

मैं अभी ध्यान देता हूं कि किसी भी संरचित पाठ से डेटा निकालने के सभी प्रकार के कार्यों के लिए, Gorp.NET उपकरण स्वयं आपके लिए पर्याप्त होंगे - यदि आपके पास जावा की थोड़ी सी कमांड है या कम से कम पता है कि आपकी परियोजनाओं में बाहरी जावा मॉड्यूल से तरीकों को कैसे कॉल किया जाए। .NET फ्रेमवर्क, साथ ही वहां मानक JVM पुस्तकालयों से विभिन्न प्रकार शामिल हैं (मैंने इसे उसी IKVM.NET के माध्यम से हासिल किया, जो, हालांकि, अब पहले से ही एक असमर्थित परियोजना की स्थिति है)। खैर, और निकाले गए डेटा के साथ आप आगे क्या करेंगे - यह, जैसा कि वे कहते हैं, आपका व्यक्तिगत व्यवसाय है। Gorp और Gorp.NET अकेले केवल एक नंगे ढांचे प्रदान करते हैं। इस तरह के सभी डेटा के आगे के प्रसंस्करण के लिए कुछ ग्राउंडवर्क में उपरोक्त BIRMA.NET शामिल है । लेकिन अपने आप में BIRMA.NET कार्यक्षमता का वर्णन पहले से ही एक अलग प्रकाशन के लिए एक विषय है (हालांकि मैं पहले से ही अपने पिछले, BIRMA प्रौद्योगिकियों की तुलनात्मक-ऐतिहासिक समीक्षा में कुछ का उल्लेख करने में कामयाब रहा)। यहां, आगे देखते हुए, मैं अपने आप को कुछ हद तक बोल्ड स्टेटमेंट की अनुमति दूंगा कि तकनीक Gorp.NET (और, तदनुसार, BIRMA.NET में उपयोग किए गए प्रतिवर्ती टेम्प्लेट) का वर्णन करती है, इस तरह के अन्य शिल्पों में कुछ अनूठा है (मैं कहता हूं " शिल्प ", जैसा कि बड़ी कंपनियों ने अभी तक इन उद्देश्यों के लिए अपने स्वयं के ढांचे को बढ़ावा देने में मेरे द्वारा अभी तक नहीं देखा है - ठीक है, शायद, केवल सेल्सफोर्स ही इसके मूल कार्यान्वयन के साथ)।

अवधारणा और तकनीकी पहलुओं के सबसे पूर्ण प्रकटीकरण के लिए जो कि Gorp में उपयोग किए जाने वाले टेम्पलेट विवरण प्रणाली से गुजरते हैं, मैं अभी यहां अंग्रेजी में मूल दस्तावेज का लिंक छोड़ता हूं। इसमें जो कुछ भी कहा गया है, आप Gorp.NET के संबंध में सुरक्षित रूप से आवेदन कर सकते हैं। और अब मैं आपको सार के बारे में थोड़ा बताऊंगा।

तो, टेम्प्लेट का वर्णन एक तरह का टेक्स्ट डॉक्यूमेंट है (शायद इसे एक बड़ी लाइन के रूप में भी प्रस्तुत किया गया है, जिसे प्रोसेसिंग के लिए संबंधित विधि में पास किया जा सकता है)। इसमें तीन सबसे महत्वपूर्ण संस्थाओं के अनुक्रमिक विवरण वाले तीन भाग शामिल हैं: पैटर्न , पैटर्न और नमूने (अर्क)।

यहां सबसे निचले स्तर के ब्लॉक पैटर्न हैं - वे केवल नियमित अभिव्यक्ति और अन्य पैटर्न के संदर्भों से मिलकर बना सकते हैं। पदानुक्रम के अगले स्तर को टेम्पलेट्स द्वारा कब्जा कर लिया जाता है , जिसके विवरण में पैटर्न के लिंक भी होते हैं, जिसे नाम भी दिया जा सकता है, साथ ही पाठ शाब्दिक के रूप में समावेश, नेस्टेड टेम्पलेट और एक्सट्रैक्टर्स के लिंक भी शामिल हैं। वहाँ भी पैरामीट्रिक पैटर्न हैं जो मैं अभी नहीं छूऊंगा (स्रोत प्रलेखन में उनके उपयोग के कुछ उदाहरण हैं)। खैर, और अंत में, ऐसे नमूने हैं जो विशिष्ट वाक्यविन्यास नियमों को निर्दिष्ट करते हैं जो स्रोत पाठ से विशिष्ट घटनाओं के साथ नामांकित पैटर्न को जोड़ते हैं।

जैसा कि मैं इसे समझता हूं, गॉर्प के रचनाकारों द्वारा निर्धारित मूल लक्ष्य रिपोर्ट फ़ाइलों (या लॉग फ़ाइलों) में निहित डेटा के अनुक्रम को पार्स करना था। सिस्टम के एक विशिष्ट अनुप्रयोग के एक सरल उदाहरण पर विचार करें।

मान लें कि हमारे पास निम्नलिखित पंक्ति वाली एक रिपोर्ट है:

<86> 2015-05-12T20: 57: 53.302858 + 00: 00 10.1.11.141 RealSource: "10.10.5.3"

चलिए Gorp टूल्स का उपयोग करके इसे पार्स करने के लिए एक उदाहरण टेम्पलेट की रचना करते हैं:

pattern %phrase \\S+
pattern %num \\d+\n
pattern %ts %phrase
pattern %ip %phrase

extract interm {
template <%num>$eventTimeStamp(%ts) $logAgent(%ip) RealSource: "$logSrcIp(%ip)"
}


ध्यान दें कि टेम्प्लेट असाइनमेंट ब्लॉक यहां तक ​​छोड़ा गया है, क्योंकि सभी आवश्यक टेम्पलेट पहले से ही अंतिम चयन में शामिल हैं। यहां उपयोग किए गए सभी टेम्प्लेट नामित हैं, उनकी सामग्री को उनके नाम के बाद कोष्ठक में इंगित किया गया है। नतीजतन, ईवेंट डेटा टाइमस्टैंप , logAgent और logSrcIp नामों के साथ एक टेक्स्ट डेटा सेट बनाया जाएगा।

अब हम आवश्यक डेटा निकालने के लिए एक सरल प्रोग्राम लिखेंगे। मान लीजिए कि हमने जो टेम्प्लेट बनाया है, वह पहले से ही एक फाइल में समाहित है, जिसे extractions.xtr कहा जाता है ।

 import com.salesforce.gorp.DefinitionReader; import com.salesforce.gorp.ExtractionResult; import com.salesforce.gorp.Gorp; // ... DefinitionReader r = DefinitionReader.reader(new File("extractions.xtr")); Gorp gorp = r.read(); final String TEST_INPUT = "<86>2015-05-12T20:57:53.302858+00:00 10.1.11.141 RealSource: \"10.10.5.3\""; ExtractionResult result = gorp.extract(TEST_INPUT); if (result == null) { // no match, handle throw new IllegalArgumentException("no match!"); } Map<String,Object> properties = asMap(); // and then use extracted property values 

एक साधारण पार्सिंग टेम्प्लेट का दूसरा उदाहरण:

# Patterns
pattern %num \d+
pattern %hostname [a-zA-Z0-9_\-\.]+
pattern %status \w+

# Templates
@endpoint $srcHost(%hostname): $srcPort(%num)

# Extraction
extract HostDefinition {
template @endpoint $status(%status)
}


खैर, मुझे लगता है कि बात स्पष्ट है। यह भी उल्लेख नहीं किया जाएगा कि निकालने की विधि के लिए दो इनपुट मापदंडों के साथ एक परिभाषा भी है, जिनमें से दूसरे में एक तार्किक प्रकार है। यदि आप इसे सही पर सेट करते हैं , तो, जब निष्पादित किया जाता है, तो विधि सभी संभावित डेटा सेटों पर पुनरावृत्ति करेगी - जब तक कि यह एक उपयुक्त का सामना नहीं करता (आप पहले से दूसरे पैरामीटर के बिना - अर्क कैफे के साथ विधि कॉल को भी बदल सकते हैं)। डिफ़ॉल्ट गलत है , और विधि इनपुट डेटा और उपयोग किए गए टेम्पलेट के बीच विसंगति पर "शपथ" कर सकती है।
मैं उसी समय पर ध्यान देता हूं कि Gorp.NET ने अर्क विधि का एक नया विस्तारित कार्यान्वयन भी पेश किया है: अब एक तार्किक प्रकार के दो बाद के मापदंडों के साथ एक संस्करण है। ExtractAllFound दृश्य के लिए संक्षिप्त कॉल का उपयोग करते हुए , हम डिफ़ॉल्ट रूप से दोनों को सही पर सेट करते हैं। तीसरे पैरामीटर का सकारात्मक मूल्य हमें विविधताओं के लिए और भी अधिक गुंजाइश देता है: अब से, हम वांछित, पहले से संरचित नमूनों (निकाले गए डेटा के सेट सहित) के बीच के अंतराल में किसी भी प्रकार के मनमाना पात्रों के साथ पाठ का विश्लेषण कर सकते हैं।

तो, इस सवाल का जवाब देने का समय आ गया है: एक्स्ट्रेक्ट विधि के विस्तार के अलावा, Gorp के मूल संस्करण के इस संशोधन में क्या विशिष्ट हो सकता है?
तथ्य यह है कि जब मैंने कई साल पहले पाठ से आवश्यक डेटा निकालने के लिए एक प्रकार का अपना उपकरण बनाया था (जो कि अपने स्वयं के विशिष्ट वाक्यविन्यास के साथ कुछ निश्चित टेम्परिंग प्रसंस्करण पर आधारित था), तो यह थोड़ा अलग सिद्धांतों पर काम करता था। Gorp और सभी व्युत्पन्न रूपरेखाओं में लागू दृष्टिकोण से उनका मुख्य अंतर यह है कि निकाले जाने वाले प्रत्येक पाठ तत्व को बस उसकी बाईं और दाईं सीमाओं को सूचीबद्ध करके सेट किया गया था (जिनमें से प्रत्येक या तो तत्व का हिस्सा हो सकता है, या बस इसे अलग कर सकता है। सभी बाद या पिछले पाठ)। उसी समय, वास्तव में, सामान्य मामले में, स्रोत पाठ की संरचना का स्वयं विश्लेषण नहीं किया गया था, जैसा कि गोर्प में मामला है, लेकिन केवल आवश्यक टुकड़ों को बाहर निकाल दिया गया था। जैसा कि उनके बीच संलग्न पाठ की सामग्री के लिए, यह बिल्कुल भी किसी भी संरचनात्मक विश्लेषण के लिए सफल नहीं हो सकता था (यह अच्छी तरह से चरित्र सेट असंगत हो सकता है)।

क्या गोरो में एक समान प्रभाव प्राप्त करना संभव है? इसके शुरुआती संस्करण में - शायद नहीं (मुझे सही करें अगर मैं इस बारे में गलत हूं)। यदि हम बस (। *) की तरह एक अभिव्यक्ति लिखते हैं, तो खोजे जाने वाले अगले तत्व की बाईं सीमा को निर्दिष्ट करने के लिए एक मुखौटा द्वारा तुरंत अनुसरण किया जाता है, फिर "लालच" क्वांटिफायर का उपयोग करके, पूरे बाद के पाठ को कैप्चर किया जाएगा। और हम मौजूदा Gorp कार्यान्वयन में "गैर-लालची" सिंटैक्स के साथ नियमित उपयोग नहीं कर सकते।
Gorp.NET आपको दो विशेष प्रकार के पैटर्न पेश करके इस समस्या को आसानी से दरकिनार करने की अनुमति देता है - (% all_before) और (% all_after) । उनमें से पहला, वास्तव में, "गैर-लालची" संस्करण (। *) का एक विकल्प है, अपने स्वयं के टेम्पलेट्स को संकलित करने में उपयोग के लिए उपयुक्त है। के रूप में (% all_after) , यह भी वर्णित पैटर्न के अगले भाग की पहली घटना तक स्रोत पाठ को देखता है - लेकिन पहले से ही पिछले पैटर्न के खोज परिणाम पर निर्भर है। उनके बीच जो कुछ भी है वह वर्तमान तत्व के एक्स्ट्रेक्टेबल सबस्ट्रिंग में गिर जाएगा। एक अर्थ में (% all_after) "वापस दिखता है", और (% all_before) , इसके विपरीत, "दिखता है"। मैं ध्यान देता हूं कि BIRMA के पहले संस्करण में (% all_before) के लिए एक अद्वितीय एनालॉग तत्व के वर्णन में गायब बाईं ओर था, और एनालॉग (% all_after) , क्रमशः, सही सीमा के बजाय एक शून्य था। यदि अगले तत्व का वर्णन करते समय दोनों सीमाएं निर्धारित नहीं की जाती हैं, तो पार्सर स्पष्ट रूप से सभी बाद के पाठ को पकड़ लेता है! हालाँकि, यह सब तब BIRMA के कार्यान्वयन का विशुद्ध रूप से ऐतिहासिक महत्व है (आप उस समय की मेरी रिपोर्ट में इसके बारे में थोड़ा और पढ़ सकते हैं)।


आइए विशिष्ट वेबसाइट से विशिष्ट उपयोगकर्ता डेटा निकालने के कार्य के उदाहरण का उपयोग करके सेवा पैटर्न (% all_before) और (% all_after) का उपयोग करने की सुविधाओं को देखें। हम अमेज़न साइट को पार्स करेंगे, और विशेष रूप से इस पृष्ठ को: https://www.amazon.com/B06-Plus-Bluaxy-Receiver-Streaming/product-reviews/B078J3GTRK/ )।

मूल कार्य उपरोक्त पृष्ठ से निम्नलिखित डेटा एकत्र करना था:

• उपयोगकर्ता नाम
• मूल्यांकन
• शीर्षक की समीक्षा करें
• तारीख
• टेक्स्ट

ठीक है, अब मैं आपको केवल मेरे द्वारा संकलित एक टेम्पलेट देता हूँ, जो आपको इस कार्य को जल्दी और कुशलता से पूरा करने की अनुमति देता है। मुझे लगता है कि सामान्य अर्थ काफी स्पष्ट होना चाहिए - शायद आप स्वयं अधिक संक्षिप्त समाधान की पेशकश कर सकते हैं।


pattern %optspace ( *)
pattern %space ( +)

pattern %cap_letter [AZ]
pattern %small_letter [az]
pattern %letter (%cap_letter|%small_letter)
pattern %endofsentence (\.|\?|\!)+
pattern %delim (\.|\?|\!\,|\:|\;)
pattern %delim2 (\(|\)|\'|\")

pattern %word (%letter|\d)+
pattern %ext_word (%delim2)*%word(%delim)*(%delim2)*

pattern %text_phrase %optspace%ext_word(%space%ext_word)+
pattern %skipped_tags <([^>]+)>

pattern %sentence (%text_phrase|%skipped_tags)+(%endofsentence)?

pattern %start <div class=\"a-fixed-right-grid view-point\">

pattern %username_start <div class=\"a-profile-content\"><span class=\"a-profile-name\">
pattern %username [^\s]+
pattern %username_end </span>

pattern %user_mark_start <i data-hook=\"review-star-rating\"([^>]+)><span class=\"a-icon-alt\">
pattern %user_mark [^\s]+
pattern %user_mark_end ([^<]+)</span>

pattern %title_start data-hook=\"review-title\"([^>]+)>(%skipped_tags)*
pattern %title [^<]+
pattern %title_end </span>

pattern %span class <span class=\"[^\"]*\">

pattern %date_start <span data-hook="review-date"([^>]+)>
pattern %date ([^<]+)
pattern %date_end </span>

pattern %content_start <span data-hook=\"review-body\"([^>]+)>(%skipped_tags)*
pattern %content0 (%sentence)+
pattern %content (%all_after)
pattern %content_end </span>

template @extractUsernameStart (%all_before)%username_start
template @extractUsername $username(%username)%username_end
template @extractUserMarkStart (%all_before)%user_mark_start
template @extractUserMark $user_mark(%user_mark)%user_mark_end
template @extractTitleStart (%all_before)%title_start
template @extractTitle $title(%title)%title_end
template @extractDateStart (%all_before)%date_start
template @extractDate $date(%date)%date_end
template @extractContentStart (%all_before)%content_start
template @extractContent $content(%content)%content_end

extract ToCEntry {
template @extractUsernameStart@extractUsername@extractUserMarkStart@extractUserMark@extractTitleStart@extractTitle@extractDateStart@extractDate@extractContentStart@extractContent
}



आज के लिए बस इतना ही। मेरे द्वारा लागू किए गए तृतीय-पक्ष टूल के बारे में, जिसमें यह ढांचा पहले से ही पूरी तरह से शामिल हो चुका है, मैं आपको एक और समय बता सकता हूं।