Add type hints for robot.model.keywords (#4723)

Co-authored-by: serhiy <serhiy.pikho@jitsuin.com>

src/robot/model/keyword.py

@@ -13,11 +13,17 @@
 #  See the License for the specific language governing permissions and
 #  limitations under the License.
 
+from typing import Sequence, TYPE_CHECKING, Type
 import warnings
 
 from .body import Body, BodyItem
 from .itemlist import ItemList
 
+if TYPE_CHECKING:
+    from robot.model.testcase import TestCase
+    from robot.model.testsuite import TestSuite
+    from robot.model.visitor import SuiteVisitor
+
 
 @Body.register
 class Keyword(BodyItem):
@@ -29,43 +35,45 @@ class Keyword(BodyItem):
     repr_args = ('name', 'args', 'assign')
     __slots__ = ['_name', 'args', 'assign', 'type']
 
-    def __init__(self, name='', args=(), assign=(), type=BodyItem.KEYWORD, parent=None):
+    def __init__(self, name: str = '', args: Sequence[str] = (),
+                 assign: Sequence[str] = (), type: str = BodyItem.KEYWORD,
+                 parent: 'TestSuite|TestCase|BodyItem|None' = None):
         self._name = name
         self.args = args
         self.assign = assign
         self.type = type
         self.parent = parent
 
     @property
-    def name(self):
+    def name(self) -> str:
         return self._name
 
     @name.setter
-    def name(self, name):
+    def name(self, name: str):
         self._name = name
 
-    def visit(self, visitor):
+    def visit(self, visitor: 'SuiteVisitor'):
         """:mod:`Visitor interface <robot.model.visitor>` entry-point."""
         if self:
             visitor.visit_keyword(self)
 
-    def __bool__(self):
+    def __bool__(self) -> bool:
         return self.name is not None
 
-    def __str__(self):
+    def __str__(self) -> str:
         parts = list(self.assign) + [self.name] + list(self.args)
         return '    '.join(str(p) for p in parts)
 
-    def to_dict(self):
-        data = {'name': self.name}
+    def to_dict(self) -> dict:
+        data: 'dict[str,list|str]' =  {'name': self.name}
         if self.args:
             data['args'] = list(self.args)
         if self.assign:
             data['assign'] = list(self.assign)
         return data
 
 
-class Keywords(ItemList):
+class Keywords(ItemList[Keyword]):
     """A list-like object representing keywords in a suite, a test or a keyword.
 
     Read-only and deprecated since Robot Framework 4.0.
@@ -76,14 +84,15 @@ class Keywords(ItemList):
         "Use 'body', 'setup' or 'teardown' instead."
     )
 
-    def __init__(self, parent=None, keywords=None):
+    def __init__(self, parent: 'TestSuite|None' = None,
+                 keywords: 'Sequence[Keyword]|Keywords' = ()):
         warnings.warn(self.deprecation_message, UserWarning)
         ItemList.__init__(self, object, {'parent': parent})
         if keywords:
             ItemList.extend(self, keywords)
 
     @property
-    def setup(self):
+    def setup(self) -> 'Keyword|None':
         return self[0] if (self and self[0].type == 'SETUP') else None
 
     @setup.setter
@@ -94,51 +103,51 @@ def create_setup(self, *args, **kwargs):
         self.raise_deprecation_error()
 
     @property
-    def teardown(self):
+    def teardown(self) -> 'Keyword|None':
         return self[-1] if (self and self[-1].type == 'TEARDOWN') else None
 
     @teardown.setter
-    def teardown(self, kw):
+    def teardown(self, kw: Keyword):
         self.raise_deprecation_error()
 
     def create_teardown(self, *args, **kwargs):
         self.raise_deprecation_error()
 
     @property
-    def all(self):
+    def all(self) -> 'Keywords':
         """Iterates over all keywords, including setup and teardown."""
         return self
 
     @property
-    def normal(self):
+    def normal(self) -> 'list[Keyword]':
         """Iterates over normal keywords, omitting setup and teardown."""
         return [kw for kw in self if kw.type not in ('SETUP', 'TEARDOWN')]
 
-    def __setitem__(self, index, item):
+    def __setitem__(self, index: int, item: Keyword):
         self.raise_deprecation_error()
 
     def create(self, *args, **kwargs):
         self.raise_deprecation_error()
 
-    def append(self, item):
+    def append(self, item: Keyword):
         self.raise_deprecation_error()
 
-    def extend(self, items):
+    def extend(self, items: Sequence[Keyword]):
         self.raise_deprecation_error()
 
-    def insert(self, index, item):
+    def insert(self, index: int, item: Keyword):
         self.raise_deprecation_error()
 
-    def pop(self, *index):
+    def pop(self, *index: int):
         self.raise_deprecation_error()
 
-    def remove(self, item):
+    def remove(self, item: Keyword):
         self.raise_deprecation_error()
 
     def clear(self):
         self.raise_deprecation_error()
 
-    def __delitem__(self, index):
+    def __delitem__(self, index: int):
         self.raise_deprecation_error()
 
     def sort(self):
@@ -148,5 +157,5 @@ def reverse(self):
         self.raise_deprecation_error()
 
     @classmethod
-    def raise_deprecation_error(cls):
+    def raise_deprecation_error(cls: 'Type[Keywords]'):
         raise AttributeError(cls.deprecation_message)