8. Hatalar ve Özel Durumlar
***************************

Şimdiye kadar hata mesajlarından fazla bahsedilmedi, ancak örnekleri
denediyseniz muhtemelen bazılarını görmüşsünüzdür.  (En azından) iki
ayırt edilebilir hata türü vardır: *söz dizimi hataları* (*syntax
errors*) ve *özel durumlar* (*exceptions*).


8.1. Söz Dizimi Hataları
========================

Ayrıştırma hataları olarak da bilinen söz dizimi hataları, Python
öğrenirken belki de en sık karşılaşılan hatalardan biridir:

   >>> while True print('Hello world')
     File "<stdin>", line 1
       while True print('Hello world')
                  ^^^^^
   SyntaxError: invalid syntax

The parser repeats the offending line and displays little arrows
pointing at the token in the line where the error was detected.  The
error may be caused by the absence of a token *before* the indicated
token.  In the example, the error is detected at the function
"print()", since a colon ("':'") is missing before it.  File name and
line number are printed so you know where to look in case the input
came from a script.


8.2. Özel Durumlar
==================

Bir komut veya ifade söz dizimsel olarak doğru olsa bile, yürütülmeye
çalışıldığında hataya neden olabilir. Yürütme sırasında algılanan
hatalara *exceptions (özel durumlar)* denir ve bazıları programlar
için kritik değildir: yakında Python programlarında bunların
üstesinden gelmeyi öğreneceksiniz.  Ancak, çoğu özel durum programlar
tarafından önlenemez ve burada gösterildiği gibi hata iletileriyle
sonuçlanır:

   >>> 10 * (1/0)
   Traceback (most recent call last):
     File "<stdin>", line 1, in <module>
       10 * (1/0)
             ~^~
   ZeroDivisionError: division by zero
   >>> 4 + spam*3
   Traceback (most recent call last):
     File "<stdin>", line 1, in <module>
       4 + spam*3
           ^^^^
   NameError: name 'spam' is not defined
   >>> '2' + 2
   Traceback (most recent call last):
     File "<stdin>", line 1, in <module>
       '2' + 2
       ~~~~^~~
   TypeError: can only concatenate str (not "int") to str

Hata iletisinin son satırı hataya neyin sebep olduğu gösterir. Özel
durumlar farklı türlerde gelir ve tür iletinin bir parçası olarak
yazdırılır: örnekteki türler şunlardır "ZeroDivisionError",
"NameError" ve "TypeError". Özel durum türü olarak yazdırılan dize,
oluşan gömülü özel durumun adıdır. Bu, tüm gömülü özel durumlar için
geçerlidir, ancak kullanıcı tanımlı özel durumlar için doğru olması
gerekmez (yararlı bir kural olmasına rağmen). Standart özel durum
adları gömülü tanımlayıcılardır (ayrılmış anahtar sözcükler değildir).

Satırın geri kalanı, özel durum türüne ve buna neyin neden olduğuna
bağlı olarak ayrıntı gösterir.

Hata iletisinin önceki bölümü, özel durumun oluştuğu bağlamı yığın
izleme geri dönüşü biçiminde gösterir. Genel olarak, kaynak satırları
listeleyen bir yığın izleme listesi içerir; ancak, standart girişten
okunan satırları görüntülemez.

Gömülü İstisnalar yerleşik özel durumları ve anlamlarını listeler.


8.3. Özel Durumları İşleme
==========================

Seçili özel durumları işleyen programlar yazmak mümkündür. Geçerli bir
tam sayı girilene kadar kullanıcıdan giriş isteyen, ancak kullanıcının
programı kesmesine izin veren aşağıdaki örneğe bakın ("Control-C" veya
işletim sistemi ne destekliyorsa onu kullanarak); kullanıcı kaynaklı
kesintilerin "KeyboardInterrupt" özel durumu ile gösterildiğini
unutmayın.

   >>> while True:
   ...     try:
   ...         x = int(input("Please enter a number: "))
   ...         break
   ...     except ValueError:
   ...         print("Oops!  That was no valid number.  Try again...")
   ...

"try" ifadesi aşağıdaki gibi çalışır.

* İlk olarak, *try yan tümcesi* ("try" ve "except" anahtar kelimeleri
  arasındaki ifadeler) yürütülür.

* Özel durum oluşmazsa, *except yan tümcesi* atlanır ve "try"
  ifadesinin yürütülmesi tamamlanır.

* "try" yan tümcesinin yürütülmesi sırasında bir özel durum oluşursa,
  yan tümcenin geri kalanı atlanır.  Daha sonra belirtilen "except"
  türü ile karşılaşılırsa, *except yan tümcesi* yürütülür ve
  try/except bloğundan sonra yürütme devam eder.

* If an exception occurs which does not match the exception named in
  the *except clause*, it is passed on to outer "try" statements; if
  no handler is found, it is an *unhandled exception* and execution
  stops with an error message.

"try" ifadesi, farklı özel durumlar için işleyiciler belirtmek üzere
birden fazla *except yan tümcesi* alabilir.  Maksimum bir tane
işleyici yürütülür. İşleyiciler yalnızca karşılık gelen *try yan
tümcesinde* oluşan özel durumları işler, aynı "try" ifadesinin diğer
işleyicilerinde işlemez.  *except yan tümcesi* birden çok özel durumu
parantezli demet olarak adlandırabilir, örneğin:

   ... except (RuntimeError, TypeError, NameError):
   ...     pass

A class in an "except" clause matches exceptions which are instances
of the class itself or one of its derived classes (but not the other
way around --- an *except clause* listing a derived class does not
match instances of its base classes). For example, the following code
will print B, C, D in that order:

   class B(Exception):
       pass

   class C(B):
       pass

   class D(C):
       pass

   for cls in [B, C, D]:
       try:
           raise cls()
       except D:
           print("D")
       except C:
           print("C")
       except B:
           print("B")

*except yan tümceleri* tersine çevrilmişse (ilk olarak "except B" ile)
B, B, B şeklinde yazdırılacaktır --- ilk eşleşen *except yan tümcesi*
tetiklenir.

Bir istisna oluştuğunda, istisnanın *argümanı* olarak da bilinen
ilişkili bir değeri olabilir. Argümanın varlığı ve türü, istisna
türüne bağlıdır.

The *except clause* may specify a variable after the exception name.
The variable is bound to the exception instance which typically has an
"args" attribute that stores the arguments. For convenience, builtin
exception types define "__str__()" to print all the arguments without
explicitly accessing ".args".

   >>> try:
   ...     raise Exception('spam', 'eggs')
   ... except Exception as inst:
   ...     print(type(inst))    # the exception type
   ...     print(inst.args)     # arguments stored in .args
   ...     print(inst)          # __str__ allows args to be printed directly,
   ...                          # but may be overridden in exception subclasses
   ...     x, y = inst.args     # unpack args
   ...     print('x =', x)
   ...     print('y =', y)
   ...
   <class 'Exception'>
   ('spam', 'eggs')
   ('spam', 'eggs')
   x = spam
   y = eggs

The exception's "__str__()" output is printed as the last part
('detail') of the message for unhandled exceptions.

"BaseException", tüm istisnaların ortak temel sınıfıdır. Alt
sınıflarından biri olan "Exception", tüm önemli olmayan istisnaların
temel sınıfıdır. "Exception" öğesinin alt sınıfları olmayan istisnalar
genellikle işlenmez, çünkü bunlar programın sona ermesi gerektiğini
belirtmek için kullanılır. Bunlar "sys.exit()" tarafından oluşturulan
"SystemExit" ve bir kullanıcı programı kesmek istediğinde ortaya çıkan
"KeyboardInterrupt" içerir.

"Exception" (neredeyse) her şeyi yakalayan bir joker karakter
(wildcard) olarak kullanılabilir. Ancak, işlemeyi amaçladığımız
istisna türleri konusunda mümkün olduğunca spesifik olmak ve
beklenmeyen istisnaların yayılmasına izin vermek iyi bir uygulamadır.

"Exception" işlemek için en yaygın model, istisnayı yazdırmak veya
log'a kaydetmek ve ardından yeniden yükseltmektir (arayanın istisnayı
da işlemesine izin verir):

   import sys

   try:
       f = open('myfile.txt')
       s = f.readline()
       i = int(s.strip())
   except OSError as err:
       print("OS error:", err)
   except ValueError:
       print("Could not convert data to an integer.")
   except Exception as err:
       print(f"Unexpected {err=}, {type(err)=}")
       raise

"try" ... "except" ifadesinin isteğe bağlı bir *else yan tümcesi*
vardır, bu da mevcut olduğunda tüm *except yan tümcelerini*
izlemelidir.  *try yan tümcesi* bir özel durum oluşturmazsa
yürütülmesi gereken kod için yararlıdır. Mesela:

   for arg in sys.argv[1:]:
       try:
           f = open(arg, 'r')
       except OSError:
           print('cannot open', arg)
       else:
           print(arg, 'has', len(f.readlines()), 'lines')
           f.close()

"else" yan tümcesinin kullanılması, "try" yan tümcesine ek kod
eklemekten daha iyidir çünkü yanlışlıkla "try" tarafından korunan kod
tarafından oluşturulmamış bir istisnayı yakalamayı önler. ... "except"
ifadesi.

İstisna işleyicileri, yalnızca *try yan tümcesinde* anında ortaya
çıkan istisnaları değil, aynı zamanda *try yan tümcesinde* çağrılan
(dolaylı olarak da olsa) işlevlerin içinde oluşan istisnaları da
işler. Örneğin:

   >>> def this_fails():
   ...     x = 1/0
   ...
   >>> try:
   ...     this_fails()
   ... except ZeroDivisionError as err:
   ...     print('Handling run-time error:', err)
   ...
   Handling run-time error: division by zero


8.4. Hata Yükseltme
===================

"raise" ifadesi, programcının belirli bir istisnanın gerçekleşmesini
zorlamasını sağlar. Örneğin:

   >>> raise NameError('HiThere')
   Traceback (most recent call last):
     File "<stdin>", line 1, in <module>
       raise NameError('HiThere')
   NameError: HiThere

"raise" için tek argüman, ortaya çıkacak istisnayı belirtir. Bu, bir
istisna örneği veya bir istisna sınıfı ("BaseException" 'dan türetilen
bir sınıf, örneğin "Exception" veya alt sınıflarından) olmalıdır.  Bir
istisna sınıfı iletilirse, yapıcısını hiçbir argüman olmadan çağırarak
dolaylı olarak başlatılır:

   raise ValueError  # shorthand for 'raise ValueError()'

Bir istisnanın oluşturulup oluşturulmadığını belirlemeniz gerekiyorsa
ancak onu işlemeyi düşünmüyorsanız, "raise" ifadesinin daha basit bir
biçimi, istisnayı yeniden oluşturmanıza olanak tanır:

   >>> try:
   ...     raise NameError('HiThere')
   ... except NameError:
   ...     print('An exception flew by!')
   ...     raise
   ...
   An exception flew by!
   Traceback (most recent call last):
     File "<stdin>", line 2, in <module>
       raise NameError('HiThere')
   NameError: HiThere


8.5. İstisna Zincirleme
=======================

Bir "except" bölümü içinde işlenmeyen bir istisna meydana gelirse,
istisnanın kendisine eklenmiş olarak işlenmesi ve şu hata mesajına
dahil edilmesi gerekir:

   >>> try:
   ...     open("database.sqlite")
   ... except OSError:
   ...     raise RuntimeError("unable to handle error")
   ...
   Traceback (most recent call last):
     File "<stdin>", line 2, in <module>
       open("database.sqlite")
       ~~~~^^^^^^^^^^^^^^^^^^^
   FileNotFoundError: [Errno 2] No such file or directory: 'database.sqlite'

   During handling of the above exception, another exception occurred:

   Traceback (most recent call last):
     File "<stdin>", line 4, in <module>
       raise RuntimeError("unable to handle error")
   RuntimeError: unable to handle error

"raise" ifadesi, bir istisnanın başka bir istisnanın doğrudan sonucu
olduğunu belirtmek için isteğe bağlı "from" yan tümcesine izin verir:

   # exc must be exception instance or None.
   raise RuntimeError from exc

Bu, özel durumları dönüştürürken yararlı olabilir. Mesela:

   >>> def func():
   ...     raise ConnectionError
   ...
   >>> try:
   ...     func()
   ... except ConnectionError as exc:
   ...     raise RuntimeError('Failed to open database') from exc
   ...
   Traceback (most recent call last):
     File "<stdin>", line 2, in <module>
       func()
       ~~~~^^
     File "<stdin>", line 2, in func
   ConnectionError

   The above exception was the direct cause of the following exception:

   Traceback (most recent call last):
     File "<stdin>", line 4, in <module>
       raise RuntimeError('Failed to open database') from exc
   RuntimeError: Failed to open database

Ayrıca, "from None" deyimi kullanılarak otomatik istisna zincirlemenin
devre dışı bırakılmasına izin verir:

   >>> try:
   ...     open('database.sqlite')
   ... except OSError:
   ...     raise RuntimeError from None
   ...
   Traceback (most recent call last):
     File "<stdin>", line 4, in <module>
       raise RuntimeError from None
   RuntimeError

Zincirleme mekaniği hakkında daha fazla bilgi için bkz. Gömülü
İstisnalar.


8.6. Kullanıcı Tanımlı İstisnalar
=================================

Programlar yeni bir istisna sınıfı oluşturarak kendi özel durumlarını
adlandırabilir (Python sınıfları hakkında daha fazla bilgi için bkz:
Sınıflar ).  Özel durumlar genellikle doğrudan veya dolaylı olarak
"Exception" sınıfından türetilmelidir.

İstisna sınıfları, başka herhangi bir sınıfın yapabileceği her şeyi
yapan tanımlanabilir, ancak genellikle basit tutulur ve çoğu zaman
yalnızca istisna için işleyiciler tarafından hatayla ilgili bilgilerin
çıkarılmasına izin veren bir dizi öznitelik sunar.

Çoğu özel durum, standart özel durumların adlandırışına benzer şekilde
"Hata" ile biten adlarla tanımlanır.

Birçok standart modül, tanımladıkları işlevlerde oluşabilecek hataları
raporlamak için kendi istisnalarını tanımlar.


8.7. Temizleme Eylemlerini Tanımlama
====================================

"try" deyimi, her koşulda yürütülmesi gereken temizleme eylemlerini
tanımlamayı amaçlayan başka bir opsiyonel yan tümceye sahiptir.
Mesela:

   >>> try:
   ...     raise KeyboardInterrupt
   ... finally:
   ...     print('Goodbye, world!')
   ...
   Goodbye, world!
   Traceback (most recent call last):
     File "<stdin>", line 2, in <module>
       raise KeyboardInterrupt
   KeyboardInterrupt

Bir "finally" yan tümcesi varsa, "finally" yan tümcesi "try" deyimi
tamamlanmadan önceki son görev olarak yürütülür. "finally" yan tümcesi
"try" deyiminin bir istisna oluşturup oluşturmadığından bağımsız
çalışır. Aşağıdaki noktalarda, bir istisna oluştuğunda daha karmaşık
durumlar anlatılmaktadır:

* "try" yan tümcesinin yürütülmesi sırasında bir istisna oluşursa,
  istisna bir "except" yan tümcesi tarafından işlenebilir. İstisna bir
  "except" yan tümcesi tarafından ele alınmıyorsa, istisna "finally"
  yan tümcesi yürütüldükten sonra yeniden oluşturulur.

* Bir "except" veya "else" yan tümcesinin yürütülmesi sırasında bir
  istisna oluşabilir. Yine, istisna, "finally" yan tümcesi
  yürütüldükten sonra yeniden oluşturulur.

* "finally" yan tümcesi bir "break", "continue" veya "return" deyimini
  yürütürse, istisnalar yeniden oluşturulmaz.

* "try" ifadesi bir "break", "continue" veya "return" ifadesine
  ulaşırsa, "finally" yan tümcesi "break", "continue" veya "return"
  ifadesinin yürütülmesinin hemen öncesinde yürütülür.

* Bir "finally" yan tümcesi bir "return" ifadesini içeriyorsa,
  döndürülen değer, "finally" yan tümcesinin "return" ifadesindeki
  değer olacaktır, "try" yan tümcesinin "return" ifadesindeki değer
  değil.

Mesela:

   >>> def bool_return():
   ...     try:
   ...         return True
   ...     finally:
   ...         return False
   ...
   >>> bool_return()
   False

Daha karmaşık bir örnek:

   >>> def divide(x, y):
   ...     try:
   ...         result = x / y
   ...     except ZeroDivisionError:
   ...         print("division by zero!")
   ...     else:
   ...         print("result is", result)
   ...     finally:
   ...         print("executing finally clause")
   ...
   >>> divide(2, 1)
   result is 2.0
   executing finally clause
   >>> divide(2, 0)
   division by zero!
   executing finally clause
   >>> divide("2", "1")
   executing finally clause
   Traceback (most recent call last):
     File "<stdin>", line 1, in <module>
       divide("2", "1")
       ~~~~~~^^^^^^^^^^
     File "<stdin>", line 3, in divide
       result = x / y
                ~~^~~
   TypeError: unsupported operand type(s) for /: 'str' and 'str'

Gördüğünüz gibi, "finally" yan tümcesi her durumda yürütülür.  İki
dizeyi bölerek oluşturulan "TypeError", "except" yan tümcesi
tarafından işlenmez ve bu nedenle "finally" yan tümcesi yürütüldikten
sonra yeniden yükseltilir.

Gerçek dünyadaki uygulamalarda "finally" yan tümcesi, kaynağın
kullanımının başarılı olup olmadığına bakılmaksızın dış kaynakları
(dosyalar veya ağ bağlantıları gibi) serbest bırakmak için yararlıdır.


8.8. Önceden Tanımlanmış Temizleme Eylemleri
============================================

Bazı nesneler, nesneyi kullanan işlemin başarılı veya başarısız olup
olmadığına bakılmaksızın, nesne artık gerekli olmadığında
gerçekleştirilecek standart temizleme eylemlerini tanımlar. Bir
dosyayı açmaya ve içeriğini ekrana yazdırmaya çalışan aşağıdaki örneğe
bakın.

   for line in open("myfile.txt"):
       print(line, end="")

Bu kodla ilgili sorun, kodun bu bölümünün yürütülmesi tamamlandıktan
sonra dosyayı belirsiz bir süre açık bırakmasıdır. Bu basit komut
dosyalarında bir sorun değildir, ancak daha büyük uygulamalar için bir
sorun olabilir. "with" ifadesi, dosyalar gibi nesnelerin her zaman
hızlı ve doğru temizlenmesini sağlayacak şekilde kullanılmasına izin
verir.

   with open("myfile.txt") as f:
       for line in f:
           print(line, end="")

İfade çalıştırıldıktan sonra, satırlar işlenirken bir sorunla
karşılaşılsa bile *f* dosyası her zaman kapatılır. Dosyalar gibi
önceden tanımlanmış temizleme eylemleri sağlayan nesneler
dokümantasyonlarında bunu gösterir.


8.9. Birden Fazla Alakasız İstisna Oluşturma ve İşleme
======================================================

Meydana gelen birkaç istisnanın rapor edilmesinin gerekli olduğu
durumlar vardır. Bu, genellikle birkaç görevin paralel olarak
başarısız olabileceği eşzamanlılık çerçevelerinde geçerlidir, ancak
ilk istisnayı yükseltmek yerine yürütmeye devam etmenin ve birden çok
hata toplamanın istendiği başka kullanım durumları da vardır.

Yerleşik "ExceptionGroup", birlikte oluşturulabilmeleri için istisna
örneklerinin bir listesini sarar. Kendisi bir istisnadır, bu nedenle
herhangi bir istisna gibi yakalanabilir.

   >>> def f():
   ...     excs = [OSError('error 1'), SystemError('error 2')]
   ...     raise ExceptionGroup('there were problems', excs)
   ...
   >>> f()
     + Exception Group Traceback (most recent call last):
     |   File "<stdin>", line 1, in <module>
     |     f()
     |     ~^^
     |   File "<stdin>", line 3, in f
     |     raise ExceptionGroup('there were problems', excs)
     | ExceptionGroup: there were problems (2 sub-exceptions)
     +-+---------------- 1 ----------------
       | OSError: error 1
       +---------------- 2 ----------------
       | SystemError: error 2
       +------------------------------------
   >>> try:
   ...     f()
   ... except Exception as e:
   ...     print(f'caught {type(e)}: e')
   ...
   caught <class 'ExceptionGroup'>: e
   >>>

"except" yerine "except*" kullanarak, yalnızca gruptaki belirli bir
türle eşleşen istisnaları seçerek işleyebiliriz. İç içe geçmiş bir
istisna grubunu gösteren aşağıdaki örnekte, her bir "except*" yan
tümcesi, diğer tüm istisnaların diğer yan tümcelere yayılmasına ve
sonunda yeniden ortaya çıkmasına izin verirken, belirli bir türdeki
grup istisnalarını çıkarır.

   >>> def f():
   ...     raise ExceptionGroup(
   ...         "group1",
   ...         [
   ...             OSError(1),
   ...             SystemError(2),
   ...             ExceptionGroup(
   ...                 "group2",
   ...                 [
   ...                     OSError(3),
   ...                     RecursionError(4)
   ...                 ]
   ...             )
   ...         ]
   ...     )
   ...
   >>> try:
   ...     f()
   ... except* OSError as e:
   ...     print("There were OSErrors")
   ... except* SystemError as e:
   ...     print("There were SystemErrors")
   ...
   There were OSErrors
   There were SystemErrors
     + Exception Group Traceback (most recent call last):
     |   File "<stdin>", line 2, in <module>
     |     f()
     |     ~^^
     |   File "<stdin>", line 2, in f
     |     raise ExceptionGroup(
     |     ...<12 lines>...
     |     )
     | ExceptionGroup: group1 (1 sub-exception)
     +-+---------------- 1 ----------------
       | ExceptionGroup: group2 (1 sub-exception)
       +-+---------------- 1 ----------------
         | RecursionError: 4
         +------------------------------------
   >>>

Bir istisna grubunda iç içe geçmiş istisnaların türler değil, örnekler
olması gerektiğini unutmayın. Bunun nedeni, pratikte istisnaların
tipik olarak, aşağıdaki kalıp boyunca program tarafından önceden
oluşturulmuş ve yakalanmış olanlar olmasıdır:

   >>> excs = []
   ... for test in tests:
   ...     try:
   ...         test.run()
   ...     except Exception as e:
   ...         excs.append(e)
   ...
   >>> if excs:
   ...    raise ExceptionGroup("Test Failures", excs)
   ...


8.10. İstisnaları Notlarla Zenginleştirme
=========================================

Yükseltilmek üzere bir istisna oluşturulduğunda, genellikle meydana
gelen hatayı açıklayan bilgilerle başlatılır. İstisna yakalandıktan
sonra bilgi eklemenin yararlı olduğu durumlar vardır. Bu amaçla,
istisnaların bir dizgiyi kabul eden ve onu istisnanın notlar listesine
ekleyen "add_note(note)" metodu vardır. Standart geri işleme
(traceback) oluşturma, tüm notları istisnadan sonra eklendikleri
sırayla içerir.

   >>> try:
   ...     raise TypeError('bad type')
   ... except Exception as e:
   ...     e.add_note('Add some information')
   ...     e.add_note('Add some more information')
   ...     raise
   ...
   Traceback (most recent call last):
     File "<stdin>", line 2, in <module>
       raise TypeError('bad type')
   TypeError: bad type
   Add some information
   Add some more information
   >>>

Örneğin, istisnaları bir istisna grubuna toplarken, bireysel hatalar
için bağlam bilgisi eklemek isteyebiliriz. Aşağıda, gruptaki her özel
durum, bu hatanın ne zaman oluştuğunu gösteren bir nota sahiptir.

   >>> def f():
   ...     raise OSError('operation failed')
   ...
   >>> excs = []
   >>> for i in range(3):
   ...     try:
   ...         f()
   ...     except Exception as e:
   ...         e.add_note(f'Happened in Iteration {i+1}')
   ...         excs.append(e)
   ...
   >>> raise ExceptionGroup('We have some problems', excs)
     + Exception Group Traceback (most recent call last):
     |   File "<stdin>", line 1, in <module>
     |     raise ExceptionGroup('We have some problems', excs)
     | ExceptionGroup: We have some problems (3 sub-exceptions)
     +-+---------------- 1 ----------------
       | Traceback (most recent call last):
       |   File "<stdin>", line 3, in <module>
       |     f()
       |     ~^^
       |   File "<stdin>", line 2, in f
       |     raise OSError('operation failed')
       | OSError: operation failed
       | Happened in Iteration 1
       +---------------- 2 ----------------
       | Traceback (most recent call last):
       |   File "<stdin>", line 3, in <module>
       |     f()
       |     ~^^
       |   File "<stdin>", line 2, in f
       |     raise OSError('operation failed')
       | OSError: operation failed
       | Happened in Iteration 2
       +---------------- 3 ----------------
       | Traceback (most recent call last):
       |   File "<stdin>", line 3, in <module>
       |     f()
       |     ~^^
       |   File "<stdin>", line 2, in f
       |     raise OSError('operation failed')
       | OSError: operation failed
       | Happened in Iteration 3
       +------------------------------------
   >>>
