Odtnhj

I have a tiny web-server written in Python 3 using http.server which calls the function translate() in method do_GET() like this:

class httpd(BaseHTTPRequestHandler):
 def do_GET(self):
 self.wfile.write(bytes(f'translate(var[0])', 'utf-8'))

Now in this translate() function I have several conditional statements and try and except blocks roughly like this:

def translate(param):
 try:
 # do something
 except SomeError as some_err:
 print("Error: " % some_err)
 return ""

 if True:
 try:
 # do something
 except SomeOtherError as some_other_err:
 print("Error: " % some_other_err)
 return ""
 except SomeThirdError as some_third_err:
 print("Third error: " % some_third_err)
 return ""
 else:
 # additional try and except blocks which print an error and
 # return an empty string

The code above is simplified, but in principle I return an empty string if an exception happens and thus my web server returns nothing to client if an exception happens.

Is there a more manageable way to handle this? Specifically, I'm looking to:

• Avoid catching each error via a separate except section, while still supporting an error message dependent on error type.


• Avoid writing multiple try / except statements, often nested, within my function.

Note: This is a copy of this now deleted question. The solution from that post is included below, but other answers are welcome.

I'm not sure if having nested try blocks is absolutely necessary in your logic, but I'd try a single try block with a custom Exception class. Something like this:

class MyException(Exception):
 """Generic error message."""
 def __str__(self):
 return self.__doc__

class SomeError(MyException):
 """SomeError message."""
 pass

class SomeOtherError(MyException):
 """SomeOtherError message."""
 pass

class SomeThirdError(MyException):
 """SomeThirdError message."""
 pass



def translate(param):
 try:
 # do something
 ...
 if cond1:
 raise SomeError()
 ...
 if cond2:
 raise SomeOtherError()
 ...
 if cond3:
 raise SomeThirdError()
 ...

 except MyException as err:
 print(err)
 return ""

How about contextmanager? To alleviate your concern about custom error messages, you can feed a dictionary mapping error classes to messages of your choice.

Since different operations require different errors to be handled, you can use multiple with statements, feeding different errors as arguments each time.

Here's a contrived example:

from contextlib import contextmanager

@contextmanager
def error_handling(msg, *exceptions):
 try:
 yield
 except exceptions as my_error:
 print(msg[my_error.__class__], my_error)
 return ''

def do_stuff(d, key, index):

 custom_msg = IndexError: 'You have an Index Error!',
 KeyError: 'You have a Key Error!'

 with error_handling(custom_msg, IndexError, KeyError):
 return d[key][index]

# example prints "You have an Index Error! list index out of range"; then returns ''
do_stuff('a': [0, 1, 2], 'a', 10)

How about to define a function that has a dictionary contained the whole errors and responses. in this case you can catch an exception one time and send it to a handler

UPDATE :

def handle (e) :

exp = 'IOError' : 'NO such a file in dir ...! ' ,
 'KeyboardInterrupt' : 'Exiting ... (Keyboard interruption)',
 'IndexError' : ' a sequence subscript is out of range' ,
 'NameError' : 'a local or global name is not found'

for key , value in exp.items() :
 if e == key :
 print (value) #or do whatever you want

def test() :
 try :
 f = open('no-file' , 'r')
 except Exception as e :
 handle (type(e).__name__)


if __name__ == "__main__" :
 test()