added more type hints

Author: manfred-kaiser

sifter/comparator.py

@@ -1,13 +1,26 @@
+from typing import (
+    TYPE_CHECKING,
+    Any,
+    Callable,
+    Text,
+    Optional,
+    Tuple,
+    Type
+)
+
 import sifter.handler
 
+if TYPE_CHECKING:
+    from sifter.grammar.comparator import Comparator
+
 __all__ = ('register', 'get_match_fn',)
 
 
-def register(comparator_name, comparator_cls):
+def register(comparator_name: Text, comparator_cls: Type['Comparator']) -> None:
     sifter.handler.register('comparator', comparator_name, comparator_cls)
 
 
-def get_match_fn(comparator, match_type):
+def get_match_fn(comparator: Optional[Text], match_type: Optional[Text]) -> Tuple[Callable[[Text, Text, Any], bool], Text, Text]:  # TODO: Change Any from Callable
     # section 2.7.3: default comparator is 'i;ascii-casemap'
     if comparator is None:
         comparator = 'i;ascii-casemap'

sifter/grammar/tag.py

@@ -1,10 +1,12 @@
+from typing import Text
+
 __all__ = ('Tag',)
 
 
 class Tag(str):
 
-    def __str__(self):
+    def __str__(self) -> Text:
         return ":%s" % super(Tag, self).__str__()
 
-    def __repr__(self):
+    def __repr__(self) -> Text:
         return "%s('%s')" % ('Tag', super(Tag, self).__repr__())

sifter/handler.py

@@ -1,13 +1,20 @@
-_HANDLERS_MAP = {}
+from typing import (
+    Any,
+    Dict,
+    Text
+)
 
 
-def register(handler_type, handler_id, value):
+_HANDLERS_MAP: Dict[Text, Dict[Text, Any]] = {}
+
+
+def register(handler_type: Text, handler_id: Text, value: Any) -> None:
     _HANDLERS_MAP.setdefault(handler_type, {})[handler_id] = value
 
 
-def unregister(handler_type, handler_id):
+def unregister(handler_type: Text, handler_id: Text) -> Any:
     return _HANDLERS_MAP.get(handler_type, {}).pop(handler_id, None)
 
 
-def get(handler_type, handler_id):
+def get(handler_type: Text, handler_id: Text) -> Any:
     return _HANDLERS_MAP.get(handler_type, {}).get(handler_id, None)

sifter/validators/tag.py

@@ -1,20 +1,25 @@
 from typing import (
-    Tuple,
     Union,
     Optional,
-    Text
+    Text,
+    List,
+    Tuple
 )
 
-import sifter.grammar
+from sifter.grammar.validator import Validator
+from sifter.grammar.rule import RuleSyntaxError
+from sifter.grammar import tag
+from sifter.validators.stringlist import StringList
 import sifter.handler
 import sifter.validators
 
 __all__ = ('Tag', 'MatchType', 'Comparator',)
 
 
-class Tag(sifter.grammar.Validator):
+class Tag(Validator):
 
-    def __init__(self, allowed_tags: Optional[Union[Text, bytes, Tuple[Union[Text, bytes], ...]]] = None, tag_arg_validators=None) -> None:
+    def __init__(self, allowed_tags: Optional[Union[Text, bytes, Tuple[Union[Text, bytes], ...]]] = None, tag_arg_validators: Optional[Tuple[Validator, ...]] = None) -> None:
+        self.tag_arg_validators: Tuple[Validator, ...]
         super(Tag, self).__init__()
         self.allowed_tags: Optional[Union[Text, bytes, Tuple[Union[Text, bytes], ...]]] = None
         if isinstance(allowed_tags, (str, bytes)):
@@ -26,10 +31,10 @@ def __init__(self, allowed_tags: Optional[Union[Text, bytes, Tuple[Union[Text, b
         else:
             self.tag_arg_validators = tag_arg_validators
 
-    def validate(self, arg_list: sifter.grammar.Tag, starting_index) -> int:
+    def validate(self, arg_list: List[tag.Tag], starting_index: int) -> Optional[int]:
         if starting_index >= len(arg_list):
             return 0
-        if not isinstance(arg_list[starting_index], sifter.grammar.Tag):
+        if not isinstance(arg_list[starting_index], tag.Tag):
             return 0
 
         if self.allowed_tags is not None:
@@ -61,20 +66,21 @@ class Comparator(Tag):
     def __init__(self) -> None:
         super(Comparator, self).__init__(
             ('COMPARATOR',),
-            (sifter.validators.StringList(1),),
+            (StringList(1),),
         )
 
-    def validate(self, arg_list, starting_index):
+    def validate(self, arg_list: List[tag.Tag], starting_index: int) -> Optional[int]:
         validated_args = super(Comparator, self).validate(
             arg_list,
             starting_index
         )
-        if validated_args > 0:
+        if validated_args and validated_args > 0:
             if not sifter.handler.get(
                 'comparator',
                 arg_list[starting_index + 1][0],
             ):
-                raise sifter.grammar.RuleSyntaxError(
+                raise RuleSyntaxError(
                     "'%s' comparator is unknown/unsupported"
                     % arg_list[starting_index + 1][0]
                 )
+        return None