fixed error E501- line too long

manfred-kaiser · manfred-kaiser · commit baa4d3adc4cb · 2020-09-28T16:15:47.000+02:00
diff --git a/sifter/commands/discard.py b/sifter/commands/discard.py
@@ -26,7 +26,12 @@ class CommandDiscard(Command):
 
     RULE_IDENTIFIER = 'DISCARD'
 
-    def __init__(self, arguments: Optional[List[Union['TagGrammar', SupportsInt, List[Union[Text, 'String']]]]] = None, tests: Optional[List['Test']] = None, block: Optional[CommandList] = None) -> None:
+    def __init__(
+        self,
+        arguments: Optional[List[Union['TagGrammar', SupportsInt, List[Union[Text, 'String']]]]] = None,
+        tests: Optional[List['Test']] = None,
+        block: Optional[CommandList] = None
+    ) -> None:
         super(CommandDiscard, self).__init__(arguments, tests, block)
         self.validate_arguments()
         self.validate_tests_size(0)
diff --git a/sifter/commands/fileinto.py b/sifter/commands/fileinto.py
@@ -27,7 +27,12 @@ class CommandFileInto(Command):
 
     RULE_IDENTIFIER = 'FILEINTO'
 
-    def __init__(self, arguments: Optional[List[Union['TagGrammar', SupportsInt, List[Union[Text, 'String']]]]] = None, tests: Optional[List['Test']] = None, block: Optional[CommandList] = None) -> None:
+    def __init__(
+        self,
+        arguments: Optional[List[Union['TagGrammar', SupportsInt, List[Union[Text, 'String']]]]] = None,
+        tests: Optional[List['Test']] = None,
+        block: Optional[CommandList] = None
+    ) -> None:
         super(CommandFileInto, self).__init__(arguments, tests, block)
         _, positional_args = self.validate_arguments(
             {},
diff --git a/sifter/commands/if_cmd.py b/sifter/commands/if_cmd.py
@@ -24,7 +24,12 @@
 # section 3.1
 class CommandIfBase(Command):
 
-    def __init__(self, arguments: Optional[List[Union['TagGrammar', SupportsInt, List[Union[Text, 'String']]]]] = None, tests: Optional[List['Test']] = None, block: Optional[CommandList] = None) -> None:
+    def __init__(
+        self,
+        arguments: Optional[List[Union['TagGrammar', SupportsInt, List[Union[Text, 'String']]]]] = None,
+        tests: Optional[List['Test']] = None,
+        block: Optional[CommandList] = None
+    ) -> None:
         super(CommandIfBase, self).__init__(arguments, tests, block)
         self.validate_arguments()
         self.validate_tests_size(1)
@@ -63,7 +68,12 @@ class CommandElse(Command):
 
     RULE_IDENTIFIER = 'ELSE'
 
-    def __init__(self, arguments: Optional[List[Union['TagGrammar', SupportsInt, List[Union[Text, 'String']]]]] = None, tests: Optional[List['Test']] = None, block: Optional[CommandList] = None) -> None:
+    def __init__(
+        self,
+        arguments: Optional[List[Union['TagGrammar', SupportsInt, List[Union[Text, 'String']]]]] = None,
+        tests: Optional[List['Test']] = None,
+        block: Optional[CommandList] = None
+    ) -> None:
         super(CommandElse, self).__init__(arguments, tests, block)
         self.validate_arguments()
         self.validate_tests_size(0)
diff --git a/sifter/commands/keep.py b/sifter/commands/keep.py
@@ -27,7 +27,12 @@ class CommandKeep(Command):
 
     RULE_IDENTIFIER = 'KEEP'
 
-    def __init__(self, arguments: Optional[List[Union['TagGrammar', SupportsInt, List[Union[Text, 'String']]]]] = None, tests: Optional[List['Test']] = None, block: Optional[CommandList] = None) -> None:
+    def __init__(
+        self,
+        arguments: Optional[List[Union['TagGrammar', SupportsInt, List[Union[Text, 'String']]]]] = None,
+        tests: Optional[List['Test']] = None,
+        block: Optional[CommandList] = None
+    ) -> None:
         super(CommandKeep, self).__init__(arguments, tests, block)
         self.validate_arguments()
         self.validate_tests_size(0)
diff --git a/sifter/commands/redirect.py b/sifter/commands/redirect.py
@@ -29,7 +29,12 @@ class CommandRedirect(Command):
 
     RULE_IDENTIFIER = 'REDIRECT'
 
-    def __init__(self, arguments: Optional[List[Union['TagGrammar', SupportsInt, List[Union[Text, 'String']]]]] = None, tests: Optional[List['Test']] = None, block: Optional[CommandList] = None) -> None:
+    def __init__(
+        self,
+        arguments: Optional[List[Union['TagGrammar', SupportsInt, List[Union[Text, 'String']]]]] = None,
+        tests: Optional[List['Test']] = None,
+        block: Optional[CommandList] = None
+    ) -> None:
         super(CommandRedirect, self).__init__(arguments, tests, block)
         _, positional_args = self.validate_arguments(
             {},
diff --git a/sifter/commands/require.py b/sifter/commands/require.py
@@ -29,7 +29,12 @@ class CommandRequire(Command):
 
     RULE_IDENTIFIER: Text = 'REQUIRE'
 
-    def __init__(self, arguments: Optional[List[Union['TagGrammar', SupportsInt, List[Union[Text, 'String']]]]] = None, tests: Optional[List['Test']] = None, block: Optional[CommandList] = None) -> None:
+    def __init__(
+        self,
+        arguments: Optional[List[Union['TagGrammar', SupportsInt, List[Union[Text, 'String']]]]] = None,
+        tests: Optional[List['Test']] = None,
+        block: Optional[CommandList] = None
+    ) -> None:
         super(CommandRequire, self).__init__(arguments, tests, block)
         _, positional_args = self.validate_arguments(
             {},
diff --git a/sifter/commands/stop.py b/sifter/commands/stop.py
@@ -26,7 +26,12 @@ class CommandStop(Command):
 
     RULE_IDENTIFIER = 'STOP'
 
-    def __init__(self, arguments: Optional[List[Union['TagGrammar', SupportsInt, List[Union[Text, 'String']]]]] = None, tests: Optional[List['Test']] = None, block: Optional[CommandList] = None) -> None:
+    def __init__(
+        self,
+        arguments: Optional[List[Union['TagGrammar', SupportsInt, List[Union[Text, 'String']]]]] = None,
+        tests: Optional[List['Test']] = None,
+        block: Optional[CommandList] = None
+    ) -> None:
         super(CommandStop, self).__init__(arguments, tests, block)
         self.validate_arguments()
         self.validate_tests_size(0)
diff --git a/sifter/comparator.py b/sifter/comparator.py
@@ -22,7 +22,10 @@ def register(comparator_name: Optional[Text], comparator_cls: Type['Comparator']
     sifter.handler.register('comparator', comparator_name, comparator_cls)
 
 
-def get_match_fn(comparator: Optional[Union[Text, 'Tag']], match_type: Optional[Union[Text, 'Tag']]) -> Tuple[Callable[[Text, Text, 'EvaluationState'], bool], Union[Text, 'Tag'], Union[Text, 'Tag']]:
+def get_match_fn(
+    comparator: Optional[Union[Text, 'Tag']],
+    match_type: Optional[Union[Text, 'Tag']]
+) -> Tuple[Callable[[Text, Text, 'EvaluationState'], bool], Union[Text, 'Tag'], Union[Text, 'Tag']]:
     # section 2.7.3: default comparator is 'i;ascii-casemap'
     if comparator is None:
         comparator = 'i;ascii-casemap'
diff --git a/sifter/grammar/command.py b/sifter/grammar/command.py
@@ -28,7 +28,12 @@ class Command(Rule):
 
     RULE_TYPE: Text = 'command'
 
-    def __init__(self, arguments: Optional[List[Union['TagGrammar', SupportsInt, List[Union[Text, 'String']]]]] = None, tests: Optional[List['Test']] = None, block: Optional[CommandList] = None) -> None:
+    def __init__(
+        self,
+        arguments: Optional[List[Union['TagGrammar', SupportsInt, List[Union[Text, 'String']]]]] = None,
+        tests: Optional[List['Test']] = None,
+        block: Optional[CommandList] = None
+    ) -> None:
         super(Command, self).__init__(arguments, tests)
         if block is None:
             self.block = CommandList()
diff --git a/sifter/grammar/rule.py b/sifter/grammar/rule.py
@@ -40,7 +40,11 @@ def register(cls) -> None:
             # only on subclasses that implement specific rules
             raise NotImplementedError
 
-    def __init__(self, arguments: Optional[List[Union['Tag', SupportsInt, List[Union[Text, 'String']]]]] = None, tests: Optional[List['Test']] = None) -> None:
+    def __init__(
+        self,
+        arguments: Optional[List[Union['Tag', SupportsInt, List[Union[Text, 'String']]]]] = None,
+        tests: Optional[List['Test']] = None
+    ) -> None:
         if arguments is None:
             self.arguments = []
         else:
@@ -63,7 +67,10 @@ def validate_arguments(
         self,
         tagged_args: Optional[Union[List[Validator], Dict[Text, Validator]]] = None,
         positional_args: Optional[List[Validator]] = None
-    ) -> Tuple[Dict[Text, List[Union[Tag, SupportsInt, List[Union[Text, 'String']]]]], List[Union[Tag, SupportsInt, List[Union[Text, 'String']]]]]:
+    ) -> Tuple[
+        Dict[Text, List[Union[Tag, SupportsInt, List[Union[Text, 'String']]]]],
+        List[Union[Tag, SupportsInt, List[Union[Text, 'String']]]]
+    ]:
         if tagged_args is None:
             tagged_args = {}
         if positional_args is None:
@@ -80,7 +87,8 @@ def validate_arguments(
                 if num_valid_args is not None and num_valid_args > 0:
                     if arg_name in seen_args:
                         raise RuleSyntaxError(
-                            "%s argument to %s was already seen earlier: %s" % (arg_name, self.RULE_IDENTIFIER, self.arguments[i])
+                            "%s argument to %s was already seen earlier: %s" %
+                            (arg_name, self.RULE_IDENTIFIER, self.arguments[i])
                         )
                     seen_args[arg_name] = self.arguments[i:i + num_valid_args]
                     i += num_valid_args
diff --git a/sifter/grammar/string.py b/sifter/grammar/string.py
@@ -19,7 +19,13 @@ class String(str):
     pass
 
 
-def compare(str1: Text, str2: Text, state: EvaluationState, comparator: Optional[Union[Text, 'Tag']] = None, match_type: Optional[Union[Text, 'Tag']] = None) -> bool:
+def compare(
+    str1: Text,
+    str2: Text,
+    state: EvaluationState,
+    comparator: Optional[Union[Text, 'Tag']] = None,
+    match_type: Optional[Union[Text, 'Tag']] = None
+) -> bool:
     cmp_fn, comparator, match_type = sifter.comparator.get_match_fn(comparator, match_type)
     state.check_required_extension('comparator-%s' % comparator, 'the comparator')
     return cmp_fn(str1, str2, state)
diff --git a/sifter/grammar/validator.py b/sifter/grammar/validator.py
@@ -16,5 +16,9 @@
 
 class Validator(object):
 
-    def validate(self, arg_list: List[Union['TagGrammar', SupportsInt, List[Union[Text, 'String']]]], starting_index: int) -> Optional[int]:
+    def validate(
+        self,
+        arg_list: List[Union['TagGrammar', SupportsInt, List[Union[Text, 'String']]]],
+        starting_index: int
+    ) -> Optional[int]:
         raise NotImplementedError
diff --git a/sifter/handler.py b/sifter/handler.py
@@ -15,7 +15,11 @@
 _HANDLERS_MAP: Dict[Text, Dict[Text, Union[bool, Type['Comparator'], Type['Rule']]]] = {}
 
 
-def register(handler_type: Optional[Text], handler_id: Optional[Text], value: Union[bool, Type['Comparator'], Type['Rule']]) -> None:
+def register(
+    handler_type: Optional[Text],
+    handler_id: Optional[Text],
+    value: Union[bool, Type['Comparator'], Type['Rule']]
+) -> None:
     if not handler_type or not handler_id:
         raise ValueError("handler_type and handler_id must not be None!")
     _HANDLERS_MAP.setdefault(handler_type, {})[handler_id] = value
diff --git a/sifter/tests/address.py b/sifter/tests/address.py
@@ -29,7 +29,11 @@ class TestAddress(Test):
 
     RULE_IDENTIFIER: Text = 'ADDRESS'
 
-    def __init__(self, arguments: Optional[List[Union['TagGrammar', SupportsInt, List[Union[Text, 'String']]]]] = None, tests: Optional[List['Test']] = None) -> None:
+    def __init__(
+        self,
+        arguments: Optional[List[Union['TagGrammar', SupportsInt, List[Union[Text, 'String']]]]] = None,
+        tests: Optional[List['Test']] = None
+    ) -> None:
         super(TestAddress, self).__init__(arguments, tests)
         tagged_args, positional_args = self.validate_arguments(
             {
diff --git a/sifter/tests/allof.py b/sifter/tests/allof.py
@@ -23,7 +23,11 @@ class TestAllOf(Test):
 
     RULE_IDENTIFIER: Text = 'ALLOF'
 
-    def __init__(self, arguments: Optional[List[Union['TagGrammar', SupportsInt, List[Union[Text, 'String']]]]] = None, tests: Optional[List['Test']] = None) -> None:
+    def __init__(
+        self,
+        arguments: Optional[List[Union['TagGrammar', SupportsInt, List[Union[Text, 'String']]]]] = None,
+        tests: Optional[List['Test']] = None
+    ) -> None:
         super(TestAllOf, self).__init__(arguments, tests)
         self.validate_arguments()
 
diff --git a/sifter/tests/anyof.py b/sifter/tests/anyof.py
@@ -24,7 +24,11 @@ class TestAnyOf(Test):
 
     RULE_IDENTIFIER = 'ANYOF'
 
-    def __init__(self, arguments: Optional[List[Union['TagGrammar', SupportsInt, List[Union[Text, 'String']]]]] = None, tests: Optional[List['Test']] = None) -> None:
+    def __init__(
+        self,
+        arguments: Optional[List[Union['TagGrammar', SupportsInt, List[Union[Text, 'String']]]]] = None,
+        tests: Optional[List['Test']] = None
+    ) -> None:
         super(TestAnyOf, self).__init__(arguments, tests)
         self.validate_arguments()
 
diff --git a/sifter/tests/exists.py b/sifter/tests/exists.py
@@ -25,7 +25,11 @@ class TestExists(Test):
 
     RULE_IDENTIFIER = 'EXISTS'
 
-    def __init__(self, arguments: Optional[List[Union['TagGrammar', SupportsInt, List[Union[Text, 'String']]]]] = None, tests: Optional[List['Test']] = None) -> None:
+    def __init__(
+        self,
+        arguments: Optional[List[Union['TagGrammar', SupportsInt, List[Union[Text, 'String']]]]] = None,
+        tests: Optional[List['Test']] = None
+    ) -> None:
         super(TestExists, self).__init__(arguments, tests)
         tagged_args, positional_args = self.validate_arguments(
             {},
diff --git a/sifter/tests/false.py b/sifter/tests/false.py
@@ -23,7 +23,11 @@ class TestFalse(Test):
 
     RULE_IDENTIFIER = 'FALSE'
 
-    def __init__(self, arguments: Optional[List[Union['TagGrammar', SupportsInt, List[Union[Text, 'String']]]]] = None, tests: Optional[List['Test']] = None) -> None:
+    def __init__(
+        self,
+        arguments: Optional[List[Union['TagGrammar', SupportsInt, List[Union[Text, 'String']]]]] = None,
+        tests: Optional[List['Test']] = None
+    ) -> None:
         super(TestFalse, self).__init__(arguments, tests)
         self.validate_arguments()
         self.validate_tests_size(0)
diff --git a/sifter/tests/header.py b/sifter/tests/header.py
@@ -27,7 +27,11 @@ class TestHeader(Test):
 
     RULE_IDENTIFIER = 'HEADER'
 
-    def __init__(self, arguments: Optional[List[Union['TagGrammar', SupportsInt, List[Union[Text, 'String']]]]] = None, tests: Optional[List['Test']] = None) -> None:
+    def __init__(
+        self,
+        arguments: Optional[List[Union['TagGrammar', SupportsInt, List[Union[Text, 'String']]]]] = None,
+        tests: Optional[List['Test']] = None
+    ) -> None:
         super(TestHeader, self).__init__(arguments, tests)
         tagged_args, positional_args = self.validate_arguments(
             {
diff --git a/sifter/tests/not_test.py b/sifter/tests/not_test.py
@@ -23,7 +23,11 @@ class TestNot(Test):
 
     RULE_IDENTIFIER = 'NOT'
 
-    def __init__(self, arguments: Optional[List[Union['TagGrammar', SupportsInt, List[Union[Text, 'String']]]]] = None, tests: Optional[List['Test']] = None) -> None:
+    def __init__(
+        self,
+        arguments: Optional[List[Union['TagGrammar', SupportsInt, List[Union[Text, 'String']]]]] = None,
+        tests: Optional[List['Test']] = None
+    ) -> None:
         super(TestNot, self).__init__(arguments, tests)
         self.validate_arguments()
         self.validate_tests_size(1)
diff --git a/sifter/tests/size.py b/sifter/tests/size.py
@@ -34,7 +34,11 @@ class TestSize(Test):
         'UNDER': operator.lt,
     }
 
-    def __init__(self, arguments: Optional[List[Union['TagGrammar', SupportsInt, List[Union[Text, 'String']]]]] = None, tests: Optional[List['Test']] = None) -> None:
+    def __init__(
+        self,
+        arguments: Optional[List[Union['TagGrammar', SupportsInt, List[Union[Text, 'String']]]]] = None,
+        tests: Optional[List['Test']] = None
+    ) -> None:
         super(TestSize, self).__init__(arguments, tests)
         tagged_args, positional_args = self.validate_arguments(
             {
diff --git a/sifter/tests/true.py b/sifter/tests/true.py
@@ -22,7 +22,11 @@ class TestTrue(Test):
 
     RULE_IDENTIFIER = 'TRUE'
 
-    def __init__(self, arguments: Optional[List[Union['TagGrammar', SupportsInt, List[Union[Text, 'String']]]]] = None, tests: Optional[List['Test']] = None) -> None:
+    def __init__(
+        self,
+        arguments: Optional[List[Union['TagGrammar', SupportsInt, List[Union[Text, 'String']]]]] = None,
+        tests: Optional[List['Test']] = None
+    ) -> None:
         super(TestTrue, self).__init__(arguments, tests)
         self.validate_arguments()
         self.validate_tests_size(0)
diff --git a/sifter/validators/number.py b/sifter/validators/number.py
@@ -18,7 +18,11 @@
 
 class Number(Validator):
 
-    def validate(self, arg_list: List[Union['TagGrammar', SupportsInt, List[Union[Text, 'String']]]], starting_index: int) -> Optional[int]:
+    def validate(
+        self,
+        arg_list: List[Union['TagGrammar', SupportsInt, List[Union[Text, 'String']]]],
+        starting_index: int
+    ) -> Optional[int]:
         if starting_index >= len(arg_list):
             return 0
         value_to_check = arg_list[starting_index]
diff --git a/sifter/validators/stringlist.py b/sifter/validators/stringlist.py
@@ -22,7 +22,11 @@ def __init__(self, length: Optional[int] = None) -> None:
         super(StringList, self).__init__()
         self.length = length
 
-    def validate(self, arg_list: List[Union['TagGrammar', SupportsInt, List[Union[Text, 'String']]]], starting_index: int) -> Optional[int]:
+    def validate(
+        self,
+        arg_list: List[Union['TagGrammar', SupportsInt, List[Union[Text, 'String']]]],
+        starting_index: int
+    ) -> Optional[int]:
         if starting_index >= len(arg_list):
             return 0
         arg = arg_list[starting_index]
diff --git a/sifter/validators/tag.py b/sifter/validators/tag.py
@@ -25,7 +25,11 @@
 
 class Tag(Validator):
 
-    def __init__(self, allowed_tags: Optional[Union[Text, Tuple[Text, ...]]] = None, tag_arg_validators: Optional[Tuple[Validator, ...]] = None) -> None:
+    def __init__(
+        self,
+        allowed_tags: Optional[Union[Text, Tuple[Text, ...]]] = None,
+        tag_arg_validators: Optional[Tuple[Validator, ...]] = None
+    ) -> None:
         self.tag_arg_validators: Tuple[Validator, ...]
         super(Tag, self).__init__()
         self.allowed_tags: Optional[Tuple[Text, ...]] = None
@@ -38,7 +42,11 @@ def __init__(self, allowed_tags: Optional[Union[Text, Tuple[Text, ...]]] = None,
         else:
             self.tag_arg_validators = tag_arg_validators
 
-    def validate(self, arg_list: List[Union['TagGrammar', SupportsInt, List[Union[Text, 'String']]]], starting_index: int) -> Optional[int]:
+    def validate(
+        self,
+        arg_list: List[Union['TagGrammar', SupportsInt, List[Union[Text, 'String']]]],
+        starting_index: int
+    ) -> Optional[int]:
         if starting_index >= len(arg_list):
             return 0
         if not isinstance(arg_list[starting_index], tag.Tag):
@@ -76,7 +84,11 @@ def __init__(self) -> None:
             (StringList(1),),
         )
 
-    def validate(self, arg_list: List[Union['TagGrammar', SupportsInt, List[Union[Text, 'String']]]], starting_index: int) -> Optional[int]:
+    def validate(
+        self,
+        arg_list: List[Union['TagGrammar', SupportsInt, List[Union[Text, 'String']]]],
+        starting_index: int
+    ) -> Optional[int]:
         validated_args = super(Comparator, self).validate(
             arg_list,
             starting_index
