added type hints

Author: manfred-kaiser

sifter/grammar/comparator.py

@@ -1,3 +1,8 @@
+from typing import (
+    Optional,
+    Text
+)
+
 import re
 import sifter.comparator
 
@@ -7,6 +12,8 @@
 # The official definition of comparators is in RFC 4790
 class Comparator(object):
 
+    COMPARATOR_ID: Optional[Text] = None
+
     @classmethod
     def register(cls) -> None:
         try:

sifter/grammar/grammar.py

@@ -1,7 +1,12 @@
 # Parser based on RFC 5228, especially the grammar as defined in section 8. All
 # references are to sections in RFC 5228 unless stated otherwise.
 
-import ply.yacc
+from typing import (
+    TYPE_CHECKING,
+    Any
+)
+
+import ply.yacc  # type: ignore
 
 import sifter.grammar
 from sifter.grammar.tag import Tag
@@ -10,14 +15,17 @@
 from sifter.grammar.string import String
 import sifter.handler
 
+if TYPE_CHECKING:
+    from py.yacc import LRParser, YaccProduction  # type: ignore
+
 __all__ = ('parser',)
 
 
-def parser(**kwargs):
+def parser(**kwargs: Any) -> 'LRParser':
     return ply.yacc.yacc(**kwargs)
 
 
-def p_commands_list(p):
+def p_commands_list(p: 'YaccProduction') -> None:
     """commands : commands command"""
     p[0] = p[1]
 
@@ -39,12 +47,12 @@ def p_commands_list(p):
     p[0].commands.append(p[2])
 
 
-def p_commands_empty(p):
+def p_commands_empty(p: 'YaccProduction') -> None:
     """commands : """
     p[0] = CommandList()
 
 
-def p_command(p):
+def p_command(p: 'YaccProduction') -> None:
     """command : IDENTIFIER arguments ';'
                | IDENTIFIER arguments block"""
     # print("COMMAND:", p[1], p[2], p[3])
@@ -59,14 +67,14 @@ def p_command(p):
     p[0] = handler(arguments=p[2]['args'], tests=tests, block=block)
 
 
-def p_command_error(p):
+def p_command_error(p: 'YaccProduction') -> None:
     """command : IDENTIFIER error ';'
                | IDENTIFIER error block"""
     print("Syntax error in command definition after %s on line %d" % (p[1], p.lineno(1)))
     raise SyntaxError
 
 
-def p_block(p):
+def p_block(p: 'YaccProduction') -> None:
     """block : '{' commands '}' """
     # section 3.2: REQUIRE command must come before any other commands,
     # which means it can't be in the block of another command
@@ -77,13 +85,13 @@ def p_block(p):
     p[0] = p[2]
 
 
-def p_block_error(p):
+def p_block_error(p: 'YaccProduction') -> None:
     """block : '{' error '}'"""
     print("Syntax error in command block that starts on line %d" % (p.lineno(1),))
     raise SyntaxError
 
 
-def p_arguments(p):
+def p_arguments(p: 'YaccProduction') -> None:
     """arguments : argumentlist
                  | argumentlist test
                  | argumentlist '(' testlist ')'"""
@@ -95,24 +103,24 @@ def p_arguments(p):
             p[0]['tests'] = [p[2]]
 
 
-def p_testlist_error(p):
+def p_testlist_error(p: 'YaccProduction') -> None:
     """arguments : argumentlist '(' error ')'"""
     print("Syntax error in test list that starts on line %d" % p.lineno(2))
     raise SyntaxError
 
 
-def p_argumentlist_list(p):
+def p_argumentlist_list(p: 'YaccProduction') -> None:
     """argumentlist : argumentlist argument"""
     p[0] = p[1]
     p[0].append(p[2])
 
 
-def p_argumentlist_empty(p):
+def p_argumentlist_empty(p: 'YaccProduction') -> None:
     """argumentlist : """
     p[0] = []
 
 
-def p_test(p):
+def p_test(p: 'YaccProduction') -> None:
     """test : IDENTIFIER arguments"""
     # print("TEST:", p[1], p[2])
     tests = p[2].get('tests')
@@ -123,55 +131,55 @@ def p_test(p):
     p[0] = handler(arguments=p[2]['args'], tests=tests)
 
 
-def p_testlist_list(p):
+def p_testlist_list(p: 'YaccProduction') -> None:
     """testlist : test ',' testlist"""
     p[0] = p[3]
     p[0].insert(0, p[1])
 
 
-def p_testlist_single(p):
+def p_testlist_single(p: 'YaccProduction') -> None:
     """testlist : test"""
     p[0] = [p[1]]
 
 
-def p_argument_stringlist(p):
+def p_argument_stringlist(p: 'YaccProduction') -> None:
     """argument : '[' stringlist ']'"""
     p[0] = p[2]
 
 
-def p_argument_string(p):
+def p_argument_string(p: 'YaccProduction') -> None:
     """argument : string"""
     # for simplicity, we treat all single strings as a string list
     p[0] = [p[1]]
 
 
-def p_argument_number(p):
+def p_argument_number(p: 'YaccProduction') -> None:
     """argument : NUMBER"""
     p[0] = p[1]
 
 
-def p_argument_tag(p):
+def p_argument_tag(p: 'YaccProduction') -> None:
     """argument : TAG"""
     p[0] = Tag(p[1])
 
 
-def p_stringlist_error(p):
+def p_stringlist_error(p: 'YaccProduction') -> None:
     """argument : '[' error ']'"""
     print("Syntax error in string list that starts on line %d" % p.lineno(1))
     raise SyntaxError
 
 
-def p_stringlist_list(p):
+def p_stringlist_list(p: 'YaccProduction') -> None:
     """stringlist : string ',' stringlist"""
     p[0] = p[3]
     p[0].insert(0, p[1])
 
 
-def p_stringlist_single(p):
+def p_stringlist_single(p: 'YaccProduction') -> None:
     """stringlist : string"""
     p[0] = [p[1]]
 
 
-def p_string(p):
+def p_string(p: 'YaccProduction') -> None:
     """string : QUOTED_STRING"""
     p[0] = String(p[1])

sifter/grammar/lexer.py

@@ -2,7 +2,7 @@
 # references are to sections in RFC 5228 unless stated otherwise.
 
 import math
-import ply.lex
+import ply.lex  # type: ignore
 
 __all__ = ('lexer', 'tokens',)
 

sifter/t/run_tests.py

@@ -1,3 +1,5 @@
+# type: ignore
+
 import unittest
 
 if __name__ == '__main__':

sifter/t/test_comparators.py

@@ -1,3 +1,5 @@
+# type: ignore
+
 import unittest
 
 import sifter.comparator

sifter/t/test_evaluation.py

@@ -1,3 +1,5 @@
+# type: ignore
+
 import email
 import os.path
 import unittest

sifter/t/test_grammar.py

@@ -1,15 +1,17 @@
+# type: ignore
+
 import unittest
 
 import sifter.extension
-import sifter.grammar
+from sifter.grammar.state import EvaluationState
 
 
 class TestEvaluationState(unittest.TestCase):
 
     def setUp(self) -> None:
         sifter.extension.register('ext1')
         sifter.extension.register('ext2')
-        self.state = sifter.grammar.EvaluationState()
+        self.state = EvaluationState()
 
     def test_require_extension(self) -> None:
         self.state.require_extension('ext1')

sifter/t/test_parser.py

@@ -1,3 +1,5 @@
+# type: ignore
+
 import os.path
 import unittest
 import codecs

sifter/t/test_validators.py

@@ -1,7 +1,12 @@
+# type: ignore
+
 import unittest
 
-from sifter.grammar.rule import Rule
-import sifter.validators
+from sifter.grammar.tag import Tag as GrammarTag
+from sifter.grammar.rule import Rule, RuleSyntaxError
+from sifter.validators.number import Number
+from sifter.validators.stringlist import StringList
+from sifter.validators.tag import Tag as TagValidator
 
 
 class MockRule(Rule):
@@ -16,54 +21,54 @@ def __init__(self, arguments=None, tests=None):
 class TestValidationFn(unittest.TestCase):
 
     def test_too_many_args(self) -> None:
-        mock_rule = MockRule([sifter.grammar.Tag('IS'), 13, ])
+        mock_rule = MockRule([GrammarTag('IS'), 13, ])
         self.assertRaises(
-            sifter.grammar.RuleSyntaxError,
+            RuleSyntaxError,
             mock_rule.validate_arguments,
         )
 
     def test_not_enough_args(self) -> None:
         mock_rule = MockRule([13, ])
         self.assertRaises(
-            sifter.grammar.RuleSyntaxError,
+            RuleSyntaxError,
             mock_rule.validate_arguments,
             [
-                sifter.validators.Number(),
-                sifter.validators.StringList(),
+                Number(),
+                StringList(),
             ],
         )
 
 
 class TestTagValidator(unittest.TestCase):
 
     def test_allowed_tag(self) -> None:
-        mock_validator = sifter.validators.Tag(['MOCK', 'IS', ])
+        mock_validator = TagValidator(['MOCK', 'IS', ])
         self.assertEqual(
-            mock_validator.validate([sifter.grammar.Tag('IS')], 0),
+            mock_validator.validate([GrammarTag('IS')], 0),
             1
         )
 
     def test_allowed_single_tag(self) -> None:
         # test the case for a non-list single tag name
-        mock_validator = sifter.validators.Tag('IS')
+        mock_validator = TagValidator('IS')
         self.assertEqual(
-            mock_validator.validate([sifter.grammar.Tag('IS')], 0),
+            mock_validator.validate([GrammarTag('IS')], 0),
             1
         )
 
     def test_not_allowed_tag(self) -> None:
-        mock_validator = sifter.validators.Tag(['MOCK', 'FOO', ])
+        mock_validator = TagValidator(['MOCK', 'FOO', ])
         self.assertEqual(
-            mock_validator.validate([sifter.grammar.Tag('IS')], 0),
+            mock_validator.validate([GrammarTag('IS')], 0),
             0
         )
 
     def test_not_allowed_single_tag(self) -> None:
         # test the case for a non-list single tag name. test when the tag is a
         # substring of the allowed tag.
-        mock_validator = sifter.validators.Tag('ISFOO')
+        mock_validator = TagValidator('ISFOO')
         self.assertEqual(
-            mock_validator.validate([sifter.grammar.Tag('IS')], 0),
+            mock_validator.validate([GrammarTag('IS')], 0),
             0
         )