Using the fastest string formatting method everywhere possible (except in help messages templates of validation exceptions)

Author: Sylvain MARIE

valid8/base.py

@@ -576,11 +576,11 @@ def raiser(x, **ctx):
     # they will appear anyway !
     # ---
     # if help_msg or failure_type:
-    #     raiser.__name__ = 'failure_raiser({}, {})'.format(get_callable_name(validation_callable),
-    #                                                       help_msg or failure_type.__name__)
+    #     raiser.__name__ = 'failure_raiser(%s, %s)' % (get_callable_name(validation_callable),
+    #                                                   help_msg or failure_type.__name__)
     # else:
     # ---
-    # raiser.__name__ = 'failure_raiser({})'.format(get_callable_name(validation_callable))
+    # raiser.__name__ = 'failure_raiser(%s)' % get_callable_name(validation_callable)
     raiser.__name__ = get_callable_name(validation_callable)
     # Note: obviously this can hold as long as we do not check the name of this object in any other context than
     # raising errors. If we want to support this, then creating a callable object with everything in the fields will be
@@ -657,7 +657,7 @@ def accept_none(x, **ctx):
         #     value is None: skip validation
 
     # set a name so that the error messages are more user-friendly
-    accept_none.__name__ = 'skip_on_none({})'.format(get_callable_name(validation_callable))
+    accept_none.__name__ = 'skip_on_none(%s)' % get_callable_name(validation_callable)
 
     return accept_none
 
@@ -689,7 +689,7 @@ def reject_none(x, **ctx):
             raise ValueIsNone(wrong_value=x)
 
     # set a name so that the error messages are more user-friendly ==> NO ! here we want to see the checker
-    reject_none.__name__ = 'reject_none({})'.format(get_callable_name(validation_callable))
+    reject_none.__name__ = 'reject_none(%s)' % get_callable_name(validation_callable)
 
     return reject_none
 

valid8/composition.py

@@ -175,7 +175,7 @@ def and_v_(x, **ctx):
 
             return True
 
-        and_v_.__name__ = 'and({})'.format(get_callable_names(validation_funcs))
+        and_v_.__name__ = 'and(%s)' % get_callable_names(validation_funcs)
         return and_v_
 
 
@@ -225,7 +225,7 @@ def not_v_(x, **ctx):
         # if we're here that's a failure
         raise DidNotFail(validation_func=validation_func, wrong_value=x, validation_outcome=res)
 
-    not_v_.__name__ = 'not({})'.format(get_callable_name(validation_func))
+    not_v_.__name__ = 'not(%s)' % get_callable_name(validation_func)
     return not_v_
 
 
@@ -275,7 +275,7 @@ def or_v_(x, **ctx):
             # no validator accepted: gather details and raise
             raise AllValidatorsFailed(validation_func, x, ctx)
 
-        or_v_.__name__ = 'or({})'.format(get_callable_names(validation_func))
+        or_v_.__name__ = 'or(%s)' % get_callable_names(validation_func)
         return or_v_
 
 
@@ -334,7 +334,7 @@ def xor_v_(x, **ctx):
                 # no validation function happy, fail
                 raise AllValidatorsFailed(validation_func, x, ctx)
 
-        xor_v_.__name__ = 'xor({})'.format(get_callable_names(validation_func))
+        xor_v_.__name__ = 'xor(%s)' % get_callable_names(validation_func)
         return xor_v_
 
 

valid8/entry_points.py

@@ -472,8 +472,8 @@ def __init__(self,
         quite different from the standard python truth value test (where None is equivalent to False), but it seems more
         adapted to an intuitive usage, where a function that returns silently without any output means 'no problem
         there, move one'. Users defining their own base validation functions may wish to raise instances or subclasses
-        of `ValidationFailure` to provide more user-friendly details and unique failure identifiers. Raw mini_lambda expressions
-        are supported and are automatically transformed to functions.
+        of `ValidationFailure` to provide more user-friendly details and unique failure identifiers. Raw mini_lambda
+        expressions are supported and are automatically transformed to functions.
 
         For example:
 
@@ -500,10 +500,12 @@ def my_validator(x):
         ```
 
         Users may perform composition on base validation functions used in a `Validator`:
+
         - either explicitly using the various operators provided in valid8.composition (`and_`, `or_`, `xor_`,
-        `failure_raiser()`, `skip_on_none()`, `fail_on_none()`...)
+          `failure_raiser()`, `skip_on_none()`, `fail_on_none()`...)
+
         - or implicitly using the syntax defined in `ValidationFuncs`: i.e. a list means an implicit `and_()` and a
-        tuple means an implicit `failure_raiser()`
+          tuple means an implicit `failure_raiser()`
 
         It is possible to provide values for `help_msg` and `error_type` in the constructor so as to reuse them in any
         subsequent call to `assert_valid`. See `assert_valid` for details about those fields
@@ -534,8 +536,8 @@ def my_validator(x):
         kw_context_args = kwargs
 
         if help_msg is None and error_type is None and len(kw_context_args) > 0:
-            raise ValueError("Keyword context arguments have been provided but help_msg and error_type have not: {}"
-                             "".format(kw_context_args))
+            raise ValueError("Keyword context arguments have been provided but `help_msg` and `error_type` have not: %s"
+                             % kw_context_args)
 
         self.none_policy = none_policy if none_policy is not None else NonePolicy.VALIDATE
 
@@ -572,14 +574,17 @@ def __repr__(self):
         # type: (...) -> str
         """ Overrides the default string representation for Validator instances """
 
-        info = self.get_additional_info_for_repr()
-        return "{validator_type}<{additional_info}validation_function={main_val_function}, none_policy={none_policy}," \
-               " exc_type={exc_type}>" \
-               "".format(additional_info=(info + ', ') if len(info) > 0 else '',
-                         validator_type=type(self).__name__,
-                         main_val_function=self.get_main_function_name(),
-                         none_policy=get_none_policy_text(self.none_policy),
-                         exc_type=self.error_type.__name__)
+        _info = self.get_additional_info_for_repr()
+        additional_info = (_info + ', ') if len(_info) > 0 else ''
+
+        validator_type = type(self).__name__
+        main_val_function = self.get_main_function_name()
+        none_policy = get_none_policy_text(self.none_policy)
+        exc_type = self.error_type.__name__
+
+        return "%s<%s" \
+               "validation_function=%s, none_policy=%s, exc_type=%s>" \
+               % (validator_type, additional_info, main_val_function, none_policy, exc_type)
 
     def get_additional_info_for_repr(self):
         # type: (...) -> str

valid8/entry_points_annotations.py

@@ -47,8 +47,8 @@ def get_what_txt(self):
         Overrides the base behaviour defined in ValidationError in order to add details about the function.
         :return:
         """
-        return 'input [{var}] for function [{func}]'.format(var=self.get_variable_str(),
-                                                            func=self.validator.get_validated_func_display_name())
+        return 'input [%s] for function [%s]' % (self.get_variable_str(),
+                                                 self.validator.get_validated_func_display_name())
 
 
 class OutputValidationError(ValidationError):
@@ -67,7 +67,7 @@ def get_what_txt(self):
         Overrides the base behaviour defined in ValidationError in order to add details about the function.
         :return:
         """
-        return 'output of function [{func}]'.format(func=self.validator.get_validated_func_display_name())
+        return 'output of function [%s]' % self.validator.get_validated_func_display_name()
 
 
 class ClassFieldValidationError(ValidationError):
@@ -85,8 +85,8 @@ def get_what_txt(self):
         Overrides the base behaviour defined in ValidationError in order to add details about the class field.
         :return:
         """
-        return 'field [{field}] for class [{clazz}]'.format(field=self.get_variable_str(),
-                                                            clazz=self.validator.get_validated_class_display_name())
+        return 'field [%s] for class [%s]' % (self.get_variable_str(),
+                                              self.validator.get_validated_class_display_name())
 
     def get_variable_str(self):
         """ Utility method to get the variable value or 'var_name=value' if name is not None """
@@ -147,7 +147,7 @@ def __init__(self,
                                             error_type=error_type, help_msg=help_msg, **kw_context_args)
 
     def get_additional_info_for_repr(self):
-        return 'validated_function={func}'.format(func=get_callable_name(self.validated_func))
+        return 'validated_function=%s' % get_callable_name(self.validated_func)
 
     def get_validated_func_display_name(self):
         """
@@ -330,8 +330,8 @@ def _get_name_for_errors(self,
         return self.validated_field_name
 
     def get_additional_info_for_repr(self):
-        return 'validated_class_field={clazz}.{field}'.format(clazz=self.get_validated_class_display_name(),
-                                                              field=self.validated_field_name)
+        return 'validated_class_field=%s.%s' % (self.get_validated_class_display_name(),
+                                                self.validated_field_name)
 
     def get_validated_class_display_name(self):
         """
@@ -645,14 +645,14 @@ def decorate_cls_with_validation(cls,
         elif (hasattr(var, '__get__') and callable(var.__get__)) \
                 or (hasattr(var, '__delete__') and callable(var.__delete__)):
             # this is a descriptor but it does not have any setter method: impossible to validate
-            raise ValueError("Class field '{}' is a valid class descriptor for class '{}' but it does not implement "
+            raise ValueError("Class field '%s' is a valid class descriptor for class '%s' but it does not implement "
                              "__set__ so it is not possible to add validation to it. See "
-                             "https://docs.python.org/3.6/howto/descriptor.html".format(field_name, cls.__name__))
+                             "https://docs.python.org/3.6/howto/descriptor.html" % (field_name, cls.__name__))
 
         else:
             # this is not a descriptor: unsupported
-            raise ValueError("Class field '{}.{}' is not a valid class descriptor, see "
-                             "https://docs.python.org/3.6/howto/descriptor.html".format(cls.__name__, field_name))
+            raise ValueError("Class field '%s.%s' is not a valid class descriptor, see "
+                             "https://docs.python.org/3.6/howto/descriptor.html" % (cls.__name__, field_name))
 
     else:
         # ** No class field with that name exist
@@ -682,8 +682,8 @@ def decorate_cls_with_validation(cls,
             # (for __setattr__ see https://stackoverflow.com/questions/15750522/class-properties-and-setattr/15751159)
 
             # finally raise an error
-            raise ValueError("@validate_field definition exception: field '{}' can not be found in class '{}', and it "
-                             "is also not an input argument of the __init__ method.".format(field_name, cls.__name__))
+            raise ValueError("@validate_field definition exception: field '%s' can not be found in class '%s', and it "
+                             "is also not an input argument of the __init__ method." % (field_name, cls.__name__))
 
     return cls
 

valid8/entry_points_inline.py

@@ -319,8 +319,8 @@ def validate(name,                   # type: str
     else:
         # basic (and not enough) check to verify that there was no typo leading an argument to be put in kw_context_args
         if error_type is None and help_msg is None and len(kw_context_args) > 0:
-            raise ValueError("Keyword context arguments have been provided but help_msg and error_type are not: {}"
-                             "".format(kw_context_args))
+            raise ValueError("Keyword context arguments have been provided but `help_msg` and `error_type` have not: %s"
+                             % kw_context_args)
 
 
 _QUICK_VALIDATOR = _QuickValidator()
@@ -461,8 +461,8 @@ def __exit__(self, exc_type, exc_val, exc_tb):
                 try:
                     wrapped_block_lines = self._get_wrapped_lines(exit_file_path, exit_line_nb)
                 except Exception as e:
-                    warn('Error while inspecting source code at {}. No details will be added to the resulting '
-                         'exception. Caught {}'.format(exit_file_path, e))
+                    warn('Error while inspecting source code at %s. No details will be added to the resulting '
+                         'exception. Caught %s' % (exit_file_path, e))
                 else:
                     if exc_val is not None:
                         # -- There was an exception, we dont know where: output the full code in self.main_function.name

valid8/tests/helpers/utils.py

@@ -9,24 +9,24 @@ def append_all_custom_variants(base_function, custom_boolean_testers, custom_fai
     :return:
     """
     if 'custom_boolean' in base_function.__name__:
-        print('{} uses custom boolean checkers'.format(base_function.__name__))
+        print('%s uses custom boolean checkers' % base_function.__name__)
         for cust in custom_boolean_testers:
             dest_list.append(create_custom_function(base_function, cust))
 
     elif 'custom_raiser' in base_function.__name__:
-        print('{} uses custom failure raisers'.format(base_function.__name__))
+        print('%s uses custom failure raisers' % base_function.__name__)
         for cust in custom_failure_raisers:
             dest_list.append(create_custom_function(base_function, cust))
 
     else:
-        print('{} uses ALL custom functions'.format(base_function.__name__))
+        print('%s uses ALL custom functions' % base_function.__name__)
         for cust in custom_boolean_testers + custom_failure_raisers:
             dest_list.append(create_custom_function(base_function, cust))
 
 
 def create_custom_function(base_function, cust):
     def cust_f(t):
-        print('calling function {} with custom func {}'.format(base_function.__name__, cust.__name__))
+        print('calling function %s with custom func %s' % (base_function.__name__, cust.__name__))
         return base_function(t, cust)
 
     cust_f.__name__ = base_function.__name__.replace('custom', 'custom_' + cust.__name__)

valid8/tests/readme/examples/test_example3.py

@@ -21,7 +21,7 @@
 ex3_functions = []
 for ex3_func in ex3_functions_init:
     if 'custom' not in ex3_func.__name__:
-        print('{} does not use custom function'.format(ex3_func.__name__))
+        print('%s does not use custom function' % ex3_func.__name__)
         ex3_functions.append(ex3_func)
     else:
         # create as many functions as there are custom functions to use

valid8/tests/readme/test_readme_examples.py

@@ -18,11 +18,11 @@ def test_readme_examples_4():
 
     for i, v in enumerate(l):
         # each item is a tuple of size 2
-        validate('l[{}]'.format(i), l[i], instance_of=tuple, length=2)
+        validate('l[%s]'% i, l[i], instance_of=tuple, length=2)
         # the first element is a float between 0 and 1
-        validate('l[{}][0]'.format(i), l[i][0], instance_of=Real, min_value=0, max_value=1)
+        validate('l[%s][0]'% i, l[i][0], instance_of=Real, min_value=0, max_value=1)
         # the second element is a lowercase string of size 3
-        validate('l[{}][1]'.format(i), l[i][1], instance_of=str, length=3, equals=l[i][1].lower())
+        validate('l[%s][1]'% i, l[i][1], instance_of=str, length=3, equals=l[i][1].lower())
 
     # ---- inline 2
     from valid8 import validator
@@ -71,7 +71,7 @@ def check_valid_tuple(tup):
     # then validate (and use) the contents
     for i, v in enumerate(l):
         # each item is a valid tuple
-        with validation('l[{}]'.format(i), l[i]):
+        with validation('l[%s]'% i, l[i]):
             check_valid_tuple(l[i])
 
         # here you can actually USE the current item

valid8/tests/readme/test_readme_usage.py

@@ -13,7 +13,7 @@ def test_tutorial():
     # 1. age: finite
     def hello(age):
         assert isfinite(age)
-        print('Hello, {}-years-old fella !'.format(age))
+        print('Hello, %s-years-old fella !' % age)
 
     hello(21)
     with pytest.raises(AssertionError):
@@ -26,7 +26,7 @@ def hello(age):
     def hello(age):
         # assert_valid('age', age, isfinite)
         validate('age', age, custom=isfinite)
-        print('Hello, {}-years-old fella !'.format(age))
+        print('Hello, %s-years-old fella !' % age)
 
     hello(21)
     with pytest.raises(ValidationError) as exc_info:
@@ -45,7 +45,7 @@ def hello(age):
     from valid8.validation_lib import between
     def hello(age):
         assert_valid('age', age, [isfinite, between(0, 150)])
-        print('Hello, {}-years-old fella !'.format(age))
+        print('Hello, %s-years-old fella !' % age)
 
     hello(21)
     with pytest.raises(ValidationError) as exc_info:
@@ -61,7 +61,7 @@ def hello(age):
     from mini_lambda import x, Int
     def hello(age):
         assert_valid('age', age, [isfinite, between(0, 150), Int(x) == x])
-        print('Hello, {}-years-old fella !'.format(age))
+        print('Hello, %s-years-old fella !' % age)
 
     with pytest.raises(ValidationError) as exc_info:
         hello(12.5)
@@ -281,7 +281,7 @@ def is_multiple_of(ref):
         def is_multiple_of_ref(x):
             return x % ref == 0
 
-        is_multiple_of_ref.__doc__ = "Checks that x is a multiple of {}".format(ref)
+        is_multiple_of_ref.__doc__ = "Checks that x is a multiple of %s" % ref
         is_multiple_of_ref.__name__ = "is_multiple_of_" + str(ref)
         return is_multiple_of_ref
 
@@ -298,10 +298,10 @@ def create_base_functions_2():
     # (recommended) raising an exception
     def gt_0(x):
         if not (x >= 0):
-            raise ValueError('x is not greater than 0, x={}.'.format(x))
+            raise ValueError('x is not greater than 0, x=%s.' % x)
     def gt_1(x):
         if x < 1:
-            raise ValidationFailure(x, 'x is not greater than 1, x={}.'.format(x))
+            raise ValidationFailure(x, 'x is not greater than 1, x=%s.' % x)
 
     # (not recommended) relying on assert, only valid in 'debug' mode
     def gt_2(x):
@@ -310,7 +310,7 @@ def gt_2(x):
     # returning details
     def gt_3(x):
         if x < 3:
-            return 'x is not greater than 3, x={}'.format(x)
+            return 'x is not greater than 3, x=%s' % x
 
     return gt_0, gt_1, gt_2, gt_3
 
@@ -353,7 +353,7 @@ def gt_ex1(x):
         if x >= 1:
             return True
         else:
-            raise ValidationFailure(x, 'x >= 1 does not hold for x={}'.format(x))
+            raise ValidationFailure(x, 'x >= 1 does not hold for x=%s' % x)
 
     def gt_assert2(x):
         """(not recommended) relying on assert, only valid in 'debug' mode"""

valid8/tests/test_entry_points_annotations.py

@@ -288,7 +288,7 @@ def test_validate_custom_validators_with_exception():
     def gt_ex1(x):
         """ A validator raising a custom exception in case of failure """
         if not x >= 1:
-            raise ValidationFailure(x, 'x >= 1 does not hold for x={val}'.format(val=x))
+            raise ValidationFailure(x, 'x >= 1 does not hold for x=%s' % x)
 
     def is_mod(ref):
         """ A validator generator, with parameters and which raises a custom exception """