예제 #1
0
def _validate_ui_config(obj_type, ui_config):
    """Validates the value of a UI configuration."""
    reference_dict = UI_CONFIG_SPECS[obj_type]
    assert set(ui_config.keys()) <= set(reference_dict.keys())
    for key, value in ui_config.iteritems():
        schema_utils.normalize_against_schema(
            value, reference_dict[key])
예제 #2
0
def _validate_ui_config(obj_type, ui_config):
    """Validates the value of a UI configuration."""
    reference_dict = UI_CONFIG_SPECS[obj_type]
    assert set(ui_config.keys()) <= set(reference_dict.keys())
    for key, value in ui_config.iteritems():
        schema_utils.normalize_against_schema(
            value, reference_dict[key])
예제 #3
0
 def test_normalize_against_schema_raises_exception(self):
     """Tests if normalize against schema raises exception
     for invalid key.
     """
     with self.assertRaises(Exception):
         schema = {SCHEMA_KEY_TYPE: 'invalid'}
         schema_utils.normalize_against_schema('obj', schema)
예제 #4
0
    def check_normalization(self, schema, mappings,
                            invalid_items_with_error_messages):
        """Validates the schema and tests that values are normalized correctly.

        Args:
            schema: dict. The schema to normalize the value
                against. Each schema is a dict with at least a key called
                'type'. The 'type' can take one of the SCHEMA_TYPE_* values
                declared above.
            mappings: list(tuple). A list of 2-element tuples.
                The first element of each item is expected to be normalized to
                the second.
            invalid_items_with_error_messages: list(tuple(str, str)). A list of
                values with their corresponding messages. Each value is expected
                to raise an AssertionError when normalized.
        """
        validate_schema(schema)

        for raw_value, expected_value in mappings:
            self.assertEqual(
                schema_utils.normalize_against_schema(raw_value, schema),
                expected_value)
        for value, error_msg in invalid_items_with_error_messages:
            with self.assertRaisesRegexp(Exception, error_msg):
                schema_utils.normalize_against_schema(value, schema)
예제 #5
0
 def validate_customization_arg_values(self, customization_args):
     """Validates customization arg values. The input is a dict whose
     keys are the names of the customization args.
     """
     for ca_spec in self.customization_arg_specs:
         schema_utils.normalize_against_schema(
             customization_args[ca_spec.name]['value'], ca_spec.schema)
예제 #6
0
    def validate(self):
        """Validates a visualization object.

        This is only used in tests for the validity of interactions.
        """
        # Check that the calculation id exists.
        calculation_registry.Registry.get_calculation_by_id(self.calculation_id)

        # Check that the options_dict is valid.
        expected_option_names = sorted([
            python_utils.convert_to_bytes(
                spec['name']) for spec in self._OPTIONS_SPECS])
        actual_option_names = sorted(self.options.keys())
        if actual_option_names != expected_option_names:
            raise utils.ValidationError(
                'For visualization %s, expected option names %s; received '
                'names %s' %
                (self.id, expected_option_names, actual_option_names))

        # Check that the schemas are correct.
        for spec in self._OPTIONS_SPECS:
            schema_utils.normalize_against_schema(
                self.options[spec['name']], spec['schema'])

        # Check that addressed_info_is_supported is valid.
        if not isinstance(self.addressed_info_is_supported, bool):
            raise utils.ValidationError(
                'For visualization %s, expected a bool value for '
                'addressed_info_is_supported; received %s' %
                (self.id, self.addressed_info_is_supported))
예제 #7
0
    def test_schema_key_post_normalizers(self):
        """Test post normalizers in schema using basic html schema."""
        schema_1 = {
            'type':
            schema_utils.SCHEMA_TYPE_HTML,
            'post_normalizers': [
                {
                    'id': 'normalize_spaces'
                },  # html strings with no extra spaces
            ]
        }
        obj_1 = 'a     a'
        normalize_obj_1 = schema_utils.normalize_against_schema(
            obj_1, schema_1)
        self.assertEqual(u'a a', normalize_obj_1)

        schema_2 = {
            'type': schema_utils.SCHEMA_TYPE_HTML,
            'post_normalizers': [{
                'id': 'sanitize_url'
            }]
        }
        obj_2 = 'http://www.oppia.org/splash/<script>'
        normalize_obj_2 = schema_utils.normalize_against_schema(
            obj_2, schema_2)
        self.assertEqual(u'http://www.oppia.org/splash/', normalize_obj_2)
예제 #8
0
 def test_normalize_against_schema_raises_exception(self):
     # type: () -> None
     """Tests if normalize against schema raises exception
     for invalid key.
     """
     with self.assertRaisesRegexp(Exception, 'Invalid schema type: invalid'): # type: ignore[no-untyped-call]
         schema = {SCHEMA_KEY_TYPE: 'invalid'}
         schema_utils.normalize_against_schema('obj', schema)
예제 #9
0
파일: base.py 프로젝트: maitbayev/oppia
 def validate_customization_arg_values(self, customization_args):
     """Validates customization arg values. The input is a dict whose
     keys are the names of the customization args.
     """
     for ca_spec in self.customization_arg_specs:
         schema_utils.normalize_against_schema(
             customization_args[ca_spec.name]['value'],
             ca_spec.schema)
예제 #10
0
 def test_global_validators_raise_exception_when_error_in_list(self):
     with self.assertRaisesRegexp(
         AssertionError,
         r'^Validation failed: does_not_contain_email .* [email protected]$'
     ):
         obj = {
             'unicodeListProp': ['*****@*****.**', 'not email 2'],
             'unicodeProp': 'not email'
         }
         schema_utils.normalize_against_schema(
             obj, self.GLOBAL_VALIDATORS_SCHEMA,
             global_validators=self.GLOBAL_VALIDATORS
         )
예제 #11
0
 def test_global_validators_raise_exception_when_error_in_dict(self):
     # type: () -> None
     with self.assertRaisesRegexp(  # type: ignore[no-untyped-call]
             AssertionError,
             r'^Validation failed: does_not_contain_email .* [email protected]$'
     ):
         obj = {
             'unicodeListProp': ['not email', 'not email 2'],
             'unicodeProp': '*****@*****.**'
         }
         schema_utils.normalize_against_schema(
             obj,
             self.GLOBAL_VALIDATORS_SCHEMA,
             global_validators=self.GLOBAL_VALIDATORS)
예제 #12
0
파일: objects.py 프로젝트: nachi11/oppia
    def normalize(cls, raw):
        """Validates and normalizes a raw Python object."""
        """
        Checks that there are no self-loops or multiple edges.
        Checks that unlabeled graphs have all labels empty.
        Checks that unweighted graphs have all weights set to 1.
        TODO(czx): Think about support for multigraphs?
        """

        try:
            raw = schema_utils.normalize_against_schema(raw, cls.SCHEMA)

            if not raw["isLabeled"]:
                for vertex in raw["vertices"]:
                    assert vertex["label"] == ""

            for edge in raw["edges"]:
                assert edge["src"] != edge["dst"]
                if not raw["isWeighted"]:
                    assert edge["weight"] == 1.0

            if raw["isDirected"]:
                edge_pairs = [(edge["src"], edge["dst"]) for edge in raw["edges"]]
            else:
                edge_pairs = [(edge["src"], edge["dst"]) for edge in raw["edges"]] + [
                    (edge["dst"], edge["src"]) for edge in raw["edges"]
                ]
            assert len(set(edge_pairs)) == len(edge_pairs)

        except Exception:
            raise TypeError("Cannot convert to graph %s" % raw)

        return raw
예제 #13
0
    def _validate_customization_arg_specs(self, customization_args):
        """Validates the customization arg specs for the interaction.

        Args:
            customization_args: list(dict(str, *)). The customization args for
                the interaction.
        """
        for ca_spec in customization_args:
            self.assertEqual(set(ca_spec.keys()), set([
                'name', 'description', 'schema', 'default_value']))

            self.assertTrue(
                isinstance(ca_spec['name'], python_utils.BASESTRING))
            self.assertTrue(self._is_alphanumeric_string(ca_spec['name']))
            self.assertTrue(
                isinstance(ca_spec['description'], python_utils.BASESTRING))
            self.assertGreater(len(ca_spec['description']), 0)

            schema_utils_test.validate_schema(ca_spec['schema'])
            self.assertEqual(
                ca_spec['default_value'],
                schema_utils.normalize_against_schema(
                    ca_spec['default_value'], ca_spec['schema']))

            if ca_spec['schema']['type'] == 'custom':
                obj_class = obj_services.Registry.get_object_class_by_type(
                    ca_spec['schema']['obj_type'])
                self.assertEqual(
                    ca_spec['default_value'],
                    obj_class.normalize(ca_spec['default_value']))
예제 #14
0
    def normalize(cls, raw):
        """Validates and normalizes a raw Python object."""
        """
        Checks that there are no self-loops or multiple edges.
        Checks that unlabeled graphs have all labels empty.
        Checks that unweighted graphs have all weights set to 1.
        TODO(czx): Think about support for multigraphs?
        """

        try:
            raw = schema_utils.normalize_against_schema(raw, cls.SCHEMA)

            if not raw['isLabeled']:
                for vertex in raw['vertices']:
                    assert (vertex['label'] == '')

            for edge in raw['edges']:
                assert (edge['src'] != edge['dst'])
                if not raw['isWeighted']:
                    assert (edge['weight'] == 1.0)

            if raw['isDirected']:
                edge_pairs = [
                    (edge['src'], edge['dst']) for edge in raw['edges']]
            else:
                edge_pairs = (
                    [(edge['src'], edge['dst']) for edge in raw['edges']] +
                    [(edge['dst'], edge['src']) for edge in raw['edges']]
                )
            assert len(set(edge_pairs)) == len(edge_pairs)

        except Exception:
            raise TypeError('Cannot convert to graph %s' % raw)

        return raw
예제 #15
0
    def _validate_customization_arg_specs(self, customization_args):
        """Validates the customization arg specs for the interaction.

        Args:
            customization_args: list(CustomizationArgSpec). The customization
                args for the interaction.
        """
        for ca_spec in customization_args:
            self.assertTrue(
                all(
                    hasattr(ca_spec, attr) for attr in
                    ['name', 'description', 'schema', 'default_value']))

            self.assertTrue(isinstance(ca_spec.name, python_utils.BASESTRING))
            self.assertTrue(self._is_alphanumeric_string(ca_spec.name))
            self.assertTrue(
                isinstance(ca_spec.description, python_utils.BASESTRING))
            self.assertGreater(len(ca_spec.description), 0)

            schema_utils_test.validate_schema(ca_spec.schema)
            self.assertEqual(
                ca_spec.default_value,
                schema_utils.normalize_against_schema(ca_spec.default_value,
                                                      ca_spec.schema))

            if ca_spec.schema['type'] == 'custom':
                obj_class = object_registry.Registry.get_object_class_by_type(
                    ca_spec.schema['obj_type'])
                self.assertEqual(ca_spec.default_value,
                                 obj_class.normalize(ca_spec.default_value))
예제 #16
0
    def _validate_customization_arg_specs(self, customization_arg_specs):
        for ca_spec in customization_arg_specs:
            self.assertEqual(set(ca_spec.keys()), set([
                'name', 'description', 'schema', 'default_value']))

            self.assertTrue(isinstance(ca_spec['name'], basestring))
            self.assertTrue(self._is_alphanumeric_string(ca_spec['name']))
            self.assertTrue(isinstance(ca_spec['description'], basestring))
            self.assertGreater(len(ca_spec['description']), 0)

            # The default value might not pass validation checks (e.g. the
            # Image component has a required field whose default value is
            # empty). Thus, when checking the default value schema, we don't
            # apply the custom validators.
            schema_utils_test.validate_schema(ca_spec['schema'])
            self.assertEqual(
                ca_spec['default_value'],
                schema_utils.normalize_against_schema(
                    ca_spec['default_value'], ca_spec['schema'],
                    apply_custom_validators=False))

            if ca_spec['schema']['type'] == 'custom':
                obj_class = obj_services.Registry.get_object_class_by_type(
                    ca_spec['schema']['obj_type'])
                self.assertIsNotNone(obj_class.edit_html_filename)
                self.assertIsNotNone(obj_class.edit_js_filename)
                self.assertEqual(
                    ca_spec['default_value'],
                    obj_class.normalize(ca_spec['default_value']))
예제 #17
0
    def normalize(cls, raw):
        # Moves cur_value to the nearest available value in the range
        # [min_value, max_value].
        """Returns the normalized coordinates of the rectangle.

        Args:
            raw: *. An object to be validated against the schema, normalizing if
                necessary.

        Returns:
            list(list(float)). The normalized object containing list of lists of
                float values as coordinates of the rectangle.

        Raises:
            TypeError: Cannot convert to the NormalizedRectangle2D schema.
        """
        def clamp(min_value, current_value, max_value):
            return min(max_value, max(min_value, current_value))

        try:
            raw = schema_utils.normalize_against_schema(raw, cls.SCHEMA)

            raw[0][0] = clamp(0.0, raw[0][0], 1.0)
            raw[0][1] = clamp(0.0, raw[0][1], 1.0)
            raw[1][0] = clamp(0.0, raw[1][0], 1.0)
            raw[1][1] = clamp(0.0, raw[1][1], 1.0)

        except Exception:
            raise TypeError('Cannot convert to Normalized Rectangle %s' % raw)

        return raw
예제 #18
0
    def _validate_customization_arg_specs(self, customization_arg_specs):
        for ca_spec in customization_arg_specs:
            self.assertEqual(
                set(ca_spec.keys()),
                set(['name', 'description', 'schema', 'default_value']))

            self.assertTrue(isinstance(ca_spec['name'], basestring))
            self.assertTrue(self._is_alphanumeric_string(ca_spec['name']))
            self.assertTrue(isinstance(ca_spec['description'], basestring))
            self.assertGreater(len(ca_spec['description']), 0)

            # The default value might not pass validation checks (e.g. the
            # Image component has a required field whose default value is
            # empty). Thus, when checking the default value schema, we don't
            # apply the custom validators.
            schema_utils_test.validate_schema(ca_spec['schema'])
            self.assertEqual(
                ca_spec['default_value'],
                schema_utils.normalize_against_schema(
                    ca_spec['default_value'],
                    ca_spec['schema'],
                    apply_custom_validators=False))

            if ca_spec['schema']['type'] == 'custom':
                obj_class = obj_services.Registry.get_object_class_by_type(
                    ca_spec['schema']['obj_type'])
                self.assertEqual(ca_spec['default_value'],
                                 obj_class.normalize(ca_spec['default_value']))
예제 #19
0
def _validate_validator(obj_type, validator):
    # type: (Text, Dict[Text, Any]) -> None
    """Validates the value of a 'validator' field.

    Args:
        obj_type: str. The type of the object.
        validator: dict. The Specs that needs to be validated.

    Raises:
        AssertionError. The object fails to validate against the schema.
    """
    reference_dict = VALIDATOR_SPECS[obj_type]
    assert 'id' in validator, 'id is not present in validator'
    assert validator['id'] in reference_dict, (
        '%s is not present in reference_dict' % validator['id'])

    customization_keys = list(validator.keys())
    customization_keys.remove('id')
    assert (
        set(customization_keys) ==
        set(reference_dict[validator['id']].keys())), (
            'Missing keys: %s, Extra keys: %s' % (
                list(
                    set(reference_dict[validator['id']].keys()) -
                    set(customization_keys)),
                list(
                    set(customization_keys) -
                    set(reference_dict[validator['id']].keys()))))
    for key in customization_keys:
        value = validator[key]
        schema = reference_dict[validator['id']][key]
        try:
            schema_utils.normalize_against_schema(value, schema)
        except Exception as e:
            raise AssertionError(e)

    # Check that the id corresponds to a valid normalizer function.
    validator_fn = schema_utils.get_validator(validator['id'])
    assert set(inspect.getargspec(validator_fn).args) == set(
        customization_keys + ['obj']), (
            'Missing keys: %s, Extra keys: %s' % (
                list(
                    set(customization_keys + ['obj']) -
                    set(inspect.getargspec(validator_fn).args)),
                list(
                    set(inspect.getargspec(validator_fn).args) -
                    set(customization_keys + ['obj']))))
예제 #20
0
def validate(
    handler_args: Any,
    handler_args_schemas: Any,
    allowed_extra_args: bool,
    allow_string_to_bool_conversion: bool = False
) -> Tuple[Dict[str, Any], List[str]]:
    """Calls schema utils for normalization of object against its schema
    and collects all the errors.

    Args:
        handler_args: *. Object for normalization.
        handler_args_schemas: dict. Schema for args.
        allowed_extra_args: bool. Whether extra args are allowed in handler.
        allow_string_to_bool_conversion: bool. Whether to allow string to
            boolean coversion.

    Returns:
        *. A two tuple, where the first element represents the normalized value
        in dict format and the second element represents the lists of errors
        after validation.
    """
    # Collect all errors and present them at once.
    errors = []
    normalized_value = {}
    for arg_key, arg_schema in handler_args_schemas.items():

        if arg_key not in handler_args or handler_args[arg_key] is None:
            if ('default_value' in arg_schema
                    and arg_schema['default_value'] is None):
                # Skip validation for optional cases.
                continue
            elif ('default_value' in arg_schema
                  and arg_schema['default_value'] is not None):
                handler_args[arg_key] = arg_schema['default_value']
            elif 'default_value' not in arg_schema:
                errors.append('Missing key in handler args: %s.' % arg_key)
                continue

        # Below normalization is for arguments which are expected to be boolean
        # but from API request they are received as string type.
        if (allow_string_to_bool_conversion and arg_schema['schema']['type']
                == schema_utils.SCHEMA_TYPE_BOOL and isinstance(
                    handler_args[arg_key], python_utils.BASESTRING)):
            handler_args[arg_key] = (convert_string_to_bool(
                handler_args[arg_key]))

        try:
            normalized_value[arg_key] = schema_utils.normalize_against_schema(
                handler_args[arg_key], arg_schema['schema'])
        except Exception as e:
            errors.append('Schema validation for \'%s\' failed: %s' %
                          (arg_key, e))

    extra_args = set(handler_args.keys()) - set(handler_args_schemas.keys())

    if not allowed_extra_args and extra_args:
        errors.append('Found extra args: %s.' % (list(extra_args)))

    return normalized_value, errors
예제 #21
0
def _validate_ui_config(obj_type, ui_config):
    """Validates the value of a UI configuration.

        Args:
            obj_type: str. UI config spec type.
            ui_config: dict. The UI config that needs to be validated.

        Raises:
            AssertionError. The object fails to validate against the schema.
    """
    reference_dict = UI_CONFIG_SPECS[obj_type]
    assert set(ui_config.keys()) <= set(reference_dict.keys()), (
        'Missing keys: %s, Extra keys: %s' % (
            list(set(reference_dict.keys()) - set(ui_config.keys())),
            list(set(ui_config.keys()) - set(reference_dict.keys()))))
    for key, value in ui_config.items():
        schema_utils.normalize_against_schema(
            value, reference_dict[key])
예제 #22
0
    def check_normalization(self, schema, mappings, invalid_items):
        """Validates the schema and tests that values are normalized correctly.

        Args:
          schema: the schema to normalize the value against.
          mappings: a list of 2-element tuples. The first element of
            each item is expected to be normalized to the second.
          invalid_items: a list of values. Each of these is expected to raise
            an AssertionError when normalized.
        """
        validate_schema(schema)

        for raw_value, expected_value in mappings:
            self.assertEqual(
                schema_utils.normalize_against_schema(raw_value, schema),
                expected_value)
        for value in invalid_items:
            with self.assertRaises(Exception):
                schema_utils.normalize_against_schema(value, schema)
예제 #23
0
 def test_global_validators_pass_when_no_error(self):
     obj = {
         'unicodeListProp': ['not email', 'not email 2'],
         'unicodeProp': 'not email'
     }
     normalized_obj = schema_utils.normalize_against_schema(
         obj, self.GLOBAL_VALIDATORS_SCHEMA,
         global_validators=self.GLOBAL_VALIDATORS
     )
     self.assertEqual(obj, normalized_obj)
예제 #24
0
    def check_normalization(self, schema, mappings, invalid_items):
        """Validates the schema and tests that values are normalized correctly.

        Args:
          schema: the schema to normalize the value against.
          mappings: a list of 2-element tuples. The first element of
            each item is expected to be normalized to the second.
          invalid_items: a list of values. Each of these is expected to raise
            an AssertionError when normalized.
        """
        validate_schema(schema)

        for raw_value, expected_value in mappings:
            self.assertEqual(
                schema_utils.normalize_against_schema(raw_value, schema),
                expected_value)
        for value in invalid_items:
            with self.assertRaises(Exception):
                schema_utils.normalize_against_schema(value, schema)
예제 #25
0
    def normalize(cls, raw):
        """Validates and normalizes a raw Python object.

        Returns:
          a normalized Python object describing the Object specified by this
          class.

        Raises:
          TypeError: if the Python object cannot be normalized.
        """
        return schema_utils.normalize_against_schema(raw, cls.SCHEMA)
예제 #26
0
    def normalize(self, value):
        """Validates the given object using the schema and normalizes if
        necessary.

        Args:
            value: The value of the configuration property.

        Returns:
            instance. The normalized object.
        """
        return schema_utils.normalize_against_schema(value, self._schema)
예제 #27
0
    def __init__(self, name, schema, description, default_value):
        if Registry.get_config_property(name):
            raise Exception('Property with name %s already exists' % name)

        self._name = name
        self._schema = schema
        self._description = description
        self._default_value = schema_utils.normalize_against_schema(
            default_value, self._schema)

        Registry.init_config_property(self.name, self)
예제 #28
0
    def __init__(self, name, schema, description, default_value):
        if Registry.get_config_property(name):
            raise Exception('Property with name %s already exists' % name)

        self._name = name
        self._schema = schema
        self._description = description
        self._default_value = schema_utils.normalize_against_schema(
            default_value, self._schema)

        Registry.init_config_property(self.name, self)
예제 #29
0
    def __init__(self, name, schema, description, default_value):
        if name in Registry._config_registry:
            raise Exception('Property with name %s already exists' % name)

        self._name = name
        # TODO(sll): Validate the schema.
        self._schema = schema
        self._description = description
        self._default_value = schema_utils.normalize_against_schema(
            default_value, self._schema)

        Registry._config_registry[self.name] = self
예제 #30
0
def _validate_validator(obj_type, validator):
    """Validates the value of a 'validator' field."""
    reference_dict = VALIDATOR_SPECS[obj_type]
    assert 'id' in validator and validator['id'] in reference_dict

    customization_keys = validator.keys()
    customization_keys.remove('id')
    assert (set(customization_keys) ==
            set(reference_dict[validator['id']].keys()))
    for key in customization_keys:
        value = validator[key]
        schema = reference_dict[validator['id']][key]
        try:
            schema_utils.normalize_against_schema(value, schema)
        except Exception as e:
            raise AssertionError(e)

    # Check that the id corresponds to a valid normalizer function.
    validator_fn = schema_utils._Validators.get(validator['id'])
    assert set(inspect.getargspec(validator_fn).args) == set(
        customization_keys + ['obj'])
예제 #31
0
def _validate_validator(obj_type, validator):
    """Validates the value of a 'validator' field."""
    reference_dict = VALIDATOR_SPECS[obj_type]
    assert 'id' in validator and validator['id'] in reference_dict

    customization_keys = validator.keys()
    customization_keys.remove('id')
    assert (set(customization_keys) ==
            set(reference_dict[validator['id']].keys()))
    for key in customization_keys:
        value = validator[key]
        schema = reference_dict[validator['id']][key]
        try:
            schema_utils.normalize_against_schema(value, schema)
        except Exception as e:
            raise AssertionError(e)

    # Check that the id corresponds to a valid normalizer function.
    validator_fn = schema_utils._Validators.get(validator['id'])
    assert set(inspect.getargspec(validator_fn).args) == set(
        customization_keys + ['obj'])
예제 #32
0
파일: models.py 프로젝트: DSeanLaw/oppia
    def validate(self):
        """Validates a visualization object.

        This is only used in tests for the validity of interactions.
        """
        # Check that the calculation id exists.
        calculation_registry.Registry.get_calculation_by_id(self.calculation_id)

        # Check that the options_dict is valid.
        expected_option_names = sorted([
            spec['name'] for spec in self._OPTIONS_SPECS])
        actual_option_names = sorted(self.options.keys())
        if actual_option_names != expected_option_names:
            raise utils.ValidationError(
                'For visualization %s, expected option names %s; received '
                'names %s' %
                (self.id, expected_option_names, actual_option_names))

        # Check that the schemas are correct.
        for spec in self._OPTIONS_SPECS:
            schema_utils.normalize_against_schema(
                self.options[spec['name']], spec['schema'])
예제 #33
0
    def normalize(self, value):
        """Validates the given object using the schema and normalizes if
        necessary.

        Args:
            value: str. The value of the configuration property.

        Returns:
            instance. The normalized object.
        """
        email_validators = [{'id': 'does_not_contain_email'}]
        return schema_utils.normalize_against_schema(
            value, self._schema, global_validators=email_validators)
예제 #34
0
    def normalize(cls, raw):
        """Validates and normalizes a raw Python object.

        Args:
            raw: *. A normalized Python object to be normalized.

        Returns:
            *. A normalized Python object describing the Object specified by
            this class.

        Raises:
            TypeError. The Python object cannot be normalized.
        """
        return schema_utils.normalize_against_schema(raw, cls.get_schema())
예제 #35
0
    def validate(self):
        """Validates a visualization object.

        This is only used in tests for the validity of interactions.
        """
        # Check that the calculation id exists.
        calculation_registry.Registry.get_calculation_by_id(
            self.calculation_id)

        # Check that the options_dict is valid.
        expected_option_names = sorted(
            [spec['name'] for spec in self._OPTIONS_SPECS])
        actual_option_names = sorted(self.options.keys())
        if actual_option_names != expected_option_names:
            raise utils.ValidationError(
                'For visualization %s, expected option names %s; received '
                'names %s' %
                (self.id, expected_option_names, actual_option_names))

        # Check that the schemas are correct.
        for spec in self._OPTIONS_SPECS:
            schema_utils.normalize_against_schema(self.options[spec['name']],
                                                  spec['schema'])
예제 #36
0
    def __init__(self, name, schema, description, default_value,
                 post_set_hook=None, is_directly_settable=True):
        if Registry.get_config_property(name):
            raise Exception('Property with name %s already exists' % name)

        self._name = name
        self._schema = schema
        self._description = description
        self._default_value = schema_utils.normalize_against_schema(
            default_value, self._schema)
        self._post_set_hook = post_set_hook
        self._is_directly_settable = is_directly_settable

        Registry.init_config_property(self.name, self)
예제 #37
0
    def normalize(cls, raw):
        """Validates and normalizes a raw Python object.

        Args:
            raw: *. A Python object to be validated against the schema,
                normalizing if necessary.

        Returns:
            bool. The normalized object (or False if the input is None or '').
        """
        if raw is None or raw == '':
            raw = False

        return schema_utils.normalize_against_schema(raw, cls.SCHEMA)
예제 #38
0
    def normalize(cls, raw):
        """Validates and normalizes a raw Python object.

        Args:
            raw: *. A Python object to be validated against the schema,
                normalizing if necessary.

        Returns:
            unicode. The normalized object containing string in unicode format.
        """
        if '\t' in raw:
            raise TypeError('Unexpected tab characters in code string: %s' %
                            raw)
        return schema_utils.normalize_against_schema(raw, cls.SCHEMA)
예제 #39
0
    def normalize(cls, raw):
        # Moves cur_value to the nearest available value in the range [min_value, max_value]
        def clamp(min_value, current_value, max_value):
            return min(max_value, max(min_value, current_value))
        try:
            raw = schema_utils.normalize_against_schema(raw, cls.SCHEMA)
            
            raw[0][0] = clamp(0.0, raw[0][0], 1.0)
            raw[0][1] = clamp(0.0, raw[0][1], 1.0)
            raw[1][0] = clamp(0.0, raw[1][0], 1.0)
            raw[1][1] = clamp(0.0, raw[1][1], 1.0)

        except Exception:
            raise TypeError('Cannot convert to Normalized Rectangle %s' % raw)

        return raw
예제 #40
0
    def _validate_customization_arg_specs(self, customization_args):
        for ca_spec in customization_args:
            self.assertEqual(set(ca_spec.keys()), set([
                'name', 'description', 'schema', 'default_value']))

            self.assertTrue(isinstance(ca_spec['name'], basestring))
            self.assertTrue(self._is_alphanumeric_string(ca_spec['name']))
            self.assertTrue(isinstance(ca_spec['description'], basestring))
            self.assertGreater(len(ca_spec['description']), 0)

            schema_utils_test.validate_schema(ca_spec['schema'])
            self.assertEqual(
                ca_spec['default_value'],
                schema_utils.normalize_against_schema(
                    ca_spec['default_value'], ca_spec['schema']))

            if ca_spec['schema']['type'] == 'custom':
                obj_class = obj_services.Registry.get_object_class_by_type(
                    ca_spec['schema']['obj_type'])
                self.assertIsNotNone(obj_class.edit_html_filename)
                self.assertIsNotNone(obj_class.edit_js_filename)
                self.assertEqual(
                    ca_spec['default_value'],
                    obj_class.normalize(ca_spec['default_value']))
예제 #41
0
파일: objects.py 프로젝트: miyucy/oppia
 def normalize(cls, raw):
     """Reads `raw` as a unicode string representing a tar file and returns
     the base64-encoded contents."""
     raw = schema_utils.normalize_against_schema(raw, cls._schema)
     raw = base64.b64decode(raw)
     return tarfile.open(fileobj=StringIO.StringIO(raw), mode='r:gz')
예제 #42
0
 def normalize(self, value):
     return schema_utils.normalize_against_schema(value, self._schema)
예제 #43
0
파일: objects.py 프로젝트: maitbayev/oppia
 def normalize(cls, raw):
     if '\t' in raw:
         raise TypeError(
             'Unexpected tab characters in code string: %s' % raw)
     return schema_utils.normalize_against_schema(raw, cls.SCHEMA)
예제 #44
0
파일: objects.py 프로젝트: maitbayev/oppia
    def normalize(cls, raw):
        """Validates and normalizes a raw Python object."""
        if raw is None or raw == '':
            raw = False

        return schema_utils.normalize_against_schema(raw, cls.SCHEMA)