taxcalc 4.4.0__py3-none-any.whl → 4.5.0__py3-none-any.whl

taxcalc/tests/test_consumption.py

@@ -1,18 +1,24 @@
+"""
+Test Consumption class and its methods.
+"""
 # CODING-STYLE CHECKS:
 # pycodestyle test_consumption.py
+# pylint --disable=locally-disabled test_consumption.py
 
+import copy
 import numpy as np
-import paramtools
 import pytest
-import copy
+import paramtools
 from taxcalc import Policy, Records, Calculator, Consumption
 
 
 def test_start_year_consistency():
+    """Test docstring"""
     assert Consumption.JSON_START_YEAR == Policy.JSON_START_YEAR
 
 
 def test_validity_of_consumption_vars_set():
+    """Test docstring"""
     records_varinfo = Records(data=None)
     assert Consumption.RESPONSE_VARS.issubset(records_varinfo.USABLE_READ_VARS)
     useable_vars = set(['housing', 'snap', 'tanf', 'vet', 'wic',
@@ -21,6 +27,7 @@ def test_validity_of_consumption_vars_set():
 
 
 def test_update_consumption():
+    """Test docstring"""
     consump = Consumption()
     consump.update_consumption({})
     revision = {
@@ -33,21 +40,29 @@ def test_update_consumption():
     expected_mpc_e20400 = np.full((consump.num_years,), 0.06)
     expected_mpc_e20400[0] = 0.0
     expected_mpc_e20400[1] = 0.05
-    assert np.allclose(consump._MPC_e20400,
-                       expected_mpc_e20400,
-                       rtol=0.0)
-    assert np.allclose(consump._MPC_e17500,
-                       np.zeros((consump.num_years,)),
-                       rtol=0.0)
+    assert np.allclose(
+        consump._MPC_e20400,  # pylint: disable=protected-access
+        expected_mpc_e20400,
+        rtol=0.0
+    )
+    assert np.allclose(
+        consump._MPC_e17500,  # pylint: disable=protected-access
+        np.zeros((consump.num_years,)),
+        rtol=0.0
+    )
     expected_ben_mcare_value = np.full((consump.num_years,), 0.80)
     expected_ben_mcare_value[0] = 1.0
     expected_ben_mcare_value[1] = 0.75
-    assert np.allclose(consump._BEN_mcare_value,
-                       expected_ben_mcare_value,
-                       rtol=0.0)
-    assert np.allclose(consump._BEN_snap_value,
-                       np.ones((consump.num_years,)),
-                       rtol=0.0)
+    assert np.allclose(
+        consump._BEN_mcare_value,  # pylint: disable=protected-access
+        expected_ben_mcare_value,
+        rtol=0.0
+    )
+    assert np.allclose(
+        consump._BEN_snap_value,  # pylint: disable=protected-access
+        np.ones((consump.num_years,)),
+        rtol=0.0
+    )
     consump.set_year(2015)
     assert consump.current_year == 2015
     assert consump.MPC_e20400 == 0.06
@@ -57,6 +72,7 @@ def test_update_consumption():
 
 
 def test_incorrect_update_consumption():
+    """Test docstring"""
     with pytest.raises(paramtools.ValidationError):
         Consumption().update_consumption([])
     with pytest.raises(paramtools.ValidationError):
@@ -74,6 +90,7 @@ def test_incorrect_update_consumption():
 
 
 def test_future_update_consumption():
+    """Test docstring"""
     consump = Consumption()
     assert consump.current_year == consump.start_year
     assert consump.has_response() is False
@@ -97,6 +114,7 @@ def test_future_update_consumption():
 
 
 def test_consumption_default_data():
+    """Test docstring"""
     consump = Consumption()
     pdata = consump.specification(meta_data=True, ignore_state=True)
     for pname in pdata.keys():
@@ -107,24 +125,26 @@ def test_consumption_default_data():
 
 
 def test_consumption_response(cps_subsample):
+    """Test docstring"""
+    # pylint: disable=too-many-locals
     consump = Consumption()
     mpc = 0.5
     consumption_response = {'MPC_e20400': {2013: mpc}}
     consump.update_consumption(consumption_response)
     # test incorrect call to response method
     with pytest.raises(ValueError):
-        consump.response(list(), 1)
+        consump.response([], 1)
     # test correct call to response method
     rec = Records.cps_constructor(data=cps_subsample)
-    pre = copy.deepcopy(rec.e20400)
+    pre = copy.deepcopy(getattr(rec, 'e20400'))
     consump.response(rec, 1.0)
-    post = rec.e20400
+    post = getattr(rec, 'e20400')
     actual_diff = post - pre
     expected_diff = np.ones(rec.array_length) * mpc
     assert np.allclose(actual_diff, expected_diff)
     # compute earnings mtr with no consumption response
     rec = Records.cps_constructor(data=cps_subsample)
-    ided0 = copy.deepcopy(rec.e20400)
+    ided0 = copy.deepcopy(getattr(rec, 'e20400'))
     calc0 = Calculator(policy=Policy(), records=rec, consumption=None)
     (mtr0_ptax, mtr0_itax, _) = calc0.mtr(variable_str='e00200p',
                                           wrt_full_compensation=False)

taxcalc/tests/test_cpscsv.py

@@ -17,8 +17,11 @@ import json
 import pytest
 import numpy as np
 import pandas as pd
-# pylint: disable=import-error
-from taxcalc import GrowFactors, GrowDiff, Policy, Records, Calculator
+from taxcalc.growfactors import GrowFactors
+from taxcalc.growdiff import GrowDiff
+from taxcalc.policy import Policy
+from taxcalc.records import Records
+from taxcalc.calculator import Calculator
 
 
 START_YEAR = 2017
@@ -52,7 +55,7 @@ def test_agg(tests_path, cps_fullsample):
         if not np.allclose(adt[icol], edt[str(icol)]):
             diffs = True
     if diffs:
-        new_filename = '{}{}'.format(aggres_path[:-10], 'actual.csv')
+        new_filename = f'{aggres_path[:-10]}actual.csv'
         adt.to_csv(new_filename, float_format='%.1f')
         msg = 'CPSCSV AGG RESULTS DIFFER\n'
         msg += '-------------------------------------------------\n'
@@ -65,7 +68,7 @@ def test_agg(tests_path, cps_fullsample):
         raise ValueError(msg)
     # create aggregate diagnostic table using unweighted sub-sample of records
     rn_seed = 180  # to ensure sub-sample is always the same
-    subfrac = 0.07# 0.03  # sub-sample fraction
+    subfrac = 0.07  # sub-sample fraction
     subsample = cps_fullsample.sample(frac=subfrac, random_state=rn_seed)
     recs_subsample = Records.cps_constructor(data=subsample)
     calc_subsample = Calculator(policy=baseline_policy, records=recs_subsample)
@@ -84,14 +87,17 @@ def test_agg(tests_path, cps_fullsample):
         if not np.allclose(taxes_subsample[cyr], taxes_fullsample[cyr],
                            atol=0.0, rtol=reltol):
             reldiff = (taxes_subsample[cyr] / taxes_fullsample[cyr]) - 1.
-            line1 = '\nCPSCSV AGG SUB-vs-FULL RESULTS DIFFER IN {}'
-            line2 = '\n  when subfrac={:.3f}, rtol={:.4f}, seed={}'
-            line3 = '\n  with sub={:.3f}, full={:.3f}, rdiff={:.4f}'
-            msg += line1.format(cyr)
-            msg += line2.format(subfrac, reltol, rn_seed)
-            msg += line3.format(taxes_subsample[cyr],
-                                taxes_fullsample[cyr],
-                                reldiff)
+            line1 = f'\nCPSCSV AGG SUB-vs-FULL RESULTS DIFFER IN {cyr}'
+            line2 = (
+                f'\n  when subfrac={subfrac:.3f}, rtol={reltol:.4f}, '
+                f'seed={rn_seed}'
+            )
+            line3 = (
+                f'\n  with sub={taxes_subsample[cyr]:.3f}, '
+                f'full={taxes_fullsample[cyr]:.3f}, '
+                f'rdiff={reldiff:.4f}'
+            )
+            msg += line1 + line2 + line3
     if msg:
         raise ValueError(msg)
 
@@ -104,7 +110,7 @@ def test_cps_availability(tests_path, cps_path):
     cpsvars = set(list(cpsdf))
     # make set of variable names that are marked as cps.csv available
     rvpath = os.path.join(tests_path, '..', 'records_variables.json')
-    with open(rvpath, 'r') as rvfile:
+    with open(rvpath, 'r', encoding='utf-8') as rvfile:
         rvdict = json.load(rvfile)
     recvars = set()
     for vname, vdict in rvdict['read'].items():
@@ -142,24 +148,20 @@ def nonsmall_diffs(linelist1, linelist2, small=0.0):
     for line1, line2 in zip(linelist1, linelist2):
         if line1 == line2:
             continue
-        else:
-            tokens1 = line1.replace(',', '').split()
-            tokens2 = line2.replace(',', '').split()
-            for tok1, tok2 in zip(tokens1, tokens2):
-                tok1_isfloat = isfloat(tok1)
-                tok2_isfloat = isfloat(tok2)
-                if tok1_isfloat and tok2_isfloat:
-                    if abs(float(tok1) - float(tok2)) <= smallamt:
-                        continue
-                    else:
-                        return True
-                elif not tok1_isfloat and not tok2_isfloat:
-                    if tok1 == tok2:
-                        continue
-                    else:
-                        return True
-                else:
-                    return True
+        tokens1 = line1.replace(',', '').split()
+        tokens2 = line2.replace(',', '').split()
+        for tok1, tok2 in zip(tokens1, tokens2):
+            tok1_isfloat = isfloat(tok1)
+            tok2_isfloat = isfloat(tok2)
+            if tok1_isfloat and tok2_isfloat:
+                if abs(float(tok1) - float(tok2)) <= smallamt:
+                    continue
+                return True
+            if not tok1_isfloat and not tok2_isfloat:
+                if tok1 == tok2:
+                    continue
+                return True
+            return True
         return False
 
 

taxcalc/tests/test_data.py

@@ -1,5 +1,9 @@
+"""
+Test Data class and its methods.
+"""
 # CODING-STYLE CHECKS:
 # pycodestyle test_data.py
+# pylint --disable=locally-disabled test_data.py
 
 import os
 import tempfile
@@ -75,14 +79,17 @@ def test_recs_class(recs_varinfo_file, cps_subsample):
             super().__init__(data, start_year, gfactors, weights)
 
         def _extrapolate(self, year):
-            self.e00300 *= self.gfactors.factor_value('AINTS', year)
+            val = getattr(self, 'e00300')
+            setattr(
+                self, 'e00300', val * self.gfactors.factor_value('AINTS', year)
+            )
 
-    # test Recs class for incorrect instantiation
+    # test Recs class for incorrect instantiation:
     with pytest.raises(ValueError):
-        Recs(data=list(), start_year=2000,
+        Recs(data=[], start_year=2000,
              gfactors=None, weights=None)
     with pytest.raises(ValueError):
-        Recs(data=cps_subsample, start_year=list(),
+        Recs(data=cps_subsample, start_year=[],
              gfactors=None, weights=None)
     with pytest.raises(ValueError):
         Recs(data=cps_subsample, start_year=2000,
@@ -93,19 +100,18 @@ def test_recs_class(recs_varinfo_file, cps_subsample):
     with pytest.raises(ValueError):
         Recs(data=cps_subsample, start_year=2000,
              gfactors='', weights='')
-    # test Recs class for correct instantiation with no aging of data
+    # test Recs class for correct instantiation with no aging of data:
     syr = 2014
     rec = Recs(data=cps_subsample, start_year=syr,
                gfactors=None, weights=None)
-    assert isinstance(rec, Recs)
-    assert np.all(rec.MARS != 0)
-    assert rec.data_year == syr
-    assert rec.current_year == syr
-    sum_e00300_in_syr = rec.e00300.sum()
+    assert np.all(getattr(rec, 'MARS') != 0)
+    assert getattr(rec, 'data_year') == syr
+    assert getattr(rec, 'current_year') == syr
+    sum_e00300_in_syr = getattr(rec, 'e00300').sum()
     rec.increment_year()
-    assert rec.data_year == syr
-    assert rec.current_year == syr + 1
-    sum_e00300_in_syr_plus_one = rec.e00300.sum()
+    assert getattr(rec, 'data_year') == syr
+    assert getattr(rec, 'current_year') == syr + 1
+    sum_e00300_in_syr_plus_one = getattr(rec, 'e00300').sum()
     assert np.allclose([sum_e00300_in_syr], [sum_e00300_in_syr_plus_one])
     del rec
     # test Recs class for correct instantiation with aging of data
@@ -114,20 +120,21 @@ def test_recs_class(recs_varinfo_file, cps_subsample):
     rec = Recs(data=cps_subsample, start_year=syr,
                gfactors=GrowFactors(), weights=wghts_df)
     assert isinstance(rec, Recs)
-    assert np.all(rec.MARS != 0)
-    assert rec.data_year == syr
-    assert rec.current_year == syr
-    sum_s006_in_syr = rec.s006.sum()
-    sum_e00300_in_syr = rec.e00300.sum()
+    assert np.all(getattr(rec, 'MARS') != 0)
+    assert getattr(rec, 'data_year') == syr
+    assert getattr(rec, 'current_year') == syr
+    sum_s006_in_syr = getattr(rec, 's006').sum()
+    sum_e00300_in_syr = getattr(rec, 'e00300').sum()
     rec.increment_year()
-    assert rec.data_year == syr
-    assert rec.current_year == syr + 1
-    sum_s006_in_syr_plus_one = rec.s006.sum()
+    assert getattr(rec, 'data_year') == syr
+    assert getattr(rec, 'current_year') == syr + 1
+    sum_s006_in_syr_plus_one = getattr(rec, 's006').sum()
     assert sum_s006_in_syr_plus_one > sum_s006_in_syr
-    sum_e00300_in_syr_plus_one = rec.e00300.sum()
+    sum_e00300_in_syr_plus_one = getattr(rec, 'e00300').sum()
     assert sum_e00300_in_syr_plus_one > sum_e00300_in_syr
-    # test private methods
+    # test private methods:
+    # pylint: disable=protected-access
     rec._read_data(data=None)
     rec._read_weights(weights=None)
     with pytest.raises(ValueError):
-        rec._read_weights(weights=list())
+        rec._read_weights(weights=[])

taxcalc/tests/test_decorators.py

@@ -1,18 +1,28 @@
+"""
+Test decorators.
+"""
 # CODING-STYLE CHECKS:
 # pycodestyle test_decorators.py
+# pylint --disable=locally-disabled test_decorators.py
 
 import os
-import sys
-import pytest
 import importlib
 import numpy as np
 from pandas import DataFrame
 from pandas.testing import assert_frame_equal
+import pytest
 import taxcalc
-from taxcalc.decorators import *
+from taxcalc.decorators import (
+    iterate_jit,
+    apply_jit,
+    create_apply_function_string,
+    create_toplevel_function_string,
+    make_apply_function,
+)
 
 
 def test_create_apply_function_string():
+    """Test docstring"""
     ans = create_apply_function_string(['a', 'b', 'c'], ['d', 'e'], [])
     exp = ("def ap_func(x_0,x_1,x_2,x_3,x_4):\n"
            "  for i in range(len(x_0)):\n"
@@ -22,6 +32,7 @@ def test_create_apply_function_string():
 
 
 def test_create_apply_function_string_with_params():
+    """Test docstring"""
     ans = create_apply_function_string(['a', 'b', 'c'], ['d', 'e'], ['d'])
     exp = ("def ap_func(x_0,x_1,x_2,x_3,x_4):\n"
            "  for i in range(len(x_0)):\n"
@@ -31,6 +42,7 @@ def test_create_apply_function_string_with_params():
 
 
 def test_create_toplevel_function_string_mult_outputs():
+    """Test docstring"""
     ans = create_toplevel_function_string(['a', 'b'], ['d', 'e'],
                                           ['pm', 'pm', 'pf', 'pm'])
     exp = ''
@@ -55,6 +67,7 @@ def test_create_toplevel_function_string_mult_outputs():
 
 
 def test_create_toplevel_function_string():
+    """Test docstring"""
     ans = create_toplevel_function_string(['a'], ['d', 'e'],
                                           ['pm', 'pf', 'pm'])
     exp = ''
@@ -78,12 +91,14 @@ def test_create_toplevel_function_string():
 
 
 def some_calc(x, y, z):
+    """Function docstring"""
     a = x + y
     b = x + y + z
     return (a, b)
 
 
 def test_make_apply_function():
+    """Test docstring"""
     ans_do_jit = make_apply_function(some_calc, ['a', 'b'], ['x', 'y', 'z'],
                                      [], do_jit=True, no_python=True)
     assert ans_do_jit
@@ -93,33 +108,45 @@ def test_make_apply_function():
 
 
 @apply_jit(["a", "b"], ["x", "y", "z"], nopython=True)
-def Magic_calc(x, y, z):
+def magic_calc(x, y, z):
+    """Function docstring"""
     a = x + y
     b = x + y + z
     return (a, b)
 
 
-def Magic(pm, pf):
+def magic(pm, pf):
+    """Function docstring"""
     # Adjustments
-    outputs = pf.a, pf.b = Magic_calc(pm, pf)
+    # pylint: disable=no-value-for-parameter
+    outputs = pf.a, pf.b = magic_calc(pm, pf)
+    # pylint: enable=no-value-for-parameter
     header = ['a', 'b']
     return DataFrame(data=np.column_stack(outputs), columns=header)
 
 
 @iterate_jit(nopython=True)
-def Magic_calc2(x, y, z):
+def magic_calc2(x, y, z):
+    """Function docstring"""
     a = x + y
     b = x + y + z
     return (a, b)
 
 
-class Foo(object):
-    pass
+class Foo:  # pylint: disable=too-many-instance-attributes
+    """Foo class"""
+
+    def faux_method1(self):
+        """ Foo method"""
+
+    def faux_method2(self):
+        """ Foo method"""
 
 
 @iterate_jit(nopython=True)
-def faux_function(MARS):
-    if MARS == 1:
+def faux_function(mars):
+    """Function docstring"""
+    if mars == 1:
         var = 2
     else:
         var = 1
@@ -128,17 +155,21 @@ def faux_function(MARS):
 
 @iterate_jit(nopython=True)
 def ret_everything(a, b, c, d, e, f):
-
+    """Function docstring"""
+    # pylint: disable=too-many-arguments,too-many-positional-arguments
     c = a + b
     d = a + b
     e = a + b
     f = a + b
-
     return (c, d, e,
             f)
 
 
+# pylint: disable=attribute-defined-outside-init
+
+
 def test_magic_apply_jit():
+    """Test docstring"""
     pm = Foo()
     pf = Foo()
     pm.a = np.ones((5,))
@@ -146,12 +177,13 @@ def test_magic_apply_jit():
     pf.x = np.ones((5,))
     pf.y = np.ones((5,))
     pf.z = np.ones((5,))
-    xx = Magic(pm, pf)
+    xx = magic(pm, pf)
     exp = DataFrame(data=[[2.0, 3.0]] * 5, columns=["a", "b"])
     assert_frame_equal(xx, exp)
 
 
 def test_magic_apply_jit_swap():
+    """Test docstring"""
     pm = Foo()
     pf = Foo()
     pm.a = np.ones((5,))
@@ -159,12 +191,16 @@ def test_magic_apply_jit_swap():
     pf.x = np.ones((5,))
     pf.y = np.ones((5,))
     pf.z = np.ones((5,))
-    xx = Magic(pf, pm)
+    xx = magic(pf, pm)  # pylint: disable=arguments-out-of-order
     exp = DataFrame(data=[[2.0, 3.0]] * 5, columns=["a", "b"])
     assert_frame_equal(xx, exp)
 
 
+# pylint: disable=no-value-for-parameter
+
+
 def test_magic_iterate_jit():
+    """Test docstring"""
     pm = Foo()
     pf = Foo()
     pm.a = np.ones((1, 5))
@@ -172,22 +208,24 @@ def test_magic_iterate_jit():
     pf.x = np.ones((5,))
     pf.y = np.ones((5,))
     pf.z = np.ones((5,))
-    xx = Magic_calc2(pm, pf)
+    xx = magic_calc2(pm, pf)
     exp = DataFrame(data=[[2.0, 3.0]] * 5, columns=["a", "b"])
     assert_frame_equal(xx, exp)
 
 
 def test_faux_function_iterate_jit():
+    """Test docstring"""
     pm = Foo()
     pf = Foo()
-    pf.MARS = np.ones((5,))
+    pf.mars = np.ones((5,))
     pf.var = np.ones((5,))
-    ans = faux_function(pm, pf)
+    ans = faux_function(pm, pf)  # pylint: disable=too-many-function-args
     exp = DataFrame(data=[2.0] * 5, columns=['var'])
     assert_frame_equal(ans, exp)
 
 
 def test_ret_everything_iterate_jit():
+    """Test docstring"""
     pm = Foo()
     pf = Foo()
     pf.a = np.ones((5,))
@@ -203,13 +241,15 @@ def test_ret_everything_iterate_jit():
 
 
 @iterate_jit(nopython=True)
-def Magic_calc3(x, y, z):
+def magic_calc3(x, y, z):
+    """Function docstring"""
     a = x + y
     b = a + z
     return (a, b)
 
 
 def test_function_takes_kwarg():
+    """Test docstring"""
     pm = Foo()
     pf = Foo()
     pm.a = np.ones((1, 5))
@@ -217,20 +257,22 @@ def test_function_takes_kwarg():
     pf.x = np.ones((5,))
     pf.y = np.ones((5,))
     pf.z = np.ones((5,))
-    ans = Magic_calc3(pm, pf)
+    ans = magic_calc3(pm, pf)
     exp = DataFrame(data=[[2.0, 3.0]] * 5,
                     columns=["a", "b"])
     assert_frame_equal(ans, exp)
 
 
 @iterate_jit(nopython=True)
-def Magic_calc4(x, y, z):
+def magic_calc4(x, y, z):
+    """Function docstring"""
     a = x + y
     b = a + z
     return (a, b)
 
 
 def test_function_no_parameters_listed():
+    """Test docstring"""
     pm = Foo()
     pf = Foo()
     pm.a = np.ones((1, 5))
@@ -238,20 +280,22 @@ def test_function_no_parameters_listed():
     pf.x = np.ones((5,))
     pf.y = np.ones((5,))
     pf.z = np.ones((5,))
-    ans = Magic_calc4(pm, pf)
+    ans = magic_calc4(pm, pf)
     exp = DataFrame(data=[[2.0, 3.0]] * 5,
                     columns=["a", "b"])
     assert_frame_equal(ans, exp)
 
 
 @iterate_jit(parameters=['w'], nopython=True)
-def Magic_calc5(w, x, y, z):
+def magic_calc5(w, x, y, z):
+    """Function docstring"""
     a = x + y
     b = w[0] + x + y + z
     return (a, b)
 
 
 def test_function_parameters_optional():
+    """Test docstring"""
     pm = Foo()
     pf = Foo()
     pm.a = np.ones((1, 5))
@@ -260,30 +304,37 @@ def test_function_parameters_optional():
     pf.x = np.ones((5,))
     pf.y = np.ones((5,))
     pf.z = np.ones((5,))
-    ans = Magic_calc5(pm, pf)
+    ans = magic_calc5(pm, pf)
     exp = DataFrame(data=[[2.0, 4.0]] * 5,
                     columns=["a", "b"])
     assert_frame_equal(ans, exp)
 
 
+# pylint: enable=no-value-for-parameter
+
+
 def unjittable_function1(w, x, y, z):
-    a = x + y
-    b = w[0] + x + y + z
+    """Function docstring"""
+    a = x + y  # pylint: disable=unused-variable
+    b = w[0] + x + y + z  # pylint: disable=unused-variable
 
 
 def unjittable_function2(w, x, y, z):
+    """Function docstring"""
     a = x + y
     b = w[0] + x + y + z
-    return (a, b, c)
+    return (a, b, c)  # pylint: disable=undefined-variable
 
 
 def test_iterate_jit_raises_on_no_return():
+    """Test docstring"""
     with pytest.raises(ValueError):
         ij = iterate_jit(parameters=['w'], nopython=True)
         ij(unjittable_function1)
 
 
 def test_iterate_jit_raises_on_unknown_return_argument():
+    """Test docstring"""
     ij = iterate_jit(parameters=['w'], nopython=True)
     uf2 = ij(unjittable_function2)
     pm = Foo()
@@ -295,10 +346,11 @@ def test_iterate_jit_raises_on_unknown_return_argument():
     pf.y = np.ones((5,))
     pf.z = np.ones((5,))
     with pytest.raises(AttributeError):
-        ans = uf2(pm, pf)
+        ans = uf2(pm, pf)  # pylint: disable=unused-variable
 
 
-def Magic_calc6(w, x, y, z):
+def magic_calc6(w, x, y, z):
+    """Function docstring"""
     a = x + y
     b = w[0] + x + y + z
     return (a, b)
@@ -313,8 +365,8 @@ def test_force_no_jit():
     os.environ['NOTAXCALCJIT'] = 'NOJIT'
     # reload the decorators module
     importlib.reload(taxcalc.decorators)
-    # verify Magic_calc6 function works as expected
-    Magic_calc6_ = iterate_jit(parameters=['w'], nopython=True)(Magic_calc6)
+    # verify magic_calc6 function works as expected
+    magic_calc6_ = iterate_jit(parameters=['w'], nopython=True)(magic_calc6)
     pm = Foo()
     pf = Foo()
     pm.a = np.ones((1, 5))
@@ -323,7 +375,7 @@ def test_force_no_jit():
     pf.x = np.ones((5,))
     pf.y = np.ones((5,))
     pf.z = np.ones((5,))
-    ans = Magic_calc6_(pm, pf)
+    ans = magic_calc6_(pm, pf)
     exp = DataFrame(data=[[2.0, 4.0]] * 5,
                     columns=["a", "b"])
     assert_frame_equal(ans, exp)