Fix typing issues detected by mypy

Author: idle-code

contextshell/Action.py

@@ -5,7 +5,7 @@
 
 
 class Action(ABC):
-    def __init__(self, name: NodePath):
+    def __init__(self, name: NodePath) -> None:
         assert isinstance(name, NodePath)
         assert name.is_relative
         self.name: NodePath = name

contextshell/CallableAction.py

@@ -6,7 +6,7 @@
 
 
 class CallableAction(Action):
-    def __init__(self, implementation: Callable, name: NodePath):
+    def __init__(self, implementation: Callable, name: NodePath) -> None:
         super().__init__(name)
         self.implementation = implementation
 

contextshell/CommandInterpreter.py

@@ -5,7 +5,7 @@
 
 
 class CommandInterpreter:
-    def __init__(self, tree: TreeRoot):
+    def __init__(self, tree: TreeRoot) -> None:
         self.tree = tree
 
     def execute(self, command: Command):
@@ -17,8 +17,8 @@ def execute(self, command: Command):
         target_path = NodePath.cast(target_path)
         action_path = NodePath.cast(self._evaluate(command.name))
         arguments = list(map(self._evaluate, command.arguments))
-        arguments = parse_argument_tree(arguments)
-        return self.tree.execute(target_path, action_path, arguments)
+        packed_arguments = parse_argument_tree(arguments)
+        return self.tree.execute(target_path, action_path, packed_arguments)
 
     def _evaluate(self, part):
         if isinstance(part, Command):

contextshell/CommandParser.py

@@ -1,5 +1,5 @@
 from contextshell.Command import Command
-from typing import List
+from typing import List, Optional
 
 
 def convert_token_type(token):
@@ -55,7 +55,7 @@ class CommandParser:
     def __init__(self):
         self._root_scope = None
 
-    def parse(self, command_line: str) -> Command:
+    def parse(self, command_line: str) -> Optional[Command]:
         tokens = tokenize(command_line)
         if len(tokens) == 0:
             return None  # ignore empty lines

contextshell/Node.py

@@ -1,3 +1,6 @@
+from typing import Optional
+
+
 class Node:
     def __init__(self, value=None):
         self._value = value
@@ -41,7 +44,7 @@ def append(self, node, name: str=None):
         node._parent = self
         self._subnodes.append((name, node))
 
-    def get_node(self, name: str=None, index: int=None) -> 'Node':
+    def get_node(self, name: str=None, index: int=None) -> Optional['Node']:
         """Return subnode with provided name or index"""
         if name is not None:
             for p in self._subnodes:

contextshell/NodePath.py

@@ -92,11 +92,11 @@ def _parse_path(self, text):
         new_path = map(NodePath._to_path_part, [part for part in text.split(NodePath.separator) if len(part) > 0])
         self.extend(new_path)
 
-    def __eq__(self, other: 'NodePath'):
+    def __eq__(self, other):
         other = NodePath.cast(other)
         return self.is_absolute == other.is_absolute and self[:] == other[:]
 
-    def __ne__(self, other: 'NodePath'):
+    def __ne__(self, other):
         return not (self == other)
 
     def __str__(self):

contextshell/NodeTreeRoot.py

@@ -89,7 +89,7 @@ def _is_action_implementation(self, node_value) -> bool:
     # def install_type(self, type: NodeType):
     #     raise NotImplementedError()
 
-    def is_attribute(self, path: NodePath):
+    def is_attribute(self, path: str): # FIXME: is used?
         return path.startswith('@')
 
     def list_actions(self, path: NodePath) -> List[NodePath]:
@@ -149,11 +149,12 @@ def _resolve_path(self, path: NodePath, root: Node = None) -> Node:
             raise NameError("'{}' doesn't exists".format(path))
         return node
 
-    def _resolve_optional_path(self, path: NodePath, root: Node=None) -> Node:
+    def _resolve_optional_path(self, path: NodePath, root: Node=None) -> Optional[Node]:
         if root is None:
             if path.is_relative:
                 raise ValueError("Could not resolve relative paths")
             root = self.root
+            assert root is not None
         if len(path) == 0:
             return root
 
@@ -167,6 +168,7 @@ def _create_path(self, path: NodePath, root: Node = None) -> Node:
             if path.is_relative:
                 raise ValueError("Could not resolve relative paths")
             root = self.root
+            assert root is not None
         if len(path) == 0:
             return root
 

contextshell/Shell.py

@@ -1,6 +1,7 @@
 from contextshell.CommandParser import CommandParser
 from contextshell.NodePath import *
 from contextshell.CommandInterpreter import CommandInterpreter
+from typing import Optional
 
 
 class Shell:
@@ -9,7 +10,7 @@ def __init__(self, interpreter):
         self.interpreter = interpreter
         self.parser = CommandParser()
 
-    def execute(self, command_line: str) -> str:
+    def execute(self, command_line: str) -> Optional[str]:
         command = self.parser.parse(command_line)
         if command is None:
             return None
@@ -22,7 +23,7 @@ def execute(self, command_line: str) -> str:
         except Exception as error:
             return self.format_error(error)
 
-    def format_result(self, result) -> str:
+    def format_result(self, result) -> Optional[str]:
         if result is None:
             return None
         if isinstance(result, list):

contextshell/TreeRoot.py

@@ -14,19 +14,19 @@ def execute(self, target: NodePath, action: NodePath, args: ActionArgsPack):
 
 def unpack_argument_tree(action_args: ActionArgsPack) -> Tuple[List[Any], Dict[str, Any]]:
     args = dict()
-    kwargs = OrderedDict()
+    kwargs: Dict[str, Any] = OrderedDict()
     for key, value in action_args.items():
         if isinstance(key, int):
             args[key] = value
         else:
             kwargs[key.to_python_name()] = value
     assert len(args) == 0 or max(args.keys()) < len(args)+len(kwargs)
-    args = [a[1] for a in sorted(args.items())]
-    return args, kwargs
+    positional_args = [a[1] for a in sorted(args.items())]
+    return positional_args, kwargs
 
 
 def pack_argument_tree(args: List[Any], kwargs: Dict[str, Any]) -> ActionArgsPack:
-    pack_list = []
+    pack_list: List[Tuple[Union[NodePath, int], Any]] = []
     for i, arg in enumerate(args):
         pack_list.append((i, arg))
     for key, value in kwargs.items():
@@ -36,7 +36,7 @@ def pack_argument_tree(args: List[Any], kwargs: Dict[str, Any]) -> ActionArgsPac
 
 def parse_argument_tree(raw_arguments: List[str]) -> ActionArgsPack:
     from contextshell.CommandParser import convert_token_type
-    pack_list = []
+    pack_list: List[Tuple[Union[NodePath, int], Any]] = []
     for i, arg in enumerate(raw_arguments):
         if isinstance(arg, str) and '=' in arg:
             key, value = arg.split('=')