Jinja: ओवरराइड करने योग्य ऑटोस्केप

सुनिश्चित नहीं है कि ऑटोस्केपिंग ऐसा करने का एक उचित तरीका है या नहीं।

मैं इसके बजाय एक फ़िल्टर का उपयोग करूंगा। tojson एक अच्छा उम्मीदवार लगता है क्योंकि यमल जोंस का सुपरसेट है।

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

ऑटोस्केपिंग का उपयोग करने की बात यह है कि मैं हर एक चर विस्तार पर एक फिल्टर नहीं लगाना चाहता।

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

आप सभी चरों पर फ़िल्टर लागू करने के लिए जिन्जा प्लगइन का उपयोग कर सकते हैं। यह बहुत कठिन नहीं है जब तक आपको i18n ब्लॉक का उपयोग करने की आवश्यकता नहीं है। हो सकता है कि आप मेरे द्वारा कुछ समय पहले लिखी गई किसी चीज़ से कुछ विचार ले सकें: https://github.com/indico/indico/blob/master/indico/web/flask/templating.py#L187

यह बहुत मददगार है, धन्यवाद! मुझे लगता है कि ऑटोस्केपिंग अभी भी इसे हल करने के लिए एक ठीक दृष्टिकोण है क्योंकि आप उदाहरण के लिए ध्वज चर |safe रूप में कर सकते हैं। लेकिन मैं मानता हूं कि अवधारणात्मक रूप से, यह वास्तव में ऑटोस्केपिंग की तरह नहीं है, क्योंकि हम केवल यह सुनिश्चित नहीं कर रहे हैं कि वेरिएबल वैध वाईएएमएल हैं, बल्कि उन्हें एक निश्चित तरीके से स्वरूपित कर रहे हैं। मैं एक विस्तार लिखूंगा।

@glasserc क्या आप इस एक्सटेंशन के साथ सफल हुए? मुझे भी इसी तरह की समस्या है, क्या आप समाधान के लिए बता सकते हैं/कुछ विचार साझा कर सकते हैं?

मेरे समाधान का पहला भाग वह एक्सटेंशन था जो फ़िल्टर के माध्यम से सभी परिवर्तनीय कॉल चलाता है। यह काम करने के लिए मुझे जो न्यूनतम आवश्यकता है वह है।

import jinja2.ext
from jinja2.lexer import Token

class YAMLEverythingExtension(jinja2.ext.Extension):
    """
    Insert a `|yaml` filter at the end of every variable substitution.

    This will ensure that all injected values are converted to YAML.
    """
    def filter_stream(self, stream):
        # This is based on https://github.com/indico/indico/blob/master/indico/web/flask/templating.py.
        for token in stream:
            if token.type == 'variable_end':
                yield Token(token.lineno, 'pipe', '|')
                yield Token(token.lineno, 'name', 'yaml')
            yield token

यह होशियार हो सकता है, उदाहरण के लिए यदि यह safe या yaml फ़िल्टर को वेरिएबल ब्लॉक में स्पष्ट रूप से देखता है तो यह फ़िल्टर डालने को छोड़ने का प्रयास कर सकता है। लेकिन मुझे उसके लिए समय की आवश्यकता / आवश्यकता कभी समाप्त नहीं हुई।

दूसरा भाग फिल्टर ही है। बस yaml.dump का उपयोग करना पर्याप्त परिष्कृत नहीं था, इसलिए मुझे यमल इंटर्नल के चारों ओर थोड़ा सा प्रहार करना पड़ा।

import cStringIO
import yaml

def yaml_filter(val):
    """Serialize some value in isolation, not as part of any document.

    We can't just use yaml.dump because that outputs an entire document, including newlines, which isn't helpful for
    inserting into a YAML document."""
    if isinstance(val, jinja2.Undefined):
        val._fail_with_undefined_error()
    stream = cStringIO.StringIO()
    dumper = yaml.dumper.Dumper(stream)
    dumper.open()
    node = dumper.represent_data(val)
    dumper.serialize(node)
    # The serialized node tends to have a \n at the end.  The template might not
    # want a \n inserted here, e.g. if two variables are on the same line, so
    # strip.
    return stream.getvalue().strip()

यह सभी को एक साथ जोड़ता है, जिसमें यह सुनिश्चित करना शामिल है कि दिए गए नाम का फ़िल्टर वातावरण में उपलब्ध है:

from jinja2 import loaders
from jinja2 import Environment, StrictUndefined

def get_environment():
    """Create a standard Jinja environment that has everything in it.
    """
    jinja_env = Environment(extensions=(YAMLEverythingExtension,),
                            # some other options that we use at work
                            loader=loaders.FileSystemLoader(['.', '/']),
                            undefined=StrictUndefined)
    jinja_env.filters["yaml"] = yaml_filter
    return jinja_env

गैर-एचटीएमएल टेम्पलेट्स से बचने के लिए यह अभी भी बहुत अच्छा होगा। मैं JSON उत्पन्न करने के लिए Jinja2 का उपयोग कर रहा हूं, और HTML से बचने के बजाय JSON एस्केपिंग का उपयोग करना चाहता हूं।

जेएसओएन उत्पन्न करने के लिए जिंजा टेम्पलेट्स या किसी अन्य स्ट्रिंग-आधारित टेम्पलेट भाषा या स्ट्रिंग ऑपरेशंस का उपयोग करना गलत है। मैं देख सकता हूं कि आप वाईएएमएल के लिए ऐसा क्यों करेंगे क्योंकि यह मानव-अनुकूल होने के लिए भी है, लेकिन जेएसओएन को एक पायथन निर्देश से उत्पन्न किया जाना चाहिए, न कि जिंजा टेम्पलेट से।

(उस ने कहा, मैं उत्सुक हूं कि आप ऐसा क्यों करना चाहते हैं और आप क्या करने की कोशिश कर रहे हैं: पी)

मुझे लगता है यह सार्थक बात है। :-) मैं #571 बंद कर दूँगा।

हो सकता है कि जेएसओएन जिंजा द्वारा उत्पन्न करने के लिए अच्छा नहीं है, लेकिन मुझे इस तरह की सुविधा में बहुत दिलचस्पी है क्योंकि मैं जिन्जा का उपयोग करके लाटेक्स उत्पन्न कर रहा हूं। मैंने block_start_string और block_end_string और अन्य को Environment संशोधित करके वहां के अधिकांश तरीके प्राप्त कर लिए हैं। अभी के लिए, मैंने autoescape = False सेट किया है, लेकिन मैं आदर्श रूप से खुद से बचने के लिए कुछ पास करना चाहता हूं (शायद रेगेक्स की तरह)।

यह प्लेनटेक्स्ट और मार्कडाउन जनरेट करने पर भी लागू होता है। गैर-एचटीएमएल दस्तावेज़ों को टेम्प्लेट करने के लिए जिंजा अब तक एक महान उपकरण रहा है।

मैं एसक्यूएल प्रश्नों को उत्पन्न करने के लिए जिन्जा का उपयोग कर रहा था क्योंकि str.format() उपयोग करना आपको कई सशर्त क्वेरी भागों की आवश्यकता होने पर गन्दा हो सकता है।

ऐसा करने के लिए पहले से ही पुस्तकालय हैं, अर्थात् जिन्जा-गायब जो कस्टम एस्केप फ़ंक्शंस और जिन्जास्क्ल की अनुमति देता है।
पहले व्यक्ति को संकलन पर निरंतर-मूल्यांकन अक्षम करना पड़ता है जो थोड़ा बुरा लगता है। दूसरा वाला
सभी वैरिएबल एक्सप्रेशन में एक विशेष फ़िल्टर जोड़ने के लिए फ़िल्टर एप्रोच का उपयोग करता है जो ठीक है लेकिन सही नहीं लगता है।

मैंने इसमें गहराई से नहीं देखा है लेकिन इसे लागू करना इतना कठिन नहीं लगता है। क्या इस पर विचार किया जा सकता है या यह पुस्तकालय के दायरे से बाहर है?