Пример #1
0
 def make_json_to_array_by_period(self, period):
     return conv.condition(
         conv.test_isinstance(dict),
         conv.pipe(
             # Value is a dict of (period, value) couples.
             conv.uniform_mapping(
                 conv.pipe(
                     conv.function(periods.period),
                     conv.not_none,
                 ),
                 conv.pipe(
                     conv.make_item_to_singleton(),
                     conv.uniform_sequence(self.json_to_dated_python, ),
                     conv.empty_to_none,
                     conv.function(lambda cells_list: np.array(
                         cells_list, dtype=self.dtype)),
                 ),
                 drop_none_values=True,
             ),
             conv.empty_to_none,
         ),
         conv.pipe(
             conv.make_item_to_singleton(),
             conv.uniform_sequence(self.json_to_dated_python, ),
             conv.empty_to_none,
             conv.function(
                 lambda cells_list: np.array(cells_list, dtype=self.dtype)),
             conv.function(lambda array: {period: array}),
         ),
     )
def validate_dated_value_json(value, state = None):
    if value is None:
        return None, None
    container = state.ancestors[-1]
    value_converter = dict(
        boolean = conv.condition(
            conv.test_isinstance(int),
            conv.test_in((0, 1)),
            conv.test_isinstance(bool),
            ),
        float = conv.condition(
            conv.test_isinstance(int),
            conv.anything_to_float,
            conv.test_isinstance(float),
            ),
        integer = conv.condition(
            conv.test_isinstance(float),
            conv.pipe(
                conv.test(lambda number: round(number) == number),
                conv.function(int),
                ),
            conv.test_isinstance(int),
            ),
        rate = conv.condition(
            conv.test_isinstance(int),
            conv.anything_to_float,
            conv.test_isinstance(float),
            ),
        )[container.get('format') or 'float']  # Only parameters have a "format".
    return value_converter(value, state = state or conv.default_state)
def validate_dated_value_json(value, state=None):
    if value is None:
        return None, None
    container = state.ancestors[-1]
    value_converter = dict(
        boolean=conv.condition(
            conv.test_isinstance(int),
            conv.test_in((0, 1)),
            conv.test_isinstance(bool),
        ),
        float=conv.condition(
            conv.test_isinstance(int),
            conv.anything_to_float,
            conv.test_isinstance(float),
        ),
        integer=conv.condition(
            conv.test_isinstance(float),
            conv.pipe(
                conv.test(lambda number: round(number) == number),
                conv.function(int),
            ),
            conv.test_isinstance(int),
        ),
        rate=conv.condition(
            conv.test_isinstance(int),
            conv.anything_to_float,
            conv.test_isinstance(float),
        ),
    )[container.get('format') or 'float']  # Only parameters have a "format".
    return value_converter(value, state=state or conv.default_state)
Пример #4
0
 def input_to_dated_python(self):
     return conv.pipe(
         conv.test(year_or_month_or_day_re.match, error=N_('Invalid date')),
         conv.function(lambda birth: '-'.join(
             (birth.split('-') + ['01', '01'])[:3])),
         conv.iso8601_input_to_date,
     )
def input_to_json_data(value, state=None):
    return conv.pipe(
        conv.make_input_to_json(),
        conv.test_isinstance(dict),
        conv.struct(
            dict(
                resultat_officiel=conv.pipe(
                    conv.test_isinstance(dict),
                    conv.uniform_mapping(
                        conv.pipe(
                            conv.test_isinstance(basestring),
                            conv.not_none,
                        ),
                        conv.pipe(
                            conv.test_isinstance(dict),
                            conv.struct(
                                dict(
                                    code=conv.pipe(
                                        conv.test_isinstance(basestring),
                                        conv.not_none,
                                    ),
                                    name=conv.pipe(
                                        conv.test_isinstance(basestring),
                                        conv.not_none,
                                    ),
                                    value=conv.pipe(
                                        conv.test_isinstance(float),
                                        conv.not_none,
                                    ),
                                ), ),
                            conv.not_none,
                        ),
                    ),
                    conv.not_none,
                ),
                scenario=conv.pipe(
                    conv.test_isinstance(dict),
                    conv.struct(
                        dict(
                            test_case=conv.pipe(
                                conv.test_isinstance(dict),
                                # For each entity convert its members from a dict to a list.
                                conv.uniform_mapping(
                                    conv.noop,
                                    conv.pipe(
                                        conv.test_isinstance(dict),
                                        conv.function(
                                            transform_entity_member_by_id_to_members
                                        ),
                                    ),
                                ),
                            ), ),
                        default=conv.noop,
                    ),
                    tax_benefit_system.Scenario.make_json_to_instance(
                        tax_benefit_system=tax_benefit_system),
                    conv.not_none,
                ),
            ), ),
    )(value, state=state or conv.default_state)
Пример #6
0
 def json_to_dated_python(self):
     return conv.pipe(
         conv.condition(
             conv.test_isinstance((float, int)),
             # YAML stores strings containing only digits as numbers.
             conv.function(str),
         ),
         conv.test_isinstance(basestring_type),
     )
Пример #7
0
 def json_to_dated_python(self):
     return conv.pipe(
         conv.condition(
             conv.test_isinstance((float, int)),
             # YAML stores strings containing only digits as numbers.
             conv.function(str),
         ),
         conv.test_isinstance(basestring_type),
         conv.test(lambda value: len(value) <= self.variable.max_length),
     )
    def validate_node_json(node, state=None):
        if node is None:
            return None, None
        if state is None:
            state = conv.default_state
        validated_node, errors = conv.pipe(
            conv.condition(
                conv.test_isinstance(list),
                conv.uniform_sequence(
                    validate_node_json,
                    drop_none_items=True,
                ),
                conv.pipe(
                    conv.condition(
                        conv.test_isinstance(basestring_type),
                        conv.function(lambda code: dict(code=code)),
                        conv.test_isinstance(dict),
                    ),
                    conv.struct(
                        dict(
                            children=conv.pipe(
                                conv.test_isinstance(list),
                                conv.uniform_sequence(
                                    validate_node_json,
                                    drop_none_items=True,
                                ),
                                conv.empty_to_none,
                            ),
                            code=conv.pipe(
                                conv.test_isinstance(basestring_type),
                                conv.cleanup_line,
                            ),
                        ),
                        constructor=collections.OrderedDict,
                        default=conv.noop,
                        drop_none_values='missing',
                        keep_value_order=True,
                    ),
                ),
            ),
            conv.empty_to_none,
        )(node, state=state)
        if validated_node is None or errors is not None:
            return validated_node, errors

        if isinstance(validated_node,
                      dict) and not validated_node.get('children'):
            validated_node, errors = conv.struct(
                dict(code=conv.pipe(
                    conv.test_in(tax_benefit_system.variables),
                    conv.not_none,
                ), ),
                default=conv.noop,
            )(validated_node, state=state)
        return validated_node, errors
Пример #9
0
 def json_to_dated_python(self):
     return conv.pipe(
         conv.condition(
             conv.test_isinstance(datetime.date),
             conv.noop,
             conv.condition(
                 conv.test_isinstance(int),
                 conv.pipe(
                     conv.test_between(1870, 2099),
                     conv.function(lambda year: datetime.date(year, 1, 1)),
                     ),
                 conv.pipe(
                     conv.test_isinstance(basestring_type),
                     conv.test(year_or_month_or_day_re.match, error = N_('Invalid date')),
                     conv.function(lambda birth: '-'.join((birth.split('-') + ['01', '01'])[:3])),
                     conv.iso8601_input_to_date,
                     ),
                 ),
             ),
         conv.test_between(datetime.date(1870, 1, 1), datetime.date(2099, 12, 31)),
         )
Пример #10
0
def make_json_or_python_to_axes(tax_benefit_system):
    column_by_name = tax_benefit_system.variables
    return conv.pipe(
        conv.test_isinstance(list),
        conv.uniform_sequence(
            conv.pipe(
                conv.item_or_sequence(
                    conv.pipe(
                        conv.test_isinstance(dict),
                        conv.struct(
                            dict(
                                count=conv.pipe(
                                    conv.test_isinstance(int),
                                    conv.test_greater_or_equal(1),
                                    conv.not_none,
                                ),
                                index=conv.pipe(
                                    conv.test_isinstance(int),
                                    conv.test_greater_or_equal(0),
                                    conv.default(0),
                                ),
                                max=conv.pipe(
                                    conv.test_isinstance((float, int)),
                                    conv.not_none,
                                ),
                                min=conv.pipe(
                                    conv.test_isinstance((float, int)),
                                    conv.not_none,
                                ),
                                name=conv.pipe(
                                    conv.test_isinstance(basestring_type),
                                    conv.test_in(column_by_name),
                                    conv.test(
                                        lambda column_name: tax_benefit_system.
                                        get_variable(column_name).dtype in
                                        (np.float32, np.int16, np.int32),
                                        error=N_(
                                            'Invalid type for axe: integer or float expected'
                                        )),
                                    conv.not_none,
                                ),
                                period=conv.function(periods.period),
                            ), ),
                    ),
                    drop_none_items=True,
                ),
                conv.make_item_to_singleton(),
            ),
            drop_none_items=True,
        ),
        conv.empty_to_none,
    )
Пример #11
0
    def json_to_dated_python(self):
        enum = self.variable.possible_values
        possible_names = [item.name for item in list(enum)]

        if enum is None:
            return conv.pipe(conv.test_isinstance(basestring_type))
        return conv.pipe(
            conv.test_isinstance(basestring_type),
            conv.pipe(
                # Verify that item belongs to enumeration.
                conv.test_in(possible_names),
                # Transform that item into enum object.
                conv.function(lambda enum_name: enum[enum_name])))
Пример #12
0
 def json_to_python(self):
     return conv.condition(
         conv.test_isinstance(dict),
         conv.pipe(
             # Value is a dict of (period, value) couples.
             conv.uniform_mapping(
                 conv.pipe(
                     conv.function(periods.period),
                     conv.not_none,
                 ),
                 self.json_to_dated_python,
             ), ),
         self.json_to_dated_python,
     )
Пример #13
0
def check_entities_and_role(test_case, tax_benefit_system, state):
    """
        Check that the test_case describes entities consistent with the tax and benefit system.

        Will raise an error if :
            - An entity is not recognized
            - An entity role is not recognized
            - A variable is declared for an entity it is not defined for (e.g. salary for a family)
    """

    test_case = deepcopy(
        test_case)  # Avoid side-effects on other references to test_case
    entity_classes = {
        entity_class.plural: entity_class
        for entity_class in tax_benefit_system.entities
    }
    for entity_type_name, entities in test_case.items():
        if entity_classes.get(entity_type_name) is None:
            raise ValueError("Invalid entity name: {}".format(
                entity_type_name).encode('utf-8'))
        entities, error = conv.pipe(
            conv.make_item_to_singleton(),
            conv.test_isinstance(list),
            conv.uniform_sequence(
                conv.test_isinstance(dict),
                drop_none_items=True,
            ),
            conv.function(set_entities_json_id),
        )(entities)
        if error is not None:
            raise ValueError("Invalid list of {}: {}. Error: {}".format(
                entity_type_name, entities, error).encode('utf-8'))
        if entities is None:
            entities = test_case[entity_type_name] = [
            ]  # YAML test runner may set these values to None
        entity_class = entity_classes[entity_type_name]
        valid_roles = dict(
            (role.key, role) if (role.max == 1) else (role.plural, role) for
            role in entity_class.roles) if not entity_class.is_person else {}

        for entity_json in entities:
            check_entity_fields(entity_json, entity_class, valid_roles,
                                tax_benefit_system)

    for entity_class in entity_classes.values():
        if test_case.get(entity_class.plural) is None:
            test_case[entity_class.plural] = [
            ]  # by convention, all entities must be declared in the test_case

    return test_case
def input_to_json_data(value, state=None):
    return conv.pipe(
        conv.make_input_to_json(),
        conv.test_isinstance(dict),
        conv.struct(
            dict(
                resultat_officiel=conv.pipe(
                    conv.test_isinstance(dict),
                    conv.uniform_mapping(
                        conv.pipe(conv.test_isinstance(basestring), conv.not_none),
                        conv.pipe(
                            conv.test_isinstance(dict),
                            conv.struct(
                                dict(
                                    code=conv.pipe(conv.test_isinstance(basestring), conv.not_none),
                                    name=conv.pipe(conv.test_isinstance(basestring), conv.not_none),
                                    value=conv.pipe(conv.test_isinstance(float), conv.not_none),
                                )
                            ),
                            conv.not_none,
                        ),
                    ),
                    conv.not_none,
                ),
                scenario=conv.pipe(
                    conv.test_isinstance(dict),
                    conv.struct(
                        dict(
                            test_case=conv.pipe(
                                conv.test_isinstance(dict),
                                # For each entity convert its members from a dict to a list.
                                conv.uniform_mapping(
                                    conv.noop,
                                    conv.pipe(
                                        conv.test_isinstance(dict),
                                        conv.function(transform_entity_member_by_id_to_members),
                                    ),
                                ),
                            )
                        ),
                        default=conv.noop,
                    ),
                    tax_benefit_system.Scenario.make_json_to_instance(tax_benefit_system=tax_benefit_system),
                    conv.not_none,
                ),
            )
        ),
    )(value, state=state or conv.default_state)
Пример #15
0
        def json_or_python_to_attributes(value, state=None):
            if value is None:
                return value, None
            if state is None:
                state = conv.default_state

            # First validation and conversion step
            data, error = conv.pipe(
                conv.test_isinstance(dict),
                # TODO: Remove condition below, once every calls uses "period" instead of "date" & "year".
                self.cleanup_period_in_json_or_python,
                conv.struct(
                    dict(
                        axes=make_json_or_python_to_axes(
                            self.tax_benefit_system),
                        input_variables=conv.test_isinstance(
                            dict
                        ),  # Real test is done below, once period is known.
                        period=conv.pipe(
                            conv.function(periods.period),
                            conv.not_none,
                        ),
                        test_case=conv.test_isinstance(
                            dict
                        ),  # Real test is done below, once period is known.
                    ), ),
            )(value, state=state)
            if error is not None:
                return data, error

            # Second validation and conversion step
            data, error = conv.struct(
                dict(
                    input_variables=make_json_or_python_to_input_variables(
                        self.tax_benefit_system, data['period']),
                    test_case=self.make_json_or_python_to_test_case(
                        period=data['period'], repair=repair),
                ),
                default=conv.noop,
            )(data, state=state)
            if error is not None:
                return data, error

            # Third validation and conversion step
            errors = {}
            if data['input_variables'] is not None and data[
                    'test_case'] is not None:
                errors['input_variables'] = state._(
                    "Items input_variables and test_case can't both exist")
                errors['test_case'] = state._(
                    "Items input_variables and test_case can't both exist")
            elif data['axes'] is not None and data["test_case"] is None:
                errors['axes'] = state._(
                    "Axes can't be used with input_variables.")
            if errors:
                return data, errors

            if data['axes'] is not None:
                for parallel_axes_index, parallel_axes in enumerate(
                        data['axes']):
                    first_axis = parallel_axes[0]
                    axis_count = first_axis['count']
                    axis_entity_key = tbs.get_variable(
                        first_axis['name']).entity.key
                    first_axis_period = first_axis['period'] or data['period']
                    for axis_index, axis in enumerate(parallel_axes):
                        if axis['min'] >= axis['max']:
                            errors.setdefault('axes', {}).setdefault(
                                parallel_axes_index, {}
                            ).setdefault(axis_index, {})['max'] = state._(
                                "Max value must be greater than min value")
                        column = tbs.get_variable(axis['name'])
                        if axis['index'] >= len(
                                data['test_case'][column.entity.plural]):
                            errors.setdefault('axes', {}).setdefault(
                                parallel_axes_index, {}).setdefault(
                                    axis_index, {})['index'] = state._(
                                        "Index must be lower than {}").format(
                                            len(data['test_case'][
                                                column.entity.plural]))
                        if axis_index > 0:
                            if axis['count'] != axis_count:
                                errors.setdefault('axes', {}).setdefault(
                                    parallel_axes_index, {}
                                ).setdefault(
                                    axis_index, {}
                                )['count'] = state._(
                                    "Parallel indexes must have the same count"
                                )
                            if column.entity.key != axis_entity_key:
                                errors.setdefault('axes', {}).setdefault(
                                    parallel_axes_index, {}
                                ).setdefault(
                                    axis_index, {}
                                )['period'] = state._(
                                    "Parallel indexes must belong to the same entity"
                                )
                            axis_period = axis['period'] or data['period']
                            if axis_period.unit != first_axis_period.unit:
                                errors.setdefault('axes', {}).setdefault(
                                    parallel_axes_index, {}
                                ).setdefault(
                                    axis_index, {}
                                )['period'] = state._(
                                    "Parallel indexes must have the same period unit"
                                )
                            elif axis_period.size != first_axis_period.size:
                                errors.setdefault('axes', {}).setdefault(
                                    parallel_axes_index, {}
                                ).setdefault(
                                    axis_index, {}
                                )['period'] = state._(
                                    "Parallel indexes must have the same period size"
                                )
                if errors:
                    return data, errors

            self.axes = data['axes']
            if data['input_variables'] is not None:
                self.input_variables = data['input_variables']
            self.period = data['period']
            if data['test_case'] is not None:
                self.test_case = data['test_case']
            return self, None
        def json_or_python_to_test_case(value, state = None):
            if value is None:
                return value, None
            if state is None:
                state = conv.default_state

            column_by_name = self.tax_benefit_system.column_by_name

            # First validation and conversion step
            test_case, error = conv.pipe(
                conv.test_isinstance(dict),
                conv.struct(
                    dict(
                        familles = conv.pipe(
                            conv.condition(
                                conv.test_isinstance(list),
                                conv.pipe(
                                    conv.uniform_sequence(
                                        conv.test_isinstance(dict),
                                        drop_none_items = True,
                                        ),
                                    conv.function(lambda values: collections.OrderedDict(
                                        (value.pop('id', index), value)
                                        for index, value in enumerate(values)
                                        )),
                                    ),
                                ),
                            conv.test_isinstance(dict),
                            conv.uniform_mapping(
                                conv.pipe(
                                    conv.test_isinstance((basestring, int)),
                                    conv.not_none,
                                    ),
                                conv.pipe(
                                    conv.test_isinstance(dict),
                                    conv.struct(
                                        dict(itertools.chain(
                                            dict(
                                                enfants = conv.pipe(
                                                    conv.test_isinstance(list),
                                                    conv.uniform_sequence(
                                                        conv.test_isinstance((basestring, int)),
                                                        drop_none_items = True,
                                                        ),
                                                    conv.default([]),
                                                    ),
                                                parents = conv.pipe(
                                                    conv.test_isinstance(list),
                                                    conv.uniform_sequence(
                                                        conv.test_isinstance((basestring, int)),
                                                        drop_none_items = True,
                                                        ),
                                                    conv.default([]),
                                                    ),
                                                ).iteritems(),
                                            (
                                                (column.name, column.json_to_python)
                                                for column in column_by_name.itervalues()
                                                if column.entity == 'fam'
                                                ),
                                            )),
                                        drop_none_values = True,
                                        ),
                                    ),
                                drop_none_values = True,
                                ),
                            conv.default({}),
                            ),
                        individus = conv.pipe(
                            conv.condition(
                                conv.test_isinstance(list),
                                conv.pipe(
                                    conv.uniform_sequence(
                                        conv.test_isinstance(dict),
                                        drop_none_items = True,
                                        ),
                                    conv.function(lambda values: collections.OrderedDict(
                                        (value.pop('id', index), value)
                                        for index, value in enumerate(values)
                                        )),
                                    ),
                                ),
                            conv.test_isinstance(dict),
                            conv.uniform_mapping(
                                conv.pipe(
                                    conv.test_isinstance((basestring, int)),
                                    conv.not_none,
                                    ),
                                conv.pipe(
                                    conv.test_isinstance(dict),
                                    conv.struct(
                                        dict(
                                            (column.name, column.json_to_python)
                                            for column in column_by_name.itervalues()
                                            if column.entity == 'ind' and column.name not in (
                                                'idfam', 'idfoy', 'idmen', 'quifam', 'quifoy', 'quimen')
                                            ),
                                        drop_none_values = True,
                                        ),
                                    ),
                                drop_none_values = True,
                                ),
                            conv.empty_to_none,
                            conv.not_none,
                            ),
                        ),
                    ),
                )(value, state = state)
            if error is not None:
                return test_case, error

            # Second validation step
            familles_individus_id = list(test_case['individus'].iterkeys())
            test_case, error = conv.struct(
                dict(
                    familles = conv.uniform_mapping(
                        conv.noop,
                        conv.struct(
                            dict(
                                enfants = conv.uniform_sequence(conv.test_in_pop(familles_individus_id)),
                                parents = conv.uniform_sequence(conv.test_in_pop(familles_individus_id)),
                                ),
                            default = conv.noop,
                            ),
                        ),
                    ),
                default = conv.noop,
                )(test_case, state = state)

            remaining_individus_id = set(familles_individus_id)
            if remaining_individus_id:
                if error is None:
                    error = {}
                for individu_id in remaining_individus_id:
                    error.setdefault('individus', {})[individu_id] = state._(u"Individual is missing from {}").format(
                        state._(u' & ').join(
                            word
                            for word in [
                                u'familles' if individu_id in familles_individus_id else None,
                                ]
                            if word is not None
                            ))
            if error is not None:
                return test_case, error

            return test_case, error
Пример #17
0
    def validate_node_xml_json(node, state=None):
        validated_node, errors = conv.pipe(
            conv.test_isinstance(dict),
            conv.struct(
                dict(
                    code=conv.pipe(
                        conv.test_isinstance(basestring_type),
                        conv.cleanup_line,
                        conv.not_none,
                    ),
                    color=conv.pipe(
                        conv.test_isinstance(basestring_type),
                        conv.function(lambda colors: colors.split(',')),
                        conv.uniform_sequence(
                            conv.pipe(
                                conv.input_to_int,
                                conv.test_between(0, 255),
                                conv.not_none,
                            ), ),
                        conv.test(
                            lambda colors: len(colors) == 3,
                            error=N_('Wrong number of colors in triplet.')),
                        conv.function(lambda colors: ','.join(
                            to_unicode(color) for color in colors)),
                    ),
                    desc=conv.pipe(
                        conv.test_isinstance(basestring_type),
                        conv.cleanup_line,
                        conv.not_none,
                    ),
                    NODE=conv.pipe(
                        conv.test_isinstance(list),
                        conv.uniform_sequence(
                            validate_node_xml_json,
                            drop_none_items=True,
                        ),
                        conv.empty_to_none,
                    ),
                    shortname=conv.pipe(
                        conv.test_isinstance(basestring_type),
                        conv.cleanup_line,
                        conv.not_none,
                    ),
                    tail=conv.pipe(
                        conv.test_isinstance(basestring_type),
                        conv.cleanup_text,
                    ),
                    text=conv.pipe(
                        conv.test_isinstance(basestring_type),
                        conv.cleanup_text,
                    ),
                    typevar=conv.pipe(
                        conv.test_isinstance(basestring_type),
                        conv.input_to_int,
                        conv.test_equals(2),
                    ),
                ),
                constructor=collections.OrderedDict,
                drop_none_values='missing',
                keep_value_order=True,
            ),
        )(node, state=state or conv.default_state)
        if errors is not None:
            return validated_node, errors

        if not validated_node.get('NODE'):
            validated_node, errors = conv.struct(
                dict(code=conv.test_in(tax_benefit_system.variables), ),
                default=conv.noop,
            )(validated_node, state=state)
        return validated_node, errors
Пример #18
0
        def json_or_python_to_test_case(value, state=None):
            if value is None:
                return value, None
            if state is None:
                state = conv.default_state

            column_by_name = self.tax_benefit_system.column_by_name

            # First validation and conversion step
            test_case, error = conv.pipe(
                conv.test_isinstance(dict),
                conv.struct(
                    dict(
                        foyers_fiscaux=conv.pipe(
                            conv.make_item_to_singleton(),
                            conv.test_isinstance(list),
                            conv.uniform_sequence(
                                conv.test_isinstance(dict),
                                drop_none_items=True,
                            ),
                            conv.function(scenarios.set_entities_json_id),
                            conv.uniform_sequence(
                                conv.struct(
                                    dict(
                                        itertools.chain(
                                            dict(
                                                declarants=conv.pipe(
                                                    conv.
                                                    make_item_to_singleton(),
                                                    conv.test_isinstance(list),
                                                    conv.uniform_sequence(
                                                        conv.test_isinstance(
                                                            (basestring, int)),
                                                        drop_none_items=True,
                                                    ),
                                                    conv.default([]),
                                                ),
                                                id=conv.pipe(
                                                    conv.test_isinstance(
                                                        (basestring, int)),
                                                    conv.not_none,
                                                ),
                                                personnes_a_charge=conv.pipe(
                                                    conv.
                                                    make_item_to_singleton(),
                                                    conv.test_isinstance(list),
                                                    conv.uniform_sequence(
                                                        conv.test_isinstance(
                                                            (basestring, int)),
                                                        drop_none_items=True,
                                                    ),
                                                    conv.default([]),
                                                ),
                                            ).iteritems(),
                                            ((column.name,
                                              column.json_to_python) for column
                                             in column_by_name.itervalues()
                                             if column.entity == 'fam'),
                                        )),
                                    drop_none_values=True,
                                ),
                                drop_none_items=True,
                            ),
                            conv.default([]),
                        ),
                        individus=conv.pipe(
                            conv.make_item_to_singleton(),
                            conv.test_isinstance(list),
                            conv.uniform_sequence(
                                conv.test_isinstance(dict),
                                drop_none_items=True,
                            ),
                            conv.function(scenarios.set_entities_json_id),
                            conv.uniform_sequence(
                                conv.struct(
                                    dict(
                                        itertools.chain(
                                            dict(id=conv.pipe(
                                                conv.test_isinstance(
                                                    (basestring, int)),
                                                conv.not_none,
                                            ), ).iteritems(),
                                            ((column.name,
                                              column.json_to_python) for column
                                             in column_by_name.itervalues()
                                             if column.entity == 'ind'
                                             and column.name not in
                                             ('idfam', 'idfoy', 'idmen',
                                              'quifam', 'quifoy', 'quimen')),
                                        )),
                                    drop_none_values=True,
                                ),
                                drop_none_items=True,
                            ),
                            conv.empty_to_none,
                            conv.not_none,
                        ),
                        menages=conv.pipe(
                            conv.make_item_to_singleton(),
                            conv.test_isinstance(list),
                            conv.uniform_sequence(
                                conv.test_isinstance(dict),
                                drop_none_items=True,
                            ),
                            conv.function(scenarios.set_entities_json_id),
                            conv.uniform_sequence(
                                conv.struct(
                                    dict(
                                        itertools.chain(
                                            dict(
                                                autres=conv.pipe(
                                                    # personnes ayant un lien autre avec la personne de référence
                                                    conv.
                                                    make_item_to_singleton(),
                                                    conv.test_isinstance(list),
                                                    conv.uniform_sequence(
                                                        conv.test_isinstance(
                                                            (basestring, int)),
                                                        drop_none_items=True,
                                                    ),
                                                    conv.default([]),
                                                ),
                                                # conjoint de la personne de référence
                                                conjoint=conv.test_isinstance(
                                                    (basestring, int)),
                                                enfants=conv.pipe(
                                                    # enfants de la personne de référence ou de son conjoint
                                                    conv.
                                                    make_item_to_singleton(),
                                                    conv.test_isinstance(list),
                                                    conv.uniform_sequence(
                                                        conv.test_isinstance(
                                                            (basestring, int)),
                                                        drop_none_items=True,
                                                    ),
                                                    conv.default([]),
                                                ),
                                                id=conv.pipe(
                                                    conv.test_isinstance(
                                                        (basestring, int)),
                                                    conv.not_none,
                                                ),
                                                personne_de_reference=conv.
                                                test_isinstance(
                                                    (basestring, int)),
                                            ).iteritems(),
                                            ((column.name,
                                              column.json_to_python) for column
                                             in column_by_name.itervalues()
                                             if column.entity == 'men'),
                                        )),
                                    drop_none_values=True,
                                ),
                                drop_none_items=True,
                            ),
                            conv.default([]),
                        ),
                    ), ),
            )(value, state=state)
            if error is not None:
                return test_case, error

            # Second validation step
            foyers_fiscaux_individus_id = [
                individu['id'] for individu in test_case['individus']
            ]
            menages_individus_id = [
                individu['id'] for individu in test_case['individus']
            ]
            test_case, error = conv.struct(
                dict(
                    foyers_fiscaux=conv.uniform_sequence(
                        conv.struct(
                            dict(
                                declarants=conv.uniform_sequence(
                                    conv.test_in_pop(
                                        foyers_fiscaux_individus_id)),
                                personnes_a_charge=conv.uniform_sequence(
                                    conv.test_in_pop(
                                        foyers_fiscaux_individus_id)),
                            ),
                            default=conv.noop,
                        ), ),
                    menages=conv.uniform_sequence(
                        conv.struct(
                            dict(
                                autres=conv.uniform_sequence(
                                    conv.test_in_pop(menages_individus_id)),
                                conjoint=conv.test_in_pop(
                                    menages_individus_id),
                                enfants=conv.uniform_sequence(
                                    conv.test_in_pop(menages_individus_id)),
                                personne_de_reference=conv.test_in_pop(
                                    menages_individus_id),
                            ),
                            default=conv.noop,
                        ), ),
                ),
                default=conv.noop,
            )(test_case, state=state)

            individu_by_id = {
                individu['id']: individu
                for individu in test_case['individus']
            }

            if repair:
                # Affecte à un foyer fiscal chaque individu qui n'appartient à aucun d'entre eux.
                new_foyer_fiscal = dict(
                    declarants=[],
                    personnes_a_charge=[],
                )
                new_foyer_fiscal_id = None
                for individu_id in foyers_fiscaux_individus_id[:]:

                    # Tente d'affecter l'individu à un foyer fiscal d'après son ménage.
                    menage, menage_role = find_menage_and_role(
                        test_case, individu_id)
                    if menage_role == u'personne_de_reference':
                        conjoint_id = menage[u'conjoint']
                        if conjoint_id is not None:
                            foyer_fiscal, other_role = find_foyer_fiscal_and_role(
                                test_case, conjoint_id)
                            if other_role == u'declarants' and len(
                                    foyer_fiscal[u'declarants']) == 1:
                                # Quand l'individu n'est pas encore dans un foyer fiscal, mais qu'il est personne de
                                # référence dans un ménage, qu'il y a un conjoint dans ce ménage et que ce
                                # conjoint est seul déclarant dans un foyer fiscal, alors ajoute l'individu comme
                                # autre déclarant de ce foyer fiscal.
                                foyer_fiscal[u'declarants'].append(individu_id)
                                foyers_fiscaux_individus_id.remove(individu_id)
                    elif menage_role == u'conjoint':
                        personne_de_reference_id = menage[
                            u'personne_de_reference']
                        if personne_de_reference_id is not None:
                            foyer_fiscal, other_role = find_foyer_fiscal_and_role(
                                test_case, personne_de_reference_id)
                            if other_role == u'declarants' and len(
                                    foyer_fiscal[u'declarants']) == 1:
                                # Quand l'individu n'est pas encore dans un foyer fiscal, mais qu'il est conjoint
                                # dans un ménage, qu'il y a une personne de référence dans ce ménage et que
                                # cette personne est seul déclarant dans un foyer fiscal, alors ajoute l'individu
                                # comme autre déclarant de ce foyer fiscal.
                                foyer_fiscal[u'declarants'].append(individu_id)
                                foyers_fiscaux_individus_id.remove(individu_id)
                    elif menage_role == u'enfants' and (
                            menage['personne_de_reference'] is not None
                            or menage[u'conjoint'] is not None):
                        for other_id in (menage['personne_de_reference'],
                                         menage[u'conjoint']):
                            if other_id is None:
                                continue
                            foyer_fiscal, other_role = find_foyer_fiscal_and_role(
                                test_case, other_id)
                            if other_role == u'declarants':
                                # Quand l'individu n'est pas encore dans un foyer fiscal, mais qu'il est enfant dans
                                # un ménage, qu'il y a une personne à charge ou un conjoint dans ce ménage et que
                                # celui-ci est déclarant dans un foyer fiscal, alors ajoute l'individu comme
                                # personne à charge de ce foyer fiscal.
                                foyer_fiscal[u'personnes_a_charge'].append(
                                    individu_id)
                                foyers_fiscaux_individus_id.remove(individu_id)
                                break

                    if individu_id in foyers_fiscaux_individus_id:
                        # L'individu n'est toujours pas affecté à un foyer fiscal.
                        individu = individu_by_id[individu_id]
                        age = find_age(individu, period.start.date)
                        if len(new_foyer_fiscal[u'declarants']) < 2 and (
                                age is None or age >= 18):
                            new_foyer_fiscal[u'declarants'].append(individu_id)
                        else:
                            new_foyer_fiscal[u'personnes_a_charge'].append(
                                individu_id)
                        if new_foyer_fiscal_id is None:
                            new_foyer_fiscal[
                                u'id'] = new_foyer_fiscal_id = unicode(
                                    uuid.uuid4())
                            test_case[u'foyers_fiscaux'].append(
                                new_foyer_fiscal)
                        foyers_fiscaux_individus_id.remove(individu_id)

                # Affecte à un ménage chaque individu qui n'appartient à aucun d'entre eux.
                new_menage = dict(
                    autres=[],
                    conjoint=None,
                    enfants=[],
                    personne_de_reference=None,
                )
                new_menage_id = None
                for individu_id in menages_individus_id[:]:
                    # Tente d'affecter l'individu à un ménage d'après son foyer fiscal.
                    foyer_fiscal, foyer_fiscal_role = find_foyer_fiscal_and_role(
                        test_case, individu_id)
                    if foyer_fiscal_role == u'declarants' and len(
                            foyer_fiscal[u'declarants']) == 2:
                        for declarant_id in foyer_fiscal[u'declarants']:
                            if declarant_id != individu_id:
                                menage, other_role = find_menage_and_role(
                                    test_case, declarant_id)
                                if other_role == u'personne_de_reference' and menage[
                                        u'conjoint'] is None:
                                    # Quand l'individu n'est pas encore dans un ménage, mais qu'il est déclarant
                                    # dans un foyer fiscal, qu'il y a un autre déclarant dans ce foyer fiscal et que
                                    # cet autre déclarant est personne de référence dans un ménage et qu'il n'y a
                                    # pas de conjoint dans ce ménage, alors ajoute l'individu comme conjoint de ce
                                    # ménage.
                                    menage[u'conjoint'] = individu_id
                                    menages_individus_id.remove(individu_id)
                                elif other_role == u'conjoint' and menage[
                                        u'personne_de_reference'] is None:
                                    # Quand l'individu n'est pas encore dans un ménage, mais qu'il est déclarant
                                    # dans une foyer fiscal, qu'il y a un autre déclarant dans ce foyer fiscal et
                                    # que cet autre déclarant est conjoint dans un ménage et qu'il n'y a pas de
                                    # personne de référence dans ce ménage, alors ajoute l'individu comme personne
                                    # de référence de ce ménage.
                                    menage[
                                        u'personne_de_reference'] = individu_id
                                    menages_individus_id.remove(individu_id)
                                break
                    elif foyer_fiscal_role == u'personnes_a_charge' and foyer_fiscal[
                            u'declarants']:
                        for declarant_id in foyer_fiscal[u'declarants']:
                            menage, other_role = find_menage_and_role(
                                test_case, declarant_id)
                            if other_role in (u'personne_de_reference',
                                              u'conjoint'):
                                # Quand l'individu n'est pas encore dans un ménage, mais qu'il est personne à charge
                                # dans un foyer fiscal, qu'il y a un déclarant dans ce foyer fiscal et que ce
                                # déclarant est personne de référence ou conjoint dans un ménage, alors ajoute
                                # l'individu comme enfant de ce ménage.
                                menage[u'enfants'].append(individu_id)
                                menages_individus_id.remove(individu_id)
                                break

                    if individu_id in menages_individus_id:
                        # L'individu n'est toujours pas affecté à un ménage.
                        if new_menage[u'personne_de_reference'] is None:
                            new_menage[u'personne_de_reference'] = individu_id
                        elif new_menage[u'conjoint'] is None:
                            new_menage[u'conjoint'] = individu_id
                        else:
                            new_menage[u'enfants'].append(individu_id)
                        if new_menage_id is None:
                            new_menage[u'id'] = new_menage_id = unicode(
                                uuid.uuid4())
                            test_case[u'menages'].append(new_menage)
                        menages_individus_id.remove(individu_id)

            remaining_individus_id = set(foyers_fiscaux_individus_id).union(
                menages_individus_id)
            if remaining_individus_id:
                individu_index_by_id = {
                    individu[u'id']: individu_index
                    for individu_index, individu in enumerate(
                        test_case[u'individus'])
                }
                if error is None:
                    error = {}
                for individu_id in remaining_individus_id:
                    error.setdefault(
                        'individus',
                        {})[individu_index_by_id[individu_id]] = state._(
                            u"Individual is missing from {}").format(
                                state._(u' & ').join(word for word in [
                                    u'foyers_fiscaux' if individu_id in
                                    foyers_fiscaux_individus_id else None,
                                    u'menages' if individu_id in
                                    menages_individus_id else None,
                                ] if word is not None))
            if error is not None:
                return test_case, error

            # Third validation step
            individu_by_id = test_case['individus']
            test_case, error = conv.struct(
                dict(
                    foyers_fiscaux=conv.pipe(
                        conv.uniform_sequence(
                            conv.struct(
                                dict(
                                    declarants=conv.pipe(
                                        conv.empty_to_none,
                                        conv.not_none,
                                        conv.test(
                                            lambda declarants: len(declarants)
                                            <= 2,
                                            error=N_(
                                                u'A "foyer_fiscal" must have at most 2 "declarants"'
                                            ),
                                        ),
                                        # conv.uniform_sequence(conv.pipe(
                                        # conv.test(lambda individu_id:
                                        #     find_age(individu_by_id[individu_id], period.start.date,
                                        #         default = 100) >= 18,
                                        #     error = u"Un déclarant d'un foyer fiscal doit être agé d'au moins 18"
                                        #         u" ans",
                                        #     ),
                                        # conv.test(
                                        # lambda individu_id: individu_id in parents_id,
                                        # error = u"Un déclarant ou un conjoint sur la déclaration d'impôt, doit"
                                        # u" être un parent dans sa famille",
                                        # ),
                                        # )),
                                    ),
                                    personnes_a_charge=conv.uniform_sequence(
                                        conv.test(
                                            lambda individu_id: individu_by_id[
                                                individu_id].get('inv', False)
                                            or find_age(individu_by_id[
                                                individu_id],
                                                        period.start.date,
                                                        default=0) < 25,
                                            error=
                                            u"Une personne à charge d'un foyer fiscal doit avoir moins de"
                                            u" 25 ans ou être invalide",
                                        ), ),
                                ),
                                default=conv.noop,
                            ), ),
                        conv.empty_to_none,
                        conv.not_none,
                    ),
                    # individus = conv.uniform_sequence(
                    #     conv.struct(
                    #         dict(
                    #             date_naissance = conv.test(
                    #                 lambda date_naissance: period.start.date - date_naissance >= datetime.timedelta(0),
                    #                 error = u"L'individu doit être né au plus tard le jour de la simulation",
                    #                 ),
                    #             ),
                    #         default = conv.noop,
                    #         drop_none_values = 'missing',
                    #         ),
                    #     ),
                    menages=conv.pipe(
                        conv.uniform_sequence(
                            conv.struct(
                                dict(personne_de_reference=conv.not_none, ),
                                default=conv.noop,
                            ), ),
                        conv.empty_to_none,
                        conv.not_none,
                    ),
                ),
                default=conv.noop,
            )(test_case, state=state)

            return test_case, error
        def json_or_python_to_test_case(value, state=None):
            if value is None:
                return value, None
            if state is None:
                state = conv.default_state

            column_by_name = self.tax_benefit_system.column_by_name

            # First validation and conversion step
            test_case, error = conv.pipe(
                conv.test_isinstance(dict),
                conv.struct(
                    dict(
                        individus=conv.pipe(
                            conv.make_item_to_singleton(),
                            conv.test_isinstance(list),
                            conv.uniform_sequence(conv.test_isinstance(dict), drop_none_items=True),
                            conv.function(scenarios.set_entities_json_id),
                            conv.uniform_sequence(
                                conv.struct(
                                    dict(
                                        itertools.chain(
                                            dict(
                                                id=conv.pipe(conv.test_isinstance((basestring, int)), conv.not_none)
                                            ).iteritems(),
                                            (
                                                (column.name, column.json_to_python)
                                                for column in column_by_name.itervalues()
                                                if column.entity == "ind" and column.name not in ("idmen", "quimen")
                                            ),
                                        )
                                    ),
                                    drop_none_values=True,
                                ),
                                drop_none_items=True,
                            ),
                            conv.empty_to_none,
                            conv.not_none,
                        ),
                        menages=conv.pipe(
                            conv.make_item_to_singleton(),
                            conv.test_isinstance(list),
                            conv.uniform_sequence(conv.test_isinstance(dict), drop_none_items=True),
                            conv.function(scenarios.set_entities_json_id),
                            conv.uniform_sequence(
                                conv.struct(
                                    dict(
                                        itertools.chain(
                                            dict(
                                                autres=conv.pipe(
                                                    conv.test_isinstance(list),
                                                    conv.uniform_sequence(
                                                        conv.test_isinstance((basestring, int)), drop_none_items=True
                                                    ),
                                                    conv.default([]),
                                                ),
                                                conjoint=conv.pipe(
                                                    conv.test_isinstance(basestring, int), conv.default(None)
                                                ),
                                                enfants=conv.pipe(
                                                    conv.test_isinstance(list),
                                                    conv.uniform_sequence(
                                                        conv.test_isinstance((basestring, int)), drop_none_items=True
                                                    ),
                                                    conv.default([]),
                                                ),
                                                id=conv.pipe(conv.test_isinstance((basestring, int)), conv.not_none),
                                                personne_de_reference=conv.pipe(
                                                    conv.test_isinstance(basestring, int), conv.default(None)
                                                ),
                                            ).iteritems(),
                                            (
                                                (column.name, column.json_to_python)
                                                for column in column_by_name.itervalues()
                                                if column.entity == "men"
                                            ),
                                        )
                                    ),
                                    drop_none_values=True,
                                ),
                                drop_none_items=True,
                            ),
                            conv.default({}),
                        ),
                    )
                ),
            )(value, state=state)
            if error is not None:
                return test_case, error

            # Second validation step
            menages_individus_id = [individu["id"] for individu in test_case["individus"]]
            test_case, error = conv.struct(
                dict(
                    menages=conv.uniform_sequence(
                        conv.struct(
                            dict(
                                autres=conv.uniform_sequence(conv.test_in_pop(menages_individus_id)),
                                conjoint=conv.test_in_pop(menages_individus_id),
                                enfants=conv.uniform_sequence(conv.test_in_pop(menages_individus_id)),
                                personne_de_reference=conv.test_in_pop(menages_individus_id),
                            ),
                            default=conv.noop,
                        )
                    )
                ),
                default=conv.noop,
            )(test_case, state=state)

            remaining_individus_id = set(menages_individus_id)
            if remaining_individus_id:
                individu_index_by_id = {
                    individu[u"id"]: individu_index for individu_index, individu in enumerate(test_case[u"individus"])
                }
                if error is None:
                    error = {}
                for individu_id in remaining_individus_id:
                    error.setdefault("individus", {})[individu_index_by_id[individu_id]] = state._(
                        u"Individual is missing from {}"
                    ).format(
                        state._(u" & ").join(
                            word
                            for word in [u"menages" if individu_id in menages_individus_id else None]
                            if word is not None
                        )
                    )
            if error is not None:
                return test_case, error

            return test_case, error
Пример #20
0
def make_json_or_python_to_test(tax_benefit_system):
    validate = conv.struct(
        dict(
            itertools.chain(
                dict(
                    absolute_error_margin=conv.pipe(
                        conv.test_isinstance((float, int)),
                        conv.test_greater_or_equal(0),
                    ),
                    axes=make_json_or_python_to_axes(tax_benefit_system),
                    description=conv.pipe(
                        conv.test_isinstance(basestring_type),
                        conv.cleanup_line,
                    ),
                    input_variables=conv.pipe(
                        conv.test_isinstance(dict),
                        conv.uniform_mapping(
                            conv.pipe(
                                conv.test_isinstance(basestring_type),
                                conv.not_none,
                            ),
                            conv.noop,
                        ),
                        conv.empty_to_none,
                    ),
                    keywords=conv.pipe(
                        conv.make_item_to_singleton(),
                        conv.test_isinstance(list),
                        conv.uniform_sequence(
                            conv.pipe(
                                conv.test_isinstance(basestring_type),
                                conv.cleanup_line,
                            ),
                            drop_none_items=True,
                        ),
                        conv.empty_to_none,
                    ),
                    name=conv.pipe(
                        conv.test_isinstance(basestring_type),
                        conv.cleanup_line,
                    ),
                    output_variables=conv.test_isinstance(dict),
                    period=conv.pipe(
                        conv.function(periods.period),
                        conv.not_none,
                    ),
                    relative_error_margin=conv.pipe(
                        conv.test_isinstance((float, int)),
                        conv.test_greater_or_equal(0),
                    ),
                ).items(),
                ((entity.plural,
                  conv.pipe(
                      conv.make_item_to_singleton(),
                      conv.test_isinstance(list),
                  )) for entity in tax_benefit_system.entities),
            )), )

    def json_or_python_to_test(value, state=None):
        if value is None:
            return value, None
        if state is None:
            state = conv.default_state
        value, error = conv.pipe(
            conv.test_isinstance(dict),
            validate,
        )(value, state=state)
        if error is not None:
            return value, error

        value, error = conv.struct(
            dict(output_variables=make_json_or_python_to_input_variables(
                tax_benefit_system, value['period']), ),
            default=conv.noop,
        )(value, state=state)
        if error is not None:
            return value, error

        test_case = value.copy()
        absolute_error_margin = test_case.pop('absolute_error_margin')
        axes = test_case.pop('axes')
        description = test_case.pop('description')
        input_variables = test_case.pop('input_variables')
        keywords = test_case.pop('keywords')
        name = test_case.pop('name')
        output_variables = test_case.pop('output_variables')
        period = test_case.pop('period')
        relative_error_margin = test_case.pop('relative_error_margin')

        if test_case is not None and all(
                entity_members is None
                for entity_members in test_case.values()):
            test_case = None

        scenario, error = tax_benefit_system.Scenario.make_json_to_instance(
            repair=True, tax_benefit_system=tax_benefit_system)(dict(
                axes=axes,
                input_variables=input_variables,
                period=period,
                test_case=test_case,
            ),
                                                                state=state)
        if error is not None:
            return scenario, error

        return {
            key: value
            for key, value in dict(
                absolute_error_margin=absolute_error_margin,
                description=description,
                keywords=keywords,
                name=name,
                output_variables=output_variables,
                relative_error_margin=relative_error_margin,
                scenario=scenario,
            ).items() if value is not None
        }, None

    return json_or_python_to_test
def validate_value_json(value, state = None):
    if value is None:
        return None, None
    container = state.ancestors[-1]
    value_converter = dict(
        boolean = conv.condition(
            conv.test_isinstance(int),
            conv.test_in((0, 1)),
            conv.test_isinstance(bool),
            ),
        float = conv.condition(
            conv.test_isinstance(int),
            conv.anything_to_float,
            conv.test_isinstance(float),
            ),
        integer = conv.condition(
            conv.test_isinstance(float),
            conv.pipe(
                conv.test(lambda number: round(number) == number),
                conv.function(int),
                ),
            conv.test_isinstance(int),
            ),
        rate = conv.condition(
            conv.test_isinstance(int),
            conv.anything_to_float,
            conv.test_isinstance(float),
            ),
        )[container.get('format') or 'float']  # Only parameters have a "format".
    state = conv.add_ancestor_to_state(state, value)
    validated_value, errors = conv.pipe(
        conv.test_isinstance(dict),
        conv.struct(
            {
                u'comment': conv.pipe(
                    conv.test_isinstance(basestring),
                    conv.cleanup_text,
                    ),
                u'from': conv.pipe(
                    conv.test_isinstance(basestring),
                    conv.iso8601_input_to_date,
                    conv.date_to_iso8601_str,
                    conv.not_none,
                    ),
                u'to': conv.pipe(
                    conv.test_isinstance(basestring),
                    conv.iso8601_input_to_date,
                    conv.date_to_iso8601_str,
                    conv.not_none,
                    ),
                u'value': conv.pipe(
                    value_converter,
                    conv.not_none,
                    ),
                },
            constructor = collections.OrderedDict,
            drop_none_values = 'missing',
            keep_value_order = True,
            ),
        )(value, state = state)
    conv.remove_ancestor_from_state(state, value)
    return validated_value, errors
def validate_value_json(value, state=None):
    if value is None:
        return None, None
    container = state.ancestors[-1]
    value_converter = dict(
        boolean=conv.condition(
            conv.test_isinstance(int),
            conv.test_in((0, 1)),
            conv.test_isinstance(bool),
        ),
        float=conv.condition(
            conv.test_isinstance(int),
            conv.anything_to_float,
            conv.test_isinstance(float),
        ),
        integer=conv.condition(
            conv.test_isinstance(float),
            conv.pipe(
                conv.test(lambda number: round(number) == number),
                conv.function(int),
            ),
            conv.test_isinstance(int),
        ),
        rate=conv.condition(
            conv.test_isinstance(int),
            conv.anything_to_float,
            conv.test_isinstance(float),
        ),
    )[container.get('format') or 'float']  # Only parameters have a "format".
    state = conv.add_ancestor_to_state(state, value)
    validated_value, errors = conv.pipe(
        conv.test_isinstance(dict),
        conv.struct(
            {
                u'comment':
                conv.pipe(
                    conv.test_isinstance(basestring),
                    conv.cleanup_text,
                ),
                u'from':
                conv.pipe(
                    conv.test_isinstance(basestring),
                    conv.iso8601_input_to_date,
                    conv.date_to_iso8601_str,
                    conv.not_none,
                ),
                u'to':
                conv.pipe(
                    conv.test_isinstance(basestring),
                    conv.iso8601_input_to_date,
                    conv.date_to_iso8601_str,
                    conv.not_none,
                ),
                u'value':
                conv.pipe(
                    value_converter,
                    conv.not_none,
                ),
            },
            constructor=collections.OrderedDict,
            drop_none_values='missing',
            keep_value_order=True,
        ),
    )(value, state=state)
    conv.remove_ancestor_from_state(state, value)
    return validated_value, errors
Пример #23
0
def input_to_period_tuple(value, state=None):
    """Convert an input string to a period tuple.

    .. note:: This function doesn't return a period, but a tuple that allows to construct a period.

    >>> input_to_period_tuple('2014')
    (('year', 2014), None)
    >>> input_to_period_tuple('2014:2')
    (('year', 2014, 2), None)
    >>> input_to_period_tuple('2014-2')
    (('month', (2014, 2)), None)
    >>> input_to_period_tuple('2014-3:12')
    (('month', (2014, 3), 12), None)
    >>> input_to_period_tuple('2014-2-3')
    (('day', (2014, 2, 3)), None)
    >>> input_to_period_tuple('2014-3-4:2')
    (('day', (2014, 3, 4), 2), None)

    >>> input_to_period_tuple('year:2014')
    (('year', '2014'), None)
    >>> input_to_period_tuple('year:2014:2')
    (('year', '2014', '2'), None)
    >>> input_to_period_tuple('year:2014-2:2')
    (('year', '2014-2', '2'), None)
    """
    if value is None:
        return value, None
    if state is None:
        state = conv.default_state
    split_value = tuple(
        clean_fragment for clean_fragment in (fragment.strip()
                                              for fragment in value.split(':'))
        if clean_fragment)
    if not split_value:
        return None, None
    if len(split_value) == 1:
        split_value = tuple(
            clean_fragment
            for clean_fragment in (fragment.strip()
                                   for fragment in split_value[0].split('-'))
            if clean_fragment)
        if len(split_value) == 1:
            return conv.pipe(
                conv.input_to_strict_int,
                conv.test_greater_or_equal(0),
                conv.function(lambda year: ('year', year)),
            )(split_value[0], state=state)
        if len(split_value) == 2:
            return conv.pipe(
                conv.struct((
                    conv.pipe(
                        conv.input_to_strict_int,
                        conv.test_greater_or_equal(0),
                    ),
                    conv.pipe(
                        conv.input_to_strict_int,
                        conv.test_between(1, 12),
                    ),
                ), ),
                conv.function(lambda month_tuple: ('month', month_tuple)),
            )(split_value, state=state)
        if len(split_value) == 3:
            return conv.pipe(
                conv.struct((
                    conv.pipe(
                        conv.input_to_strict_int,
                        conv.test_greater_or_equal(0),
                    ),
                    conv.pipe(
                        conv.input_to_strict_int,
                        conv.test_between(1, 12),
                    ),
                    conv.pipe(
                        conv.input_to_strict_int,
                        conv.test_between(1, 31),
                    ),
                ), ),
                conv.function(lambda day_tuple: ('day', day_tuple)),
            )(split_value, state=state)
        return split_value, state._(
            'Instant string contains too much "-" for a year, a month or a day'
        )
    if len(split_value) == 2:
        split_start = tuple(
            clean_fragment
            for clean_fragment in (fragment.strip()
                                   for fragment in split_value[0].split('-'))
            if clean_fragment)
        size, error = conv.input_to_int(split_value[1], state=state)
        if error is None:
            if len(split_start) == 1:
                start, error = conv.pipe(
                    conv.input_to_strict_int,
                    conv.test_greater_or_equal(0),
                )(split_start[0], state=state)
                if error is None:
                    return ('year', start, size), None
            elif len(split_start) == 2:
                start, error = conv.struct((
                    conv.pipe(
                        conv.input_to_strict_int,
                        conv.test_greater_or_equal(0),
                    ),
                    conv.pipe(
                        conv.input_to_strict_int,
                        conv.test_between(1, 12),
                    ),
                ), )(split_start, state=state)
                if error is None:
                    return ('month', start, size), None
            elif len(split_start) == 3:
                start, error = conv.struct((
                    conv.pipe(
                        conv.input_to_strict_int,
                        conv.test_greater_or_equal(0),
                    ),
                    conv.pipe(
                        conv.input_to_strict_int,
                        conv.test_between(1, 12),
                    ),
                    conv.pipe(
                        conv.input_to_strict_int,
                        conv.test_between(1, 31),
                    ),
                ), )(split_start, state=state)
                if error is None:
                    return ('day', start, size), None
    return split_value, None
        def json_or_python_to_test_case(value, state=None):
            if value is None:
                return value, None
            if state is None:
                state = conv.default_state

            column_by_name = self.tax_benefit_system.column_by_name

            # First validation and conversion step
            test_case, error = conv.pipe(
                conv.test_isinstance(dict),
                conv.struct(
                    dict(
                        individus=conv.pipe(
                            conv.make_item_to_singleton(),
                            conv.test_isinstance(list),
                            conv.uniform_sequence(
                                conv.test_isinstance(dict),
                                drop_none_items=True,
                            ),
                            conv.function(scenarios.set_entities_json_id),
                            conv.uniform_sequence(
                                conv.struct(
                                    dict(
                                        itertools.chain(
                                            dict(id=conv.pipe(
                                                conv.test_isinstance(
                                                    (basestring, int)),
                                                conv.not_none,
                                            ), ).iteritems(),
                                            ((column.name,
                                              column.json_to_python) for column
                                             in column_by_name.itervalues()
                                             if column.entity == 'ind' and
                                             column.name not in ('idmen',
                                                                 'quimen')),
                                        )),
                                    drop_none_values=True,
                                ),
                                drop_none_items=True,
                            ),
                            conv.empty_to_none,
                            conv.not_none,
                        ),
                        menages=conv.pipe(
                            conv.make_item_to_singleton(),
                            conv.test_isinstance(list),
                            conv.uniform_sequence(
                                conv.test_isinstance(dict),
                                drop_none_items=True,
                            ),
                            conv.function(scenarios.set_entities_json_id),
                            conv.uniform_sequence(
                                conv.struct(
                                    dict(
                                        itertools.chain(
                                            dict(
                                                autres=conv.pipe(
                                                    conv.test_isinstance(list),
                                                    conv.uniform_sequence(
                                                        conv.test_isinstance(
                                                            (basestring, int)),
                                                        drop_none_items=True,
                                                    ),
                                                    conv.default([]),
                                                ),
                                                conjoint=conv.pipe(
                                                    conv.test_isinstance(
                                                        basestring, int),
                                                    conv.default(None),
                                                ),
                                                enfants=conv.pipe(
                                                    conv.test_isinstance(list),
                                                    conv.uniform_sequence(
                                                        conv.test_isinstance(
                                                            (basestring, int)),
                                                        drop_none_items=True,
                                                    ),
                                                    conv.default([]),
                                                ),
                                                id=conv.pipe(
                                                    conv.test_isinstance(
                                                        (basestring, int)),
                                                    conv.not_none,
                                                ),
                                                personne_de_reference=conv.
                                                pipe(
                                                    conv.test_isinstance(
                                                        basestring, int),
                                                    conv.default(None),
                                                ),
                                            ).iteritems(),
                                            ((column.name,
                                              column.json_to_python) for column
                                             in column_by_name.itervalues()
                                             if column.entity == 'men'),
                                        )),
                                    drop_none_values=True,
                                ),
                                drop_none_items=True,
                            ),
                            conv.default({}),
                        ),
                    ), ),
            )(value, state=state)
            if error is not None:
                return test_case, error

            # Second validation step
            menages_individus_id = [
                individu['id'] for individu in test_case['individus']
            ]
            test_case, error = conv.struct(
                dict(menages=conv.uniform_sequence(
                    conv.struct(
                        dict(
                            autres=conv.uniform_sequence(
                                conv.test_in_pop(menages_individus_id)),
                            conjoint=conv.test_in_pop(menages_individus_id),
                            enfants=conv.uniform_sequence(
                                conv.test_in_pop(menages_individus_id)),
                            personne_de_reference=conv.test_in_pop(
                                menages_individus_id),
                        ),
                        default=conv.noop,
                    ), ), ),
                default=conv.noop,
            )(test_case, state=state)

            remaining_individus_id = set(menages_individus_id)
            if remaining_individus_id:
                individu_index_by_id = {
                    individu[u'id']: individu_index
                    for individu_index, individu in enumerate(
                        test_case[u'individus'])
                }
                if error is None:
                    error = {}
                for individu_id in remaining_individus_id:
                    error.setdefault(
                        'individus',
                        {})[individu_index_by_id[individu_id]] = state._(
                            u"Individual is missing from {}").format(
                                state._(u' & ').join(word for word in [
                                    u'menages' if individu_id in
                                    menages_individus_id else None,
                                ] if word is not None))
            if error is not None:
                return test_case, error

            return test_case, error