Пример #1
0
def simulation_from_test(test,
                         monthly_amount=False,
                         default_error_margin=1,
                         forced_error_margin=None):
    year = test["year"]
    parent1 = dict(date_naissance=datetime.date(year - 40, 1, 1))
    menage = dict()
    foyer_fiscal = dict()
    for variable, value in test['input_vars'].iteritems():
        if variable == "age":
            parent1['date_naissance'] = datetime.date(year - value, 1, 1)
        elif tax_benefit_system.variables[variable].entity == 'men':
            menage[variable] = value
        elif tax_benefit_system.variables[variable].entity == 'ind':
            parent1[variable] = value


# TODO: if the person is a child
        elif tax_benefit_system.variables[variable].entity == 'foy':
            foyer_fiscal[variable] = value

    simulation = tax_benefit_system.new_scenario().init_single_entity(
        period=year,
        parent1=parent1,
        menage=menage,
        foyer_fiscal=foyer_fiscal,
    ).new_simulation()

    return simulation
Пример #2
0
def test_basics():
    for scenario_arguments in scenarios_arguments:
        scenario = tax_benefit_system.new_scenario()
        scenario.init_single_entity(**scenario_arguments)
        simulation = scenario.new_simulation(debug = False)
        period = scenario_arguments['period']
        yield check_run, simulation, period
Пример #3
0
def test_decomposition(print_decomposition = False):
    simulation = tax_benefit_system.new_scenario().init_single_entity(
        period = "2013-01",
        parent1 = dict(
            effectif_entreprise = 3000,
            exposition_accident = 3,
            code_postal_entreprise = "75001",
            ratio_alternants = .025,
            salaire_de_base = {"2013": 12 * 3000},
            taille_entreprise = 3,
            categorie_salarie = 0,
            ),
        menage = dict(
            zone_apl = 1,
            ),
        ).new_simulation()

    xml_file_path = os.path.join(
        decompositions_directory,
        "fiche_de_paie_decomposition.xml"
        )

    decomposition_json = decompositions.get_decomposition_json(
        tax_benefit_system, xml_file_path = xml_file_path)
    simulations = [simulation]
    response = decompositions.calculate(simulations, decomposition_json)
    if print_decomposition:
        print unicode(
            json.dumps(response, encoding = 'utf-8', ensure_ascii = False, indent = 2)
            )
def test_2_parents_2_enfants():
    year = 2013
    janvier = '2013-01'

    scenario = tax_benefit_system.new_scenario().init_from_attributes(
        test_case=dict(individus=[
            dict(),
            dict(date_naissance=datetime.date(year - 30, 1, 1)),
            dict(),
            dict(date_naissance=datetime.date(year - 18, 1, 1)),
        ], ),
        repair=True,
        year=year,
    )
    scenario.suggest()
    json.dumps(scenario.to_json(),
               encoding='utf-8',
               ensure_ascii=False,
               indent=2)
    simulation = scenario.new_simulation()
    assert_equal(
        simulation.calculate('date_naissance', period=None).tolist(),
        [
            datetime.date(year - 40, 1, 1),
            datetime.date(year - 30, 1, 1),
            datetime.date(year - 10, 1, 1),
            datetime.date(year - 18, 1, 1),
        ],
    )
    assert_equal(
        simulation.calculate('activite', period=janvier).decode().tolist(),
        [
            TypesActivite.inactif,
            TypesActivite.inactif,
            TypesActivite.etudiant,
            TypesActivite.inactif,
        ],
    )
    assert_equal(
        simulation.calculate('age', period=janvier).tolist(),
        [
            40,
            30,
            10,
            18,
        ],
    )
    assert_equal(
        simulation.calculate('age_en_mois', period=janvier).tolist(),
        [
            40 * 12,
            30 * 12,
            10 * 12,
            18 * 12,
        ],
    )
def test_birth():
    year = 2013
    janvier = '2013-01'

    scenario = tax_benefit_system.new_scenario().init_single_entity(
        period=year,
        parent1=dict(),
        enfants=[
            dict(),
            dict(date_naissance=datetime.date(year - 12, 1, 1)),
            dict(date_naissance=datetime.date(year - 18, 1, 1)),
        ],
    )
    scenario.suggest()
    json.dumps(scenario.to_json(),
               encoding='utf-8',
               ensure_ascii=False,
               indent=2)
    simulation = scenario.new_simulation()
    assert_equal(
        simulation.calculate('date_naissance', period=None).tolist(),
        [
            datetime.date(year - 40, 1, 1),
            datetime.date(year - 10, 1, 1),
            datetime.date(year - 12, 1, 1),
            datetime.date(year - 18, 1, 1),
        ],
    )
    assert_equal(
        simulation.calculate('activite', period=janvier).decode().tolist(),
        [
            TypesActivite.inactif,
            TypesActivite.etudiant,
            TypesActivite.etudiant,
            TypesActivite.inactif,
        ],
    )
    assert_equal(
        simulation.calculate('age', period=janvier).tolist(),
        [
            40,
            10,
            12,
            18,
        ],
    )
    assert_equal(
        simulation.calculate('age_en_mois', period=janvier).tolist(),
        [
            40 * 12,
            10 * 12,
            12 * 12,
            18 * 12,
        ],
    )
def test_decomposition_calculate():
    xml_file_path = tax_benefit_system.decomposition_file_path
    decomposition_json = decompositions.get_decomposition_json(
        tax_benefit_system, xml_file_path)
    year = 2013
    simulation = tax_benefit_system.new_scenario().init_single_entity(
        period=year,
        parent1={},
    ).new_simulation()
    decomposition = decompositions.calculate([simulation], decomposition_json)
    assert isinstance(decomposition, dict)
def test_average_tax_rate():
    year = 2013
    simulation = tax_benefit_system.new_scenario().init_single_entity(
        axes = [
            dict(
                count = 100,
                name = 'salaire_imposable',
                max = 24000,
                min = 0,
                ),
            ],
        period = year,
        parent1 = dict(age = 40),
        ).new_simulation()
    assert (average_rate(
        target = simulation.calculate('revenu_disponible', period = year),
        varying = simulation.calculate('revenu_disponible', period = year),
        ) == 0).all()
def test_nb_enfants():
    test_case = deepcopy(TEST_CASE_AGES)
    simulation = tax_benefit_system.new_scenario().init_from_test_case(
        period=2013, test_case=test_case).new_simulation()
    from openfisca_france.model.prestations.prestations_familiales.base_ressource import nb_enf

    assert_near(
        nb_enf(simulation.famille, simulation.period.first_month, 3, 18),
        [2, 0])
    assert_near(
        nb_enf(simulation.famille, simulation.period.first_month, 19, 50),
        [0, 1])  # Adults don't count

    test_case['individus'][5]['autonomie_financiere'] = True
    simulation_2 = new_simulation(test_case)

    assert_near(
        nb_enf(simulation_2.famille, simulation_2.period.first_month, 19, 50),
        [0, 0])
Пример #9
0
def test_menage_1_personne_de_reference_1_conjoint_2_enfants():
    year = 2013
    janvier = '2013-01'

    scenario = tax_benefit_system.new_scenario().init_from_attributes(
        test_case=dict(
            individus=[
                dict(),
                dict(date_naissance=datetime.date(year - 30, 1, 1)),
                dict(),
                dict(date_naissance=datetime.date(year - 18, 1, 1)),
            ],
            menages=[
                dict(
                    personne_de_reference=0,
                    conjoint=1,
                    enfants=[2, 3],
                ),
            ],
        ),
        repair=True,
        year=year,
    )
    scenario.suggest()
    json.dumps(scenario.to_json(),
               encoding='utf-8',
               ensure_ascii=False,
               indent=2)
    simulation = scenario.new_simulation()
    assert_equal(
        simulation.calculate('date_naissance', period=None).tolist(),
        [
            datetime.date(year - 40, 1, 1),
            datetime.date(year - 30, 1, 1),
            datetime.date(year - 10, 1, 1),
            datetime.date(year - 18, 1, 1),
        ],
    )
    assert_equal(
        simulation.calculate('activite', period=janvier).tolist(),
        [
            4,
            4,
            2,
            4,
        ],
    )
    assert_equal(
        simulation.calculate('age', period=janvier).tolist(),
        [
            40,
            30,
            10,
            18,
        ],
    )
    assert_equal(
        simulation.calculate('age_en_mois', period=janvier).tolist(),
        [
            40 * 12,
            30 * 12,
            10 * 12,
            18 * 12,
        ],
    )
Пример #10
0
def test_foyer_fiscal_2_declarants_2_personnes_a_charge():
    year = 2013
    janvier = '2013-01'

    scenario = tax_benefit_system.new_scenario().init_from_attributes(
        test_case=dict(
            foyers_fiscaux=[
                dict(
                    declarants=[0, 1],
                    personnes_a_charge=[2, 3],
                ),
            ],
            individus=[
                dict(),
                dict(date_naissance=datetime.date(year - 30, 1, 1)),
                dict(),
                dict(date_naissance=datetime.date(year - 18, 1, 1)),
            ],
        ),
        repair=True,
        year=year,
    )
    scenario.suggest()
    json.dumps(scenario.to_json(),
               encoding='utf-8',
               ensure_ascii=False,
               indent=2)
    simulation = scenario.new_simulation()
    assert_equal(
        simulation.calculate('date_naissance', period=janvier).tolist(),
        [
            datetime.date(year - 40, 1, 1),
            datetime.date(year - 30, 1, 1),
            datetime.date(year - 10, 1, 1),
            datetime.date(year - 18, 1, 1),
        ],
    )
    assert_equal(
        simulation.calculate('activite', period=janvier).tolist(),
        [
            4,
            4,
            2,
            4,
        ],
    )
    assert_equal(
        simulation.calculate('age', period=janvier).tolist(),
        [
            40,
            30,
            10,
            18,
        ],
    )
    assert_equal(
        simulation.calculate('age_en_mois', period=janvier).tolist(),
        [
            40 * 12,
            30 * 12,
            10 * 12,
            18 * 12,
        ],
    )