`with` ब्लॉक में encapsulating पुनर्प्रयास

Question

मैं एक with ब्लॉक में डेटाबेस लेनदेन के लिए तर्क संपुटित करने के लिए देख रहा हूँ; एक लेनदेन में कोड लपेटना और विभिन्न अपवादों को संभालना (मुद्दों को लॉक करना)। यह काफी आसान है, हालांकि मैं कुछ अपवादों के बाद ब्लॉक ब्लॉक को पुनः लोड करने के लिए ब्लॉक को भी समाहित करना चाहता हूं। मैं संदर्भ प्रबंधक में इसे अच्छी तरह से पैकेज करने का कोई तरीका नहीं देख सकता।

क्या with कथन के भीतर कोड दोहराना संभव है?

मैं इसे जो वास्तव में साफ है, इस के रूप में के रूप में बस का उपयोग करना चाहते हैं।

def do_work(): 
    ... 
    # This is ideal! 
    with transaction(retries=3): 
     # Atomic DB statements 
     ... 
    ... 

मैं वर्तमान में एक डेकोरेटर के साथ इस से निपटने हूँ, लेकिन मैं संदर्भ प्रबंधक (या दोनों वास्तव में), तो मैं बजाय with ब्लॉक में कोड की कुछ लाइनें रैप करने के लिए चुन सकते हैं की पेशकश करना पसंद करते हैं एक इनलाइन समारोह एक डेकोरेटर में लिपटे है, जो है जो मैं इस समय कर की:

with transaction(_perform_in_transaction, retries=3) as _perf: 
    _perf() 

के लिए:

def do_work(): 
    ... 
    # This is not ideal! 
    @transaction(retries=3) 
    def _perform_in_transaction(): 
     # Atomic DB statements 
     ... 
    _perform_in_transaction() 
    ... 

Answer 1

सज्जाकार के रूप में सिर्फ खुद को काम करता हैं, तो आपको निम्न कर सकता है विवरण, आप transaction() एक कारखाने विधि है कि मूल विधि कॉल और विफलता पर कई बार retries नंबर करने के लिए इसे दोहराने के लिए सेट __callable__() के साथ एक वस्तु के रूप में रिटर्न लागू करने की आवश्यकता होगी; __enter__() और __exit__() डेटाबेस लेनदेन संदर्भ प्रबंधकों के लिए सामान्य के रूप में परिभाषित किया जाएगा।

आप वैकल्पिक रूप से transaction() स्थापित कर सकते हैं जैसे कि यह स्वयं को retries तक पारित विधि को निष्पादित करता है, जो शायद संदर्भ प्रबंधक को कार्यान्वित करने के समान काम की आवश्यकता होगी लेकिन इसका मतलब होगा कि वास्तविक उपयोग केवल घट जाएगा transaction(_perform_in_transaction, retries=3) (जो वास्तव में, सजावटी उदाहरण डेलनान के बराबर है)।

Answer 2

क्या with कथन के भीतर कोड दोहराना संभव है?

No.

के रूप में है कि मेलिंग सूची धागा में पहले ने कहा, आप डेकोरेटर पारित कर दिया फ़ंक्शन को कॉल करके दोहराव का एक सा कम कर सकते हैं:

def do_work(): 
    ... 
    # This is not ideal! 
    @transaction(retries=3) 
    def _perform_in_transaction(): 
     # Atomic DB statements 
     ... 
    # called implicitly 
    ... 

Answer 3

तरीका है कि मेरे पास होता है यह एक मानक डेटाबेस लेनदेन context manager लागू है, लेकिन यह निर्माता में एक retries तर्क लेने के लिए अनुमति देने के लिए बस है क्या करना है। तो मैं बस इसे अपने विधि कार्यान्वयन में लपेटूंगा। इस तरह कुछ:

class transaction(object): 
    def __init__(self, retries=0): 
     self.retries = retries 
    def __enter__(self): 
     return self 
    def __exit__(self, exc_type, exc_val, traceback): 
     pass 

    # Implementation... 
    def execute(self, query): 
     err = None 
     for _ in range(self.retries): 
      try: 
       return self._cursor.execute(query) 
      except Exception as e: 
       err = e # probably ought to save all errors, but hey 
     raise err 

with transaction(retries=3) as cursor: 
    cursor.execute('BLAH')