ยกข้อยกเว้นด้วยประเภทและข้อความที่แตกต่างกันรักษาข้อมูลที่มีอยู่

ฉันกำลังเขียนโมดูลและต้องการมีลำดับชั้นข้อยกเว้นแบบรวมสำหรับข้อยกเว้นที่สามารถยกระดับได้ (เช่นการสืบทอดจากFooErrorคลาสนามธรรมสำหรับfooข้อยกเว้นเฉพาะทั้งหมดของโมดูล) สิ่งนี้ช่วยให้ผู้ใช้โมดูลสามารถตรวจจับข้อยกเว้นเฉพาะเหล่านั้นและจัดการพวกมันอย่างชัดเจนหากจำเป็น แต่มีข้อยกเว้นมากมายที่ยกมาจากโมดูลเนื่องจากข้อยกเว้นอื่น ๆ เช่นความล้มเหลวในบางงานเนื่องจาก OSError บนไฟล์

สิ่งที่ฉันต้องการคือ"ห่อ" ข้อยกเว้นที่จับได้ว่ามันมีประเภทและข้อความที่แตกต่างกันดังนั้นข้อมูลจะมีอยู่ในลำดับชั้นการเผยแพร่ต่อไปโดยสิ่งใดก็ตามที่จับข้อยกเว้น แต่ฉันไม่ต้องการสูญเสียชนิดข้อความและการติดตามสแต็กที่มีอยู่เดิม นั่นคือข้อมูลที่มีประโยชน์ทั้งหมดสำหรับคนที่พยายามแก้ไขปัญหา ตัวจัดการข้อยกเว้นระดับบนสุดไม่ดีนักเนื่องจากฉันพยายามตกแต่งข้อยกเว้นก่อนที่มันจะเพิ่มระดับสแต็คการเผยแพร่ต่อไปและตัวจัดการระดับบนสุดจะสายเกินไป

นี่เป็นส่วนหนึ่งที่ได้รับการแก้ไขโดยการรับfooประเภทข้อยกเว้นเฉพาะของโมดูลจากประเภทที่มีอยู่ (เช่นclass FooPermissionError(OSError, FooError)) แต่นั่นไม่ได้ทำให้ง่ายต่อการห่ออินสแตนซ์ข้อยกเว้นที่มีอยู่ในรูปแบบใหม่หรือแก้ไขข้อความ

ธPEP 3134 “ข้อยกเว้นผูกมัดและ tracebacks ฝังตัว” กล่าวถึงการเปลี่ยนแปลงที่ยอมรับในหลาม 3.0 สำหรับ“ผูกมัด” วัตถุข้อยกเว้นที่จะแสดงให้เห็นว่าข้อยกเว้นใหม่ถูกยกขึ้นในระหว่างการจัดการของข้อยกเว้นที่มีอยู่

สิ่งที่ฉันพยายามจะทำคือเกี่ยวข้อง: ฉันต้องการมันยังทำงานในรุ่น Python ก่อนหน้านี้และฉันไม่ต้องการสำหรับการผูกมัด แต่สำหรับ polymorphism เท่านั้น วิธีที่ถูกต้องในการทำเช่นนี้คืออะไร?

Python 3นำเสนอการผูกมัดข้อยกเว้น (ตามที่อธิบายไว้ในPEP 3134 ) สิ่งนี้อนุญาตให้ยกข้อยกเว้นเพื่ออ้างถึงข้อยกเว้นที่มีอยู่ว่าเป็น "สาเหตุ":

try:
    frobnicate()
except KeyError as exc:
    raise ValueError("Bad grape") from exc

ข้อยกเว้นที่จับได้จึงกลายเป็นส่วนหนึ่งของ (เป็น“ สาเหตุของ”) ข้อยกเว้นใหม่และสามารถใช้ได้กับรหัสใดก็ตามที่จับข้อยกเว้นใหม่ได้

ด้วยการใช้คุณสมบัตินี้จะมีการ__cause__ตั้งค่าแอตทริบิวต์ ตัวจัดการข้อยกเว้นในตัวยังรู้วิธีการรายงาน“ สาเหตุ” และ“ บริบท” ของข้อยกเว้นพร้อมกับการสืบค้นกลับ

ในPython 2ดูเหมือนว่ากรณีการใช้งานนี้ไม่มีคำตอบที่ดี (ตามที่อธิบายโดยIan BickingและNed Batchelder ) คนเกียจคร้าน

คุณสามารถใช้ sys.exc_info () เพื่อรับการติดตามย้อนกลับและเพิ่มข้อยกเว้นใหม่ของคุณด้วยการติดตามย้อนกลับดังกล่าว (ตามที่ PEP กล่าวถึง) หากคุณต้องการรักษาชนิดและข้อความเก่าไว้คุณสามารถทำได้ยกเว้น แต่จะมีประโยชน์เฉพาะเมื่อมีสิ่งใดก็ตามที่จับข้อยกเว้นของคุณได้

ตัวอย่างเช่น

import sys

def failure():
    try: 1/0
    except ZeroDivisionError, e:
        type, value, traceback = sys.exc_info()
        raise ValueError, ("You did something wrong!", type, value), traceback

แน่นอนว่ามันไม่มีประโยชน์จริงๆ ถ้าเป็นเช่นนั้นเราไม่ต้องการ PEP นั้น ฉันไม่แนะนำให้ทำ

คุณสามารถสร้างประเภทข้อยกเว้นของคุณเองที่ขยายข้อยกเว้นใด ๆ ที่คุณจับได้

class NewException(CaughtException):
    def __init__(self, caught):
        self.caught = caught

try:
    ...
except CaughtException as e:
    ...
    raise NewException(e)

แต่ส่วนมากของเวลาที่ฉันคิดว่ามันจะง่ายต่อการจับข้อยกเว้นจัดการกับมันและทั้งraiseข้อยกเว้นเดิม (และรักษา traceback) raise NewException()หรือ หากฉันกำลังเรียกรหัสของคุณและฉันได้รับหนึ่งในข้อยกเว้นที่กำหนดเองของคุณฉันคาดหวังว่ารหัสของคุณจะจัดการกับข้อยกเว้นใดก็ตามที่คุณต้องตรวจจับ ดังนั้นฉันไม่จำเป็นต้องเข้าถึงด้วยตนเอง

แก้ไข: ฉันพบการวิเคราะห์วิธีนี้เพื่อทำให้เกิดข้อยกเว้นของคุณเองและรักษาข้อยกเว้นดั้งเดิมไว้ ไม่มีทางออกที่ดี

ฉันยังพบว่าหลายครั้งที่ฉันต้องการ "การตัด" เพื่อเพิ่มข้อผิดพลาด

สิ่งนี้รวมอยู่ในขอบเขตของฟังก์ชันและบางครั้งก็มีเพียงบางบรรทัดในฟังก์ชัน

สร้างเสื้อคลุมที่จะใช้decoratorและcontext manager:

การดำเนินงาน

import inspect
from contextlib import contextmanager, ContextDecorator
import functools    

class wrap_exceptions(ContextDecorator):
    def __init__(self, wrapper_exc, *wrapped_exc):
        self.wrapper_exc = wrapper_exc
        self.wrapped_exc = wrapped_exc

    def __enter__(self):
        pass

    def __exit__(self, exc_type, exc_val, exc_tb):
        if not exc_type:
            return
        try:
            raise exc_val
        except self.wrapped_exc:
            raise self.wrapper_exc from exc_val

    def __gen_wrapper(self, f, *args, **kwargs):
        with self:
            for res in f(*args, **kwargs):
                yield res

    def __call__(self, f):
        @functools.wraps(f)
        def wrapper(*args, **kw):
            with self:
                if inspect.isgeneratorfunction(f):
                    return self.__gen_wrapper(f, *args, **kw)
                else:
                    return f(*args, **kw)
        return wrapper

ตัวอย่างการใช้งาน

มัณฑนากร

@wrap_exceptions(MyError, IndexError)
def do():
   pass

เมื่อโทรdoวิธีไม่ต้องกังวลIndexErrorเพียงแค่MyError

try:
   do()
except MyError as my_err:
   pass # handle error 

ผู้จัดการบริบท

def do2():
   print('do2')
   with wrap_exceptions(MyError, IndexError):
       do()

ภายในdo2ในcontext managerถ้าIndexErrorจะเพิ่มขึ้นก็จะถูกห่อและเติบโตMyError

ทางออกที่ตรงตามความต้องการของคุณมากที่สุดคือ:

try:
     upload(file_id)
except Exception as upload_error:
     error_msg = "Your upload failed! File: " + file_id
     raise RuntimeError(error_msg, upload_error)

ด้วยวิธีนี้คุณสามารถพิมพ์ข้อความของคุณในภายหลังและข้อผิดพลาดเฉพาะที่เกิดขึ้นจากฟังก์ชั่นอัพโหลด