fixed mypy and flake8 errors

Author: manfred-kaiser

sifter/commands/notify.py

@@ -59,6 +59,9 @@ def evaluate(self, message: Message, state: EvaluationState) -> Optional[Actions
         if not res:
             raise RuleSyntaxError(msg)
 
-        state.actions.append('notify', (notify_method, notify_from, notify_importance, notify_options, notify_message))  # type: ignore
+        state.actions.append(
+            'notify',
+            (notify_method, notify_from, notify_importance, notify_options, notify_message)  # type: ignore
+        )
 
         return None

sifter/commands/variables.py

@@ -1,10 +1,18 @@
 import re
+from email.message import Message
+from typing import (
+    Optional,
+    Text
+)
+
 from urllib.parse import quote
 from sifter.grammar.command import Command
 from sifter.grammar.rule import RuleSyntaxError
 from sifter.validators.stringlist import StringList
 from sifter.validators.tag import Tag
 from sifter.grammar.string import expand_variables
+from sifter.grammar.state import EvaluationState
+from sifter.grammar.actions import Actions
 
 __all__ = ('CommandSet',)
 
@@ -28,34 +36,33 @@ class CommandSet(Command):
         StringList(length=1),
     ]
 
-    def __init__(self, arguments=None, tests=None, block=None):
-        super(CommandSet, self).__init__(arguments, tests, block)
+    def evaluate(self, message: Message, state: EvaluationState) -> Optional[Actions]:
+        state.check_required_extension('variables', 'VARIABLES')
 
-        self.variable_modifier = self.tagged_args
-        self.variable_name = self.positional_args[0][0]
-        if (not re.match(r'^[A-Za-z_][A-Za-z0-9_]*$', self.variable_name)):
-            raise RuleSyntaxError("Illegal variable name '%s' encountered" % self.variable_name)
-        self.variable_value = self.positional_args[1][0]
+        variable_modifier = self.tagged_args
+        variable_name = self.positional_args[0][0]  # type: ignore
+        if (not re.match(r'^[A-Za-z_][A-Za-z0-9_]*$', variable_name)):
+            raise RuleSyntaxError("Illegal variable name '%s' encountered" % variable_name)
+        variable_value: Text = self.positional_args[1][0]  # type: ignore
 
-    def evaluate(self, message, state):
-        state.check_required_extension('variables', 'VARIABLES')
-        variable_value = expand_variables(self.variable_value, state)
-        if 'lower' in self.variable_modifier:
+        variable_value = expand_variables(variable_value, state)
+        if 'lower' in variable_modifier:
             variable_value = variable_value.lower()
-        if 'upper' in self.variable_modifier:
+        if 'upper' in variable_modifier:
             variable_value = variable_value.upper()
-        if 'lowerfirst' in self.variable_modifier:
+        if 'lowerfirst' in variable_modifier:
             variable_value = variable_value[:1].lower() + variable_value[1:]
-        if 'upperfirst' in self.variable_modifier:
+        if 'upperfirst' in variable_modifier:
             variable_value = variable_value[:1].upper() + variable_value[1:]
-        if 'quotewildcard' in self.variable_modifier:
+        if 'quotewildcard' in variable_modifier:
             variable_value = variable_value.replace('*', '\\*')
             variable_value = variable_value.replace('?', '\\?')
             variable_value = variable_value.replace('\\', '\\\\')
-        if 'quoteregex' in self.variable_modifier:
+        if 'quoteregex' in variable_modifier:
             variable_value = re.escape(variable_value)
-        if 'encodeurl' in self.variable_modifier:
+        if 'encodeurl' in variable_modifier:
             variable_value = quote(variable_value, safe='-._~')
-        if 'length' in self.variable_modifier:
-            variable_value = "" + len(variable_value)
-        state.named_variables[self.variable_name] = variable_value
+        if 'length' in variable_modifier:
+            variable_value = "" + str(len(variable_value))
+        state.named_variables[variable_name] = variable_value
+        return None

sifter/extensions/__init__.py

@@ -103,9 +103,13 @@ def register(
         cls._HANDLERS_MAP.setdefault(handler_type, {})[handler_id] = value
 
     @classmethod
-    def unregister(cls, handler_type: Text, handler_id: Text) -> Optional[Union[bool, Type[NotificationMethod], Type['Comparator'], Type['Rule']]]:
+    def unregister(
+        cls, handler_type: Text, handler_id: Text
+    ) -> Optional[Union[bool, Type[NotificationMethod], Type['Comparator'], Type['Rule']]]:
         return cls._HANDLERS_MAP.get(handler_type, {}).pop(handler_id, None)
 
     @classmethod
-    def get(cls, handler_type: Text, handler_id: Text) -> Optional[Union[bool, Type[NotificationMethod], Type['Comparator'], Type['Rule']]]:
+    def get(
+        cls, handler_type: Text, handler_id: Text
+    ) -> Optional[Union[bool, Type[NotificationMethod], Type['Comparator'], Type['Rule']]]:
         return cls._HANDLERS_MAP.get(handler_type, {}).get(handler_id, None)

sifter/grammar/notificationmethod.py

@@ -16,7 +16,9 @@ def handler_type(cls) -> Text:
     @classmethod
     def handler_id(cls) -> Text:
         if cls.NOTIFICATION_METHOD_ID is None:
-            raise NotImplementedError('NotificationMethod must be implemented as subclass as NOTIFICATION_METHOD_ID must be set')
+            raise NotImplementedError(
+                'NotificationMethod must be implemented as subclass as NOTIFICATION_METHOD_ID must be set'
+            )
         return cls.NOTIFICATION_METHOD_ID
 
     @classmethod

sifter/tests/body.py

@@ -1,6 +1,12 @@
 import re
+from email.message import Message
 from typing import (
-    Text
+    TYPE_CHECKING,
+    Text,
+    Optional,
+    List,
+    Union,
+    SupportsInt
 )
 from sifter.grammar.state import EvaluationState
 
@@ -9,6 +15,10 @@
 from sifter.validators.tag import Comparator, MatchType, BodyTransform
 from sifter.grammar.string import compare as string_compare, expand_variables
 
+if TYPE_CHECKING:
+    from sifter.grammar.tag import Tag
+    from sifter.grammar.string import String
+
 
 # RFC 5173
 class TestBody(Test):
@@ -23,13 +33,18 @@ class TestBody(Test):
         StringList(),
     ]
 
-    def __init__(self, arguments=None, tests=None):
+    def __init__(
+        self,
+        arguments: Optional[List[Union['Tag', SupportsInt, List[Union[Text, 'String']]]]] = None,
+        tests: Optional[List['Test']] = None,
+        validate: bool = True
+    ) -> None:
         super(TestBody, self).__init__(arguments, tests)
 
         self.keylist = self.positional_args[0]
         self.body_transform = self.match_type = self.comparator = None
         if 'comparator' in self.tagged_args:
-            self.comparator = self.tagged_args['comparator'][1][0]
+            self.comparator = self.tagged_args['comparator'][1][0]  # type: ignore
         if 'match_type' in self.tagged_args:
             self.match_type = self.tagged_args['match_type'][0]
         if 'body_transform' in self.tagged_args:
@@ -39,11 +54,11 @@ def __init__(self, arguments=None, tests=None):
             elif body_transform_type == 'TEXT':
                 self.body_transform = ['text']
             else:
-                self.body_transform = self.tagged_args['body_transform'][1]
+                self.body_transform = self.tagged_args['body_transform'][1]  # type: ignore
         else:
             self.body_transform = ['text']
 
-    def evaluate(self, message, state):
+    def evaluate(self, message: Message, state: EvaluationState) -> Optional[bool]:
         state.check_required_extension('body', 'tests against the email body')
         if not self.body_transform:  # RAW
             # Flatten message, match header / body separator (two new-lines);
@@ -73,8 +88,8 @@ def evaluate(self, message, state):
         return False
 
     def evaluate_part(self, part_str: Text, state: EvaluationState) -> bool:
-        for key in self.keylist:
+        for key in self.keylist:  # type: ignore
             key = expand_variables(key, state)
-            if string_compare(part_str, key, state, self.comparator, self.match_type):
+            if string_compare(part_str, key, state, self.comparator, self.match_type):  # type: ignore
                 return True
         return False

sifter/tests/notify.py

@@ -1,6 +1,11 @@
 import re
 from email.message import Message
-from typing import Optional
+from typing import (
+    Any,
+    Optional,
+    Text,
+    List
+)
 
 from sifter.grammar.test import Test
 from sifter.validators.stringlist import StringList
@@ -54,21 +59,23 @@ class TestNotifyMethodCapability(Test):
     def evaluate(self, message: Message, state: EvaluationState) -> Optional[bool]:
         state.check_required_extension('enotify', 'NOTIFY')
 
+        match_type: Text
+
         if 'comparator' in self.tagged_args:
-            comparator = self.tagged_args['comparator'][1][0]
+            comparator = self.tagged_args['comparator'][1][0]  # type: ignore
         else:
             comparator = 'i;ascii-casemap'
         if 'match_type' in self.tagged_args:
-            match_type = self.tagged_args['match_type'][0]
+            match_type = self.tagged_args['match_type'][0]  # type: ignore
         else:
             match_type = 'IS'
-        notification_uri = self.positional_args[0][0]
-        notification_capability = self.positional_args[1][0]
-        key_list = self.positional_args[2]
+        notification_uri = self.positional_args[0][0]  # type: ignore
+        notification_capability = self.positional_args[1][0]  # type: ignore
+        key_list: List[Any] = self.positional_args[2]  # type: ignore
 
         notification_uri = sifter.grammar.string.expand_variables(notification_uri, state)
         notification_capability = sifter.grammar.string.expand_variables(notification_capability, state)
-        key_list = map(lambda s: sifter.grammar.string.expand_variables(s, state), key_list)
+        key_list = list(map(lambda s: sifter.grammar.string.expand_variables(s, state), key_list))
 
         m = re.match('^([A-Za-z][A-Za-z0-9.+-]*):', notification_uri)
         if not m: