owlplanner 2025.2.8__py3-none-any.whl → 2025.2.9__py3-none-any.whl

owlplanner/abcapi.py

@@ -43,7 +43,7 @@ class Row(object):
         """
         Add an element at index ``ind`` of value ``val`` to the row.
         """
-        assert 0 <= ind and ind < self.nvars, 'Index %d out of range.' % ind
+        assert 0 <= ind and ind < self.nvars, "Index %d out of range." % ind
         self.ind.append(ind)
         self.val.append(val)
 
@@ -96,11 +96,11 @@ class ConstraintMatrix(object):
         self.lb.append(lb)
         self.ub.append(ub)
         if lb == ub:
-            self.key.append('fx')
+            self.key.append("fx")
         elif ub == np.inf:
-            self.key.append('lo')
+            self.key.append("lo")
         else:
-            self.key.append('ra')
+            self.key.append("ra")
         self.ncons += 1
 
     def addNewRow(self, rowDic, lb, ub):
@@ -154,39 +154,39 @@ class Bounds(object):
         self.integrality = []
 
     def setBinary(self, ii):
-        assert 0 <= ii and ii < self.nvars, 'Index %d out of range.' % ii
+        assert 0 <= ii and ii < self.nvars, "Index %d out of range." % ii
         self.ind.append(ii)
         self.lb.append(0)
         self.ub.append(1)
-        self.key.append('ra')
+        self.key.append("ra")
         self.integrality.append(ii)
 
     def set0_Ub(self, ii, ub):
-        assert 0 <= ii and ii < self.nvars, 'Index %d out of range.' % ii
+        assert 0 <= ii and ii < self.nvars, "Index %d out of range." % ii
         self.ind.append(ii)
         self.lb.append(0)
         self.ub.append(ub)
-        self.key.append('ra')
+        self.key.append("ra")
 
     def setLb_Inf(self, ii, lb):
-        assert 0 <= ii and ii < self.nvars, 'Index %d out of range.' % ii
+        assert 0 <= ii and ii < self.nvars, "Index %d out of range." % ii
         self.ind.append(ii)
         self.lb.append(lb)
         self.ub.append(np.inf)
-        self.key.append('lo')
+        self.key.append("lo")
 
     def setRange(self, ii, lb, ub):
-        assert 0 <= ii and ii < self.nvars, 'Index %d out of range.' % ii
+        assert 0 <= ii and ii < self.nvars, "Index %d out of range." % ii
         self.ind.append(ii)
         self.lb.append(lb)
         self.ub.append(ub)
         if lb == ub:
-            self.key.append('fx')
+            self.key.append("fx")
         else:
-            self.key.append('ra')
+            self.key.append("ra")
 
     def keys(self):
-        keys = ['lo'] * self.nvars
+        keys = ["lo"] * self.nvars
         for ii in range(len(self.ind)):
             keys[self.ind[ii]] = self.key[ii]
 
@@ -223,7 +223,7 @@ class Objective(object):
         self.val = []
 
     def setElem(self, ind, val):
-        assert 0 <= ind and ind < self.nvars, 'Index %d out of range.' % ind
+        assert 0 <= ind and ind < self.nvars, "Index %d out of range." % ind
         self.ind.append(ind)
         self.val.append(val)
 

owlplanner/config.py

@@ -24,108 +24,112 @@ def saveConfig(plan, file, mylog):
     Save case parameters and return a dictionary containing all parameters.
     """
     # np.set_printoptions(legacy='1.21')
-    accountTypes = ['taxable', 'tax-deferred', 'tax-free']
+    accountTypes = ["taxable", "tax-deferred", "tax-free"]
 
     diconf = {}
-    diconf['Plan Name'] = plan._name
+    diconf["Plan Name"] = plan._name
 
     # Basic Info.
-    diconf['Basic Info'] = {'Status': ['unknown', 'single', 'married'][plan.N_i],
-                            'Names': plan.inames,
-                            'Birth year': plan.yobs.tolist(),
-                            'Life expectancy': plan.expectancy.tolist(),
-                            'Start date': plan.startDate,
-                            }
+    diconf["Basic Info"] = {
+        "Status": ["unknown", "single", "married"][plan.N_i],
+        "Names": plan.inames,
+        "Birth year": plan.yobs.tolist(),
+        "Life expectancy": plan.expectancy.tolist(),
+        "Start date": plan.startDate,
+    }
 
     # Assets.
-    diconf['Assets'] = {}
+    diconf["Assets"] = {}
     for j in range(plan.N_j):
         amounts = plan.beta_ij[:, j] / 1000
-        diconf['Assets']['%s savings balances' % accountTypes[j]] = amounts.tolist()
+        diconf["Assets"]["%s savings balances" % accountTypes[j]] = amounts.tolist()
     if plan.N_i == 2:
-        diconf['Assets']['Beneficiary fractions'] = plan.phi_j.tolist()
-        diconf['Assets']['Spousal surplus deposit fraction'] = plan.eta
+        diconf["Assets"]["Beneficiary fractions"] = plan.phi_j.tolist()
+        diconf["Assets"]["Spousal surplus deposit fraction"] = plan.eta
 
     # Wages and Contributions.
-    diconf['Wages and Contributions'] = {'Contributions file name': plan.timeListsFileName}
+    diconf["Wages and Contributions"] = {"Contributions file name": plan.timeListsFileName}
 
     # Fixed Income.
-    diconf['Fixed Income'] = {'Pension amounts': (plan.pensionAmounts/1000).tolist(),
-                              'Pension ages': plan.pensionAges.tolist(),
-                              'Pension indexed': plan.pensionIndexed,
-                              'Social security amounts': (plan.ssecAmounts/1000).tolist(),
-                              'Social security ages': plan.ssecAges.tolist(),
-                              }
-
-    # Rate Selection.
-    diconf['Rate Selection'] = {'Heirs rate on tax-deferred estate': float(100 * plan.nu),
-                                'Long-term capital gain tax rate': float(100 * plan.psi),
-                                'Dividend tax rate': float(100 * plan.mu),
-                                'Method': plan.rateMethod,
-                                }
-    if plan.rateMethod in ['user', 'stochastic']:
-        diconf['Rate Selection']['Values'] = (100 * plan.rateValues).tolist()
-    if plan.rateMethod in ['stochastic']:
-        diconf['Rate Selection']['Standard deviations'] = (100 * plan.rateStdev).tolist()
-        diconf['Rate Selection']['Correlations'] = plan.rateCorr.tolist()
-    if plan.rateMethod in ['historical average', 'historical', 'histochastic']:
-        diconf['Rate Selection']['From'] = int(plan.rateFrm)
-        diconf['Rate Selection']['To'] = int(plan.rateTo)
+    diconf["Fixed Income"] = {
+        "Pension amounts": (plan.pensionAmounts / 1000).tolist(),
+        "Pension ages": plan.pensionAges.tolist(),
+        "Pension indexed": plan.pensionIndexed,
+        "Social security amounts": (plan.ssecAmounts / 1000).tolist(),
+        "Social security ages": plan.ssecAges.tolist(),
+    }
+
+    # Rates Selection.
+    diconf["Rates Selection"] = {
+        "Heirs rate on tax-deferred estate": float(100 * plan.nu),
+        "Long-term capital gain tax rate": float(100 * plan.psi),
+        "Dividend tax rate": float(100 * plan.mu),
+        "Method": plan.rateMethod,
+    }
+    if plan.rateMethod in ["user", "stochastic"]:
+        diconf["Rates Selection"]["Values"] = (100 * plan.rateValues).tolist()
+    if plan.rateMethod in ["stochastic"]:
+        diconf["Rates Selection"]["Standard deviations"] = (100 * plan.rateStdev).tolist()
+        diconf["Rates Selection"]["Correlations"] = plan.rateCorr.tolist()
+    if plan.rateMethod in ["historical average", "historical", "histochastic"]:
+        diconf["Rates Selection"]["From"] = int(plan.rateFrm)
+        diconf["Rates Selection"]["To"] = int(plan.rateTo)
     else:
-        diconf['Rate Selection']['From'] = int(FROM)
-        diconf['Rate Selection']['To'] = int(TO)
-
-    # Asset Allocations.
-    diconf['Asset Allocations'] = {'Interpolation method': plan.interpMethod,
-                                   'Interpolation center': float(plan.interpCenter),
-                                   'Interpolation width': float(plan.interpWidth),
-                                   'Type': plan.ARCoord,
-                                   }
-    if plan.ARCoord == 'account':
+        diconf["Rates Selection"]["From"] = int(FROM)
+        diconf["Rates Selection"]["To"] = int(TO)
+
+    # Asset Allocation.
+    diconf["Asset Allocation"] = {
+        "Interpolation method": plan.interpMethod,
+        "Interpolation center": float(plan.interpCenter),
+        "Interpolation width": float(plan.interpWidth),
+        "Type": plan.ARCoord,
+    }
+    if plan.ARCoord == "account":
         for accType in accountTypes:
-            diconf['Asset Allocations'][accType] = plan.boundsAR[accType]
+            diconf["Asset Allocation"][accType] = plan.boundsAR[accType]
     else:
-        diconf['Asset Allocations']['generic'] = plan.boundsAR['generic']
+        diconf["Asset Allocation"]["generic"] = plan.boundsAR["generic"]
 
     # Optimization Parameters.
-    diconf['Optimization Parameters'] = {
-                                         'Spending profile': plan.spendingProfile,
-                                         'Surviving spouse spending percent': int(100 * plan.chi),
-                                        }
-    if plan.spendingProfile == 'smile':
-        diconf['Optimization Parameters']['Smile dip'] = int(plan.smileDip)
-        diconf['Optimization Parameters']['Smile increase'] = int(plan.smileIncrease)
-        diconf['Optimization Parameters']['Smile delay'] = int(plan.smileDelay)
-
-    diconf['Optimization Parameters']['Objective'] = plan.objective
-    diconf['Solver Options'] = plan.solverOptions
+    diconf["Optimization Parameters"] = {
+        "Spending profile": plan.spendingProfile,
+        "Surviving spouse spending percent": int(100 * plan.chi),
+    }
+    if plan.spendingProfile == "smile":
+        diconf["Optimization Parameters"]["Smile dip"] = int(plan.smileDip)
+        diconf["Optimization Parameters"]["Smile increase"] = int(plan.smileIncrease)
+        diconf["Optimization Parameters"]["Smile delay"] = int(plan.smileDelay)
+
+    diconf["Optimization Parameters"]["Objective"] = plan.objective
+    diconf["Solver Options"] = plan.solverOptions
 
     # Results.
-    diconf['Results'] = {'Default plots': plan.defaultPlots}
+    diconf["Results"] = {"Default plots": plan.defaultPlots}
 
     if isinstance(file, str):
         filename = file
-        if not file.endswith('.toml'):
-            filename = filename + '.toml'
-        if not filename.startswith('case_'):
-            filename = 'case_' + filename
+        if not file.endswith(".toml"):
+            filename = filename + ".toml"
+        if not filename.startswith("case_"):
+            filename = "case_" + filename
         mylog.vprint("Saving plan case file as '%s'." % filename)
 
         try:
-            with open(filename, 'w') as casefile:
+            with open(filename, "w") as casefile:
                 toml.dump(diconf, casefile, encoder=toml.TomlNumpyEncoder())
         except Exception as e:
-            raise RuntimeError('Failed to save case file %s: %s' % (filename, e))
+            raise RuntimeError("Failed to save case file %s: %s" % (filename, e))
     elif isinstance(file, StringIO):
         try:
             string = toml.dumps(diconf, encoder=toml.TomlNumpyEncoder())
             file.write(string)
         except Exception as e:
-            raise RuntimeError('Failed to save case to StringIO: %s', e)
+            raise RuntimeError("Failed to save case to StringIO: %s", e)
     elif file is None:
         pass
     else:
-        raise ValueError('Argument %s has unknown type' % type(file))
+        raise ValueError("Argument %s has unknown type" % type(file))
 
     return diconf
 
@@ -138,146 +142,147 @@ def readConfig(file, *, verbose=True, logstreams=None, readContributions=True):
     """
     mylog = logging.Logger(verbose, logstreams)
 
-    accountTypes = ['taxable', 'tax-deferred', 'tax-free']
+    accountTypes = ["taxable", "tax-deferred", "tax-free"]
 
-    dirname = ''
+    dirname = ""
     if isinstance(file, str):
         filename = file
         dirname = os.path.dirname(filename)
-        if not filename.endswith('.toml'):
-            filename = filename + '.toml'
+        if not filename.endswith(".toml"):
+            filename = filename + ".toml"
 
         mylog.vprint("Reading plan from case file '%s'." % filename)
 
         try:
-            with open(filename, 'r') as f:
+            with open(filename, "r") as f:
                 diconf = toml.load(f)
         except Exception as e:
-            raise FileNotFoundError('File %s not found: %s' % (filename, e))
+            raise FileNotFoundError("File %s not found: %s" % (filename, e))
     elif isinstance(file, BytesIO):
         try:
-            string = file.getvalue().decode('utf-8')
+            string = file.getvalue().decode("utf-8")
             diconf = toml.loads(string)
         except Exception as e:
-            raise RuntimeError('Cannot read from BytesIO: %s' % e)
+            raise RuntimeError("Cannot read from BytesIO: %s" % e)
     elif isinstance(file, StringIO):
         try:
             string = file.getvalue()
             diconf = toml.loads(string)
         except Exception as e:
-            raise RuntimeError('Cannot read from StringIO: %s' % e)
+            raise RuntimeError("Cannot read from StringIO: %s" % e)
     else:
-        raise ValueError('%s not a valid type' % type(file))
+        raise ValueError("%s not a valid type" % type(file))
 
     # Basic Info.
-    name = diconf['Plan Name']
-    inames = diconf['Basic Info']['Names']
+    name = diconf["Plan Name"]
+    inames = diconf["Basic Info"]["Names"]
     # status = diconf['Basic Info']['Status']
-    yobs = diconf['Basic Info']['Birth year']
-    expectancy = diconf['Basic Info']['Life expectancy']
-    startDate = diconf['Basic Info']['Start date']
+    yobs = diconf["Basic Info"]["Birth year"]
+    expectancy = diconf["Basic Info"]["Life expectancy"]
+    startDate = diconf["Basic Info"]["Start date"]
     icount = len(yobs)
 
-    mylog.vprint('Plan for %d individual%s: %s.' % (icount, ['', 's'][icount - 1], inames))
+    mylog.vprint("Plan for %d individual%s: %s." % (icount, ["", "s"][icount - 1], inames))
     p = plan.Plan(inames, yobs, expectancy, name, startDate=startDate, verbose=True, logstreams=logstreams)
 
     # Assets.
     balances = {}
     for acc in accountTypes:
-        balances[acc] = diconf['Assets']['%s savings balances' % acc]
-    p.setAccountBalances(taxable=balances['taxable'], taxDeferred=balances['tax-deferred'],
-                         taxFree=balances['tax-free'])
+        balances[acc] = diconf["Assets"]["%s savings balances" % acc]
+    p.setAccountBalances(
+        taxable=balances["taxable"], taxDeferred=balances["tax-deferred"], taxFree=balances["tax-free"]
+    )
     if icount == 2:
-        phi_j = diconf['Assets']['Beneficiary fractions']
+        phi_j = diconf["Assets"]["Beneficiary fractions"]
         p.setBeneficiaryFractions(phi_j)
-        eta = diconf['Assets']['Spousal surplus deposit fraction']
+        eta = diconf["Assets"]["Spousal surplus deposit fraction"]
         p.setSpousalDepositFraction(eta)
 
     # Wages and Contributions.
-    timeListsFileName = diconf['Wages and Contributions']['Contributions file name']
-    if timeListsFileName != 'None':
+    timeListsFileName = diconf["Wages and Contributions"]["Contributions file name"]
+    if timeListsFileName != "None":
         if readContributions:
             if os.path.exists(timeListsFileName):
                 myfile = timeListsFileName
-            elif dirname != '' and os.path.exists(dirname + '/' + timeListsFileName):
-                myfile = dirname + '/' + timeListsFileName
+            elif dirname != "" and os.path.exists(dirname + "/" + timeListsFileName):
+                myfile = dirname + "/" + timeListsFileName
             else:
                 raise FileNotFoundError("File '%s' not found." % timeListsFileName)
             p.readContributions(myfile)
         else:
             p.timeListsFileName = timeListsFileName
-            mylog.vprint('Ignoring to read contributions file %s.' % timeListsFileName)
+            mylog.vprint("Ignoring to read contributions file %s." % timeListsFileName)
 
     # Fixed Income.
-    ssecAmounts = np.array(diconf['Fixed Income']['Social security amounts'], dtype=np.float32)
-    ssecAges = np.array(diconf['Fixed Income']['Social security ages'], dtype=np.int32)
+    ssecAmounts = np.array(diconf["Fixed Income"]["Social security amounts"], dtype=np.float32)
+    ssecAges = np.array(diconf["Fixed Income"]["Social security ages"], dtype=np.int32)
     p.setSocialSecurity(ssecAmounts, ssecAges)
-    pensionAmounts = np.array(diconf['Fixed Income']['Pension amounts'], dtype=np.float32)
-    pensionAges = np.array(diconf['Fixed Income']['Pension ages'], dtype=np.int32)
-    pensionIndexed = diconf['Fixed Income']['Pension indexed']
+    pensionAmounts = np.array(diconf["Fixed Income"]["Pension amounts"], dtype=np.float32)
+    pensionAges = np.array(diconf["Fixed Income"]["Pension ages"], dtype=np.int32)
+    pensionIndexed = diconf["Fixed Income"]["Pension indexed"]
     p.setPension(pensionAmounts, pensionAges, pensionIndexed)
 
-    # Rate Selection.
-    p.setDividendRate(float(diconf['Rate Selection']['Dividend tax rate']))
-    p.setLongTermCapitalTaxRate(float(diconf['Rate Selection']['Long-term capital gain tax rate']))
-    p.setHeirsTaxRate(float(diconf['Rate Selection']['Heirs rate on tax-deferred estate']))
+    # Rates Selection.
+    p.setDividendRate(float(diconf["Rates Selection"]["Dividend tax rate"]))
+    p.setLongTermCapitalTaxRate(float(diconf["Rates Selection"]["Long-term capital gain tax rate"]))
+    p.setHeirsTaxRate(float(diconf["Rates Selection"]["Heirs rate on tax-deferred estate"]))
 
     frm = None
     to = None
     rateValues = None
     stdev = None
     rateCorr = None
-    rateMethod = diconf['Rate Selection']['Method']
-    if rateMethod in ['historical average', 'historical', 'histochastic']:
-        frm = diconf['Rate Selection']['From']
+    rateMethod = diconf["Rates Selection"]["Method"]
+    if rateMethod in ["historical average", "historical", "histochastic"]:
+        frm = diconf["Rates Selection"]["From"]
         if not isinstance(frm, int):
             frm = int(frm)
-        to = int(diconf['Rate Selection']['To'])
+        to = int(diconf["Rates Selection"]["To"])
         if not isinstance(to, int):
             to = int(to)
-    if rateMethod in ['user', 'stochastic']:
-        rateValues = np.array(diconf['Rate Selection']['Values'], dtype=np.float32)
-    if rateMethod in ['stochastic']:
-        stdev = np.array(diconf['Rate Selection']['Standard deviations'], dtype=np.float32)
-        rateCorr = np.array(diconf['Rate Selection']['Correlations'], dtype=np.float32)
+    if rateMethod in ["user", "stochastic"]:
+        rateValues = np.array(diconf["Rates Selection"]["Values"], dtype=np.float32)
+    if rateMethod in ["stochastic"]:
+        stdev = np.array(diconf["Rates Selection"]["Standard deviations"], dtype=np.float32)
+        rateCorr = np.array(diconf["Rates Selection"]["Correlations"], dtype=np.float32)
     p.setRates(rateMethod, frm, to, rateValues, stdev, rateCorr)
 
     # Asset Allocation.
     boundsAR = {}
     p.setInterpolationMethod(
-        diconf['Asset Allocations']['Interpolation method'],
-        float(diconf['Asset Allocations']['Interpolation center']),
-        float(diconf['Asset Allocations']['Interpolation width']),
+        diconf["Asset Allocation"]["Interpolation method"],
+        float(diconf["Asset Allocation"]["Interpolation center"]),
+        float(diconf["Asset Allocation"]["Interpolation width"]),
     )
-    allocType = diconf['Asset Allocations']['Type']
-    if allocType == 'account':
+    allocType = diconf["Asset Allocation"]["Type"]
+    if allocType == "account":
         for aType in accountTypes:
-            boundsAR[aType] = np.array(diconf['Asset Allocations'][aType], dtype=np.float32)
+            boundsAR[aType] = np.array(diconf["Asset Allocation"][aType], dtype=np.float32)
 
         p.setAllocationRatios(
             allocType,
-            taxable=boundsAR['taxable'],
-            taxDeferred=boundsAR['tax-deferred'],
-            taxFree=boundsAR['tax-free'],
+            taxable=boundsAR["taxable"],
+            taxDeferred=boundsAR["tax-deferred"],
+            taxFree=boundsAR["tax-free"],
         )
-    elif allocType == 'individual' or allocType == 'spouses':
-        boundsAR['generic'] = np.array(diconf['Asset Allocations']['generic'], dtype=np.float32)
+    elif allocType == "individual" or allocType == "spouses":
+        boundsAR["generic"] = np.array(diconf["Asset Allocation"]["generic"], dtype=np.float32)
         p.setAllocationRatios(
             allocType,
-            generic=boundsAR['generic'],
+            generic=boundsAR["generic"],
         )
     else:
-        raise ValueError('Unknown asset allocation type %s.' % allocType)
+        raise ValueError("Unknown asset allocation type %s." % allocType)
 
     # Optimization Parameters.
-    p.objective = diconf['Optimization Parameters']['Objective']
-
-    profile = diconf['Optimization Parameters']['Spending profile']
-    survivor = int(diconf['Optimization Parameters']['Surviving spouse spending percent'])
-    if profile == 'smile':
-        dip = int(diconf['Optimization Parameters']['Smile dip'])
-        increase = int(diconf['Optimization Parameters']['Smile increase'])
-        delay = int(diconf['Optimization Parameters']['Smile delay'])
+    p.objective = diconf["Optimization Parameters"]["Objective"]
+
+    profile = diconf["Optimization Parameters"]["Spending profile"]
+    survivor = int(diconf["Optimization Parameters"]["Surviving spouse spending percent"])
+    if profile == "smile":
+        dip = int(diconf["Optimization Parameters"]["Smile dip"])
+        increase = int(diconf["Optimization Parameters"]["Smile increase"])
+        delay = int(diconf["Optimization Parameters"]["Smile delay"])
     else:
         dip = 15
         increase = 12
@@ -286,9 +291,9 @@ def readConfig(file, *, verbose=True, logstreams=None, readContributions=True):
     p.setSpendingProfile(profile, survivor, dip, increase, delay)
 
     # Solver Options.
-    p.solverOptions = diconf['Solver Options']
+    p.solverOptions = diconf["Solver Options"]
 
     # Results.
-    p.setDefaultPlots(diconf['Results']['Default plots'])
+    p.setDefaultPlots(diconf["Results"]["Default plots"])
 
     return p

owlplanner/logging.py

@@ -19,15 +19,15 @@ class Logger(object):
         self._prevState = self._verbose
         if logstreams is None or logstreams == [] or len(logstreams) > 2:
             self._logstreams = [sys.stdout, sys.stderr]
-            self.vprint('Using stdout and stderr as stream loggers.')
+            self.vprint("Using stdout and stderr as stream loggers.")
         elif len(logstreams) == 2:
             self._logstreams = logstreams
-            self.vprint('Using logstreams as stream loggers.')
+            self.vprint("Using logstreams as stream loggers.")
         elif len(logstreams) == 1:
-            self._logstreams = 2*logstreams
-            self.vprint('Using logstream as stream logger.')
+            self._logstreams = 2 * logstreams
+            self.vprint("Using logstream as stream logger.")
         else:
-            raise ValueError('Log streams %r must be a list.' % logstreams)
+            raise ValueError("Log streams %r must be a list." % logstreams)
 
     def setVerbose(self, verbose=True):
         """
@@ -36,7 +36,7 @@ class Logger(object):
         """
         self._prevState = self._verbose
         self._verbose = verbose
-        self.vprint('Setting verbose to', verbose)
+        self.vprint("Setting verbose to", verbose)
 
         return self._prevState
 
@@ -51,9 +51,9 @@ class Logger(object):
         Unconditional printing regardless of the value of the verbose variable
         previously set.
         """
-        if 'file' not in kwargs:
+        if "file" not in kwargs:
             file = self._logstreams[0]
-            kwargs['file'] = file
+            kwargs["file"] = file
 
         print(*args, **kwargs)
         file.flush()
@@ -71,14 +71,14 @@ class Logger(object):
         Print message and exit. Use to print error messages on stderr.
         The exit() used throws an exception in an interactive environment.
         """
-        if 'file' not in kwargs:
+        if "file" not in kwargs:
             file = self._logstreams[1]
-            kwargs['file'] = file
+            kwargs["file"] = file
 
         if self._verbose:
-            print('ERROR:', *args, **kwargs)
-            print('Exiting...')
+            print("ERROR:", *args, **kwargs)
+            print("Exiting...")
             file.flush()
 
-        raise Exception('Fatal error.')
+        raise Exception("Fatal error.")
         # sys.exit(-1)