Merge pull request #2254 from strictdoc-project/stanislaw/nodes_migration

Code climate: query_engine: query_object: fix all mypy issues

Author: stanislaw

.link_health.yml

@@ -27,3 +27,4 @@ exceptions:
   - url: https://github.com/fcurella/python-datauri/blob/master/LICENSE
   - url: https://github.com/tree-sitter/tree-sitter/blob/master/LICENSE
   - url: https://github.com/doorstop-dev/doorstop/blob/804153c67c7c5466ee94e9553118cc3df03a56f9/reqs/REQ001.yml
+  - url: https://github.com/tiangolo/fastapi/blob/master/LICENSE

strictdoc/core/query_engine/query_object.py

@@ -1,8 +1,11 @@
-# mypy: disable-error-code="no-any-return,no-untyped-call,no-untyped-def,union-attr,operator"
-from typing import List, Optional
+from typing import Any, List, Optional
 
 from strictdoc.backend.sdoc.models.document import SDocDocument
-from strictdoc.backend.sdoc.models.document_grammar import GrammarElement
+from strictdoc.backend.sdoc.models.document_grammar import (
+    DocumentGrammar,
+    GrammarElement,
+)
+from strictdoc.backend.sdoc.models.model import SDocElementIF
 from strictdoc.backend.sdoc.models.node import SDocNode, SDocNodeField
 from strictdoc.backend.sdoc.models.section import SDocSection
 from strictdoc.core.traceability_index import TraceabilityIndex
@@ -14,123 +17,125 @@ class Expression:
 
 
 class StringExpression:
-    def __init__(self, parent, string: str):
-        self.parent = parent
+    def __init__(self, parent: Any, string: str):
+        self.parent: Any = parent
         self.string: str = string
 
 
 class NoneExpression:
-    def __init__(self, parent, _: str):
-        self.parent = parent
+    def __init__(self, parent: Any, _: str):
+        self.parent: Any = parent
 
 
 class NodeFieldExpression:
-    def __init__(self, parent, field_name: str):
-        self.parent = parent
+    def __init__(self, parent: Any, field_name: str):
+        self.parent: Any = parent
         self.field_name = field_name
 
 
 class NodeContainsExpression:
-    def __init__(self, parent, string: str):
-        self.parent = parent
+    def __init__(self, parent: Any, string: str):
+        self.parent: Any = parent
         self.string: str = string
 
 
 class NodeHasParentRequirementsExpression:
-    def __init__(self, parent, _):
-        self.parent = parent
+    def __init__(self, parent: Any, _: Any) -> None:
+        self.parent: Any = parent
 
 
 class NodeContainsAnyFreeTextExpression:
-    def __init__(self, parent, _):
-        self.parent = parent
+    def __init__(self, parent: Any, _: Any):
+        self.parent: Any = parent
 
 
 class NodeHasChildRequirementsExpression:
-    def __init__(self, parent, _):
-        self.parent = parent
+    def __init__(self, parent: Any, _: Any):
+        self.parent: Any = parent
 
 
 class NodeIsRequirementExpression:
-    def __init__(self, parent, _):
-        self.parent = parent
+    def __init__(self, parent: Any, _: Any):
+        self.parent: Any = parent
 
 
 class NodeIsSectionExpression:
-    def __init__(self, parent, _):
-        self.parent = parent
+    def __init__(self, parent: Any, _: Any):
+        self.parent: Any = parent
 
 
 class NodeIsRootExpression:
-    def __init__(self, parent, _):
-        self.parent = parent
+    def __init__(self, parent: Any, _: Any):
+        self.parent: Any = parent
 
 
 class EqualExpression:
-    def __init__(self, parent, lhs_expr: Expression, rhs_expr: Expression):
-        self.parent = parent
+    def __init__(self, parent: Any, lhs_expr: Expression, rhs_expr: Expression):
+        self.parent: Any = parent
         self.lhs_expr: Expression = lhs_expr
         self.rhs_expr: Expression = rhs_expr
 
 
 class AndExpression:
-    def __init__(self, parent, expressions: List[Expression]):
-        self.parent = parent
+    def __init__(self, parent: Any, expressions: List[Expression]):
+        self.parent: Any = parent
         self.expressions: List[Expression] = expressions
 
 
 class OrExpression:
-    def __init__(self, parent, expressions: List[Expression]):
-        self.parent = parent
+    def __init__(self, parent: Any, expressions: List[Expression]):
+        self.parent: Any = parent
         self.expressions: List[Expression] = expressions
 
 
 class NotExpression:
-    def __init__(self, parent, expression: Expression):
-        self.parent = parent
+    def __init__(self, parent: Any, expression: Expression):
+        self.parent: Any = parent
         self.expression: Expression = expression
 
 
 class NotEqualExpression:
-    def __init__(self, parent, lhs_expr: Expression, rhs_expr: Expression):
-        self.parent = parent
+    def __init__(self, parent: Any, lhs_expr: Expression, rhs_expr: Expression):
+        self.parent: Any = parent
         self.lhs_expr: Expression = lhs_expr
         self.rhs_expr: Expression = rhs_expr
 
 
 class InExpression:
-    def __init__(self, parent, lhs_expr: Expression, rhs_expr: Expression):
-        self.parent = parent
+    def __init__(self, parent: Any, lhs_expr: Expression, rhs_expr: Expression):
+        self.parent: Any = parent
         self.lhs_expr: Expression = lhs_expr
         self.rhs_expr: Expression = rhs_expr
 
 
 class NotInExpression:
-    def __init__(self, parent, lhs_expr: Expression, rhs_expr: Expression):
-        self.parent = parent
+    def __init__(self, parent: Any, lhs_expr: Expression, rhs_expr: Expression):
+        self.parent: Any = parent
         self.lhs_expr: Expression = lhs_expr
         self.rhs_expr: Expression = rhs_expr
 
 
 class Query:
-    def __init__(self, root_expression):
-        self.root_expression = root_expression
+    def __init__(self, root_expression: Any):
+        self.root_expression: Any = root_expression
 
 
 class QueryNullObject:
-    def evaluate(self, _) -> bool:
+    def evaluate(self, _: Any) -> bool:
         return True
 
 
 class QueryObject:
-    def __init__(self, query: Query, traceability_index: TraceabilityIndex):
+    def __init__(
+        self, query: Query, traceability_index: TraceabilityIndex
+    ) -> None:
         self.query: Query = query
         self.traceability_index: TraceabilityIndex = traceability_index
 
-    def evaluate(self, node) -> bool:
+    def evaluate(self, node: SDocElementIF) -> bool:
         return self._evaluate(node, self.query.root_expression)
 
-    def _evaluate(self, node, expression) -> bool:
+    def _evaluate(self, node: SDocElementIF, expression: Any) -> bool:
         if isinstance(expression, EqualExpression):
             return self._evaluate_equal(node, expression)
         if isinstance(expression, NotEqualExpression):
@@ -150,7 +155,11 @@ def _evaluate(self, node, expression) -> bool:
         if isinstance(expression, NodeIsSectionExpression):
             return isinstance(node, SDocSection)
         if isinstance(expression, NodeIsRootExpression):
-            return node.is_root
+            if isinstance(node, SDocNode):
+                return node.is_root
+            raise RuntimeError(
+                "The node.is_root expression can be only called on nodes."
+            )
         if isinstance(expression, NotExpression):
             return not self._evaluate(node, expression.expression)
         if isinstance(expression, AndExpression):
@@ -164,30 +173,40 @@ def _evaluate(self, node, expression) -> bool:
                     return True
             return False
         if isinstance(expression, InExpression):
-            rhs_value = self._evaluate_value(node, expression.rhs_expr)
-            if rhs_value is None:
-                return False
-            return self._evaluate_value(node, expression.lhs_expr) in rhs_value
+            if (
+                rhs_value := self._evaluate_value(node, expression.rhs_expr)
+            ) is not None and (
+                lhs_value := self._evaluate_value(node, expression.lhs_expr)
+            ) is not None:
+                return lhs_value in rhs_value
+            return False
         if isinstance(expression, NotInExpression):
-            rhs_value = self._evaluate_value(node, expression.rhs_expr)
-            if rhs_value is None:
-                return False
-            return (
-                self._evaluate_value(node, expression.lhs_expr) not in rhs_value
-            )
+            if (
+                rhs_value := self._evaluate_value(node, expression.rhs_expr)
+            ) is not None and (
+                lhs_value := self._evaluate_value(node, expression.lhs_expr)
+            ) is not None:
+                return lhs_value not in rhs_value
+            return False
         assert 0, expression
 
-    def _evaluate_equal(self, node, expression: EqualExpression) -> bool:
+    def _evaluate_equal(
+        self, node: SDocElementIF, expression: EqualExpression
+    ) -> bool:
         return self._evaluate_value(
             node, expression.lhs_expr
         ) == self._evaluate_value(node, expression.rhs_expr)
 
-    def _evaluate_not_equal(self, node, expression: NotEqualExpression) -> bool:
+    def _evaluate_not_equal(
+        self, node: SDocElementIF, expression: NotEqualExpression
+    ) -> bool:
         return self._evaluate_value(
             node, expression.lhs_expr
         ) != self._evaluate_value(node, expression.rhs_expr)
 
-    def _evaluate_value(self, node, expression) -> Optional[str]:
+    def _evaluate_value(
+        self, node: SDocElementIF, expression: Any
+    ) -> Optional[str]:
         if isinstance(expression, NodeFieldExpression):
             return self._evaluate_node_field_expression(node, expression)
         if isinstance(expression, StringExpression):
@@ -197,27 +216,34 @@ def _evaluate_value(self, node, expression) -> Optional[str]:
         assert 0, expression
 
     def _evaluate_node_field_expression(
-        self, node, expression: NodeFieldExpression
+        self,
+        node: SDocElementIF,
+        expression: NodeFieldExpression,
     ) -> Optional[str]:
         field_name = expression.field_name
-        if node.is_requirement() and node.node_type == "REQUIREMENT":
+        if (
+            isinstance(node, SDocNode)
+            and node.is_requirement()
+            and node.node_type == "REQUIREMENT"
+        ):
             requirement: SDocNode = assert_cast(node, SDocNode)
             requirement_document: SDocDocument = assert_cast(
                 requirement.get_document(), SDocDocument
             )
-            element: GrammarElement = (
-                requirement_document.grammar.elements_by_type[
-                    requirement.node_type
-                ]
+            document_grammar: DocumentGrammar = assert_cast(
+                requirement_document.grammar, DocumentGrammar
             )
+            element: GrammarElement = document_grammar.elements_by_type[
+                requirement.node_type
+            ]
             grammar_field_titles = list(map(lambda f: f.title, element.fields))
             if field_name not in grammar_field_titles:
                 return None
             field_value = requirement._get_cached_field(field_name, False)
             if field_value is not None:
                 return field_value
             return None
-        elif node.is_section():
+        elif isinstance(node, SDocSection) and node.is_section():
             section: SDocSection = assert_cast(node, SDocSection)
             if field_name == "UID":
                 return section.reserved_uid
@@ -227,7 +253,9 @@ def _evaluate_node_field_expression(
         else:
             raise NotImplementedError  # pragma: no cover
 
-    def _evaluate_node_has_parent_requirements(self, node) -> bool:
+    def _evaluate_node_has_parent_requirements(
+        self, node: SDocElementIF
+    ) -> bool:
         if not isinstance(node, SDocNode):
             raise TypeError(
                 f"node.has_parent_requirements can be only called on "
@@ -236,7 +264,9 @@ def _evaluate_node_has_parent_requirements(self, node) -> bool:
             )
         return self.traceability_index.has_parent_requirements(node)
 
-    def _evaluate_node_has_child_requirements(self, node) -> bool:
+    def _evaluate_node_has_child_requirements(
+        self, node: SDocElementIF
+    ) -> bool:
         if not isinstance(node, SDocNode):
             raise TypeError(
                 f"node.has_child_requirements can be only called on "
@@ -246,7 +276,9 @@ def _evaluate_node_has_child_requirements(self, node) -> bool:
         return self.traceability_index.has_children_requirements(node)
 
     def _evaluate_node_contains(
-        self, node, expression: NodeContainsExpression
+        self,
+        node: SDocElementIF,
+        expression: NodeContainsExpression,
     ) -> bool:
         if isinstance(node, SDocNode):
             requirement = assert_cast(node, SDocNode)
@@ -262,7 +294,7 @@ def _evaluate_node_contains(
             return False
         raise NotImplementedError  # pragma: no cover
 
-    def _evaluate_node_contains_any_text(self, node) -> bool:
+    def _evaluate_node_contains_any_text(self, node: SDocElementIF) -> bool:
         if not isinstance(node, SDocSection):
             raise TypeError(
                 f"node.contains_any_text can be only called on "