robotcode-robot 0.95.0__tar.gz → 0.95.1__tar.gz

{robotcode_robot-0.95.0 → robotcode_robot-0.95.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: robotcode-robot
-Version: 0.95.0
+Version: 0.95.1
 Summary: Support classes for RobotCode for handling Robot Framework projects.
 Project-URL: Homepage, https://robotcode.io
 Project-URL: Donate, https://opencollective.com/robotcode
@@ -26,7 +26,7 @@ Classifier: Topic :: Utilities
 Classifier: Typing :: Typed
 Requires-Python: >=3.8
 Requires-Dist: platformdirs<4.2.0,>=3.2.0
-Requires-Dist: robotcode-core==0.95.0
+Requires-Dist: robotcode-core==0.95.1
 Requires-Dist: robotframework>=4.1.0
 Requires-Dist: tomli>=1.1.0; python_version < '3.11'
 Description-Content-Type: text/markdown

{robotcode_robot-0.95.0 → robotcode_robot-0.95.1}/pyproject.toml

@@ -29,7 +29,7 @@ dependencies = [
   "robotframework>=4.1.0",
   "tomli>=1.1.0; python_version < '3.11'",
   "platformdirs>=3.2.0,<4.2.0",
-  "robotcode-core==0.95.0",
+  "robotcode-core==0.95.1",
 ]
 dynamic = ["version"]
 

robotcode_robot-0.95.1/src/robotcode/robot/__version__.py

@@ -0,0 +1 @@
+__version__ = "0.95.1"

{robotcode_robot-0.95.0 → robotcode_robot-0.95.1}/src/robotcode/robot/diagnostics/entities.py

@@ -145,10 +145,10 @@ class VariableMatcher:
         self.normalized_name = str(normalize(self.base))
 
     def __eq__(self, o: object) -> bool:
-        if isinstance(o, VariableMatcher):
+        if type(o) is VariableMatcher:
             return o.normalized_name == self.normalized_name
 
-        if isinstance(o, str):
+        if type(o) is str:
             match = search_variable(o, "$@&%", ignore_errors=True)
             base = match.base
             if base is None:

{robotcode_robot-0.95.0 → robotcode_robot-0.95.1}/src/robotcode/robot/diagnostics/keyword_finder.py

@@ -58,8 +58,8 @@ class KeywordFinder:
         ] = {}
 
         self._all_keywords: Optional[List[LibraryEntry]] = None
-        self._resource_keywords: Optional[List[ResourceEntry]] = None
-        self._library_keywords: Optional[List[LibraryEntry]] = None
+        self._resource_imports: Optional[List[ResourceEntry]] = None
+        self._library_imports: Optional[List[LibraryEntry]] = None
 
     def reset_diagnostics(self) -> None:
         self.diagnostics = []
@@ -312,23 +312,23 @@ class KeywordFinder:
         other: Tuple[Optional[LibraryEntry], KeywordDoc],
     ) -> bool:
         return (
-            other[1].matcher.embedded_arguments.match(candidate[1].name) is not None
+            other[1].matcher.embedded_arguments is not None
+            and candidate[1].matcher.embedded_arguments is not None
+            and other[1].matcher.embedded_arguments.match(candidate[1].name) is not None
             and candidate[1].matcher.embedded_arguments.match(other[1].name) is None
         )
 
     def _get_keyword_from_resource_files(self, name: str) -> Optional[KeywordDoc]:
-        if self._resource_keywords is None:
-            self._resource_keywords = list(chain(self.namespace._resources.values()))
+        if self._resource_imports is None:
+            self._resource_imports = list(chain(self.namespace._resources.values()))
 
         if get_robot_version() >= (6, 0):
-            found: List[Tuple[Optional[LibraryEntry], KeywordDoc]] = []
-            for v in self._resource_keywords:
-                r = v.library_doc.keywords.get_all(name)
-                if r:
-                    found.extend([(v, k) for k in r])
+            found: List[Tuple[Optional[LibraryEntry], KeywordDoc]] = [
+                (v, k) for v in self._resource_imports for k in v.library_doc.keywords.iter_all(name)
+            ]
         else:
             found = []
-            for k in self._resource_keywords:
+            for k in self._resource_imports:
                 s = k.library_doc.keywords.get(name, None)
                 if s is not None:
                     found.append((k, s))
@@ -373,19 +373,18 @@ class KeywordFinder:
         return entries
 
     def _get_keyword_from_libraries(self, name: str) -> Optional[KeywordDoc]:
-        if self._library_keywords is None:
-            self._library_keywords = list(chain(self.namespace._libraries.values()))
+        if self._library_imports is None:
+            self._library_imports = list(chain(self.namespace._libraries.values()))
 
         if get_robot_version() >= (6, 0):
-            found: List[Tuple[Optional[LibraryEntry], KeywordDoc]] = []
-            for v in self._library_keywords:
-                r = v.library_doc.keywords.get_all(name)
-                if r:
-                    found.extend([(v, k) for k in r])
+            found: List[Tuple[Optional[LibraryEntry], KeywordDoc]] = [
+                (v, k) for v in self._library_imports for k in v.library_doc.keywords.iter_all(name)
+            ]
+
         else:
             found = []
 
-            for k in self._library_keywords:
+            for k in self._library_imports:
                 s = k.library_doc.keywords.get(name, None)
                 if s is not None:
                     found.append((k, s))

{robotcode_robot-0.95.0 → robotcode_robot-0.95.1}/src/robotcode/robot/diagnostics/library_doc.py

@@ -76,12 +76,12 @@ from robotcode.robot.utils import get_robot_version
 from robotcode.robot.utils.ast import (
     cached_isinstance,
     get_variable_token,
+    iter_nodes,
     range_from_token,
     strip_variable_token,
 )
 from robotcode.robot.utils.markdownformatter import MarkDownFormatter
 from robotcode.robot.utils.match import normalize, normalize_namespace
-from robotcode.robot.utils.stubs import HasError, HasErrors
 
 from ..utils.variables import contains_variable
 
@@ -239,7 +239,11 @@ class KeywordMatcher:
         self._can_have_embedded = can_have_embedded and not is_namespace
         self._is_namespace = is_namespace
         self._normalized_name: Optional[str] = None
-        self._embedded_arguments: Any = None
+
+        self.embedded_arguments: Optional[EmbeddedArguments] = (
+            _get_embedded_arguments(self.name) or None if self._can_have_embedded else None
+        )
+        self._match_cache: Dict[str, bool] = {}
 
     @property
     def normalized_name(self) -> str:
@@ -248,28 +252,18 @@ class KeywordMatcher:
 
         return self._normalized_name
 
-    @property
-    def embedded_arguments(self) -> Any:
-        if self._embedded_arguments is None:
-            if self._can_have_embedded:
-                self._embedded_arguments = _get_embedded_arguments(self.name)
-            else:
-                self._embedded_arguments = ()
-
-        return self._embedded_arguments
-
     if get_robot_version() >= (6, 0):
 
         def __match_embedded(self, name: str) -> bool:
-            return self.embedded_arguments.match(name) is not None
+            return self.embedded_arguments is not None and self.embedded_arguments.match(name) is not None
 
     else:
 
         def __match_embedded(self, name: str) -> bool:
-            return self.embedded_arguments.name.match(name) is not None
+            return self.embedded_arguments is not None and self.embedded_arguments.name.match(name) is not None
 
     def __eq__(self, o: object) -> bool:
-        if cached_isinstance(o, KeywordMatcher):
+        if type(o) is KeywordMatcher:
             if self._is_namespace != o._is_namespace:
                 return False
 
@@ -278,7 +272,7 @@ class KeywordMatcher:
 
             o = o.name
 
-        if not cached_isinstance(o, str):
+        if type(o) is not str:
             return False
 
         if self.embedded_arguments:
@@ -667,13 +661,11 @@ class KeywordDoc(SourceEntity):
     def __str__(self) -> str:
         return f"{self.name}({', '.join(str(arg) for arg in self.arguments)})"
 
-    @property
+    @functools.cached_property
     def matcher(self) -> KeywordMatcher:
-        if not hasattr(self, "__matcher"):
-            self.__matcher = KeywordMatcher(self.name)
-        return self.__matcher
+        return KeywordMatcher(self.name)
 
-    @property
+    @functools.cached_property
     def is_deprecated(self) -> bool:
         return self.deprecated or DEPRECATED_PATTERN.match(self.doc) is not None
 
@@ -685,13 +677,13 @@ class KeywordDoc(SourceEntity):
     def is_library_keyword(self) -> bool:
         return self.libtype == "LIBRARY"
 
-    @property
+    @functools.cached_property
     def deprecated_message(self) -> str:
         if (m := DEPRECATED_PATTERN.match(self.doc)) is not None:
             return m.group("message").strip()
         return ""
 
-    @property
+    @functools.cached_property
     def name_range(self) -> Range:
         if self.name_token is not None:
             return range_from_token(self.name_token)
@@ -709,7 +701,7 @@ class KeywordDoc(SourceEntity):
 
         return "robot:private" in self.normalized_tags()
 
-    @property
+    @functools.cached_property
     def range(self) -> Range:
         if self.name_token is not None:
             return range_from_token(self.name_token)
@@ -820,7 +812,7 @@ class KeywordDoc(SourceEntity):
 
         return result
 
-    @property
+    @functools.cached_property
     def signature(self) -> str:
         return (
             f'({self.type}) "{self.name}": ('
@@ -919,19 +911,13 @@ class KeywordStore:
     source_type: Optional[str] = None
     keywords: List[KeywordDoc] = field(default_factory=list)
 
-    @property
-    def _matchers(self) -> Dict[KeywordMatcher, KeywordDoc]:
-        if not hasattr(self, "__matchers"):
-            self.__matchers = {v.matcher: v for v in self.keywords}
-        return self.__matchers
-
     def __getitem__(self, key: str) -> KeywordDoc:
-        items = [(k, v) for k, v in self._matchers.items() if k == key]
+        items = [v for v in self.keywords if v.matcher == key]
 
         if not items:
             raise KeyError
         if len(items) == 1:
-            return items[0][1]
+            return items[0]
 
         if self.source and self.source_type:
             file_info = ""
@@ -946,14 +932,14 @@ class KeywordStore:
         else:
             file_info = "File"
         error = [f"{file_info} contains multiple keywords matching name '{key}':"]
-        names = sorted(k.name for k, v in items)
+        names = sorted(v.name for v in items)
         raise KeywordError(
             "\n    ".join(error + names),
-            multiple_keywords=[v for _, v in items],
+            multiple_keywords=[v for v in items],
         )
 
     def __contains__(self, _x: object) -> bool:
-        return any(k == _x for k in self._matchers.keys())
+        return any(v.matcher == _x for v in self.keywords)
 
     def __len__(self) -> int:
         return len(self.keywords)
@@ -983,7 +969,7 @@ class KeywordStore:
         return list(self.iter_all(key))
 
     def iter_all(self, key: str) -> Iterable[KeywordDoc]:
-        yield from (v for k, v in self._matchers.items() if k == key)
+        yield from (v for v in self.keywords if v.matcher == key)
 
 
 @dataclass
@@ -2716,15 +2702,16 @@ def get_model_doc(
     append_model_errors: bool = True,
 ) -> LibraryDoc:
     errors: List[Error] = []
-    keyword_name_nodes: List[KeywordName] = []
-    keywords_nodes: List[Keyword] = []
-    for node in ast.walk(model):
-        if isinstance(node, Keyword):
-            keywords_nodes.append(node)
-        if isinstance(node, KeywordName):
-            keyword_name_nodes.append(node)
-
-        error = node.error if isinstance(node, HasError) else None
+    keyword_name_nodes: Dict[int, KeywordName] = {}
+    keywords_nodes: Dict[int, Keyword] = {}
+    for node in iter_nodes(model):
+        if cached_isinstance(node, Keyword):
+            node.lineno
+            keywords_nodes[node.lineno] = node
+        if cached_isinstance(node, KeywordName):
+            keyword_name_nodes[node.lineno] = node
+
+        error = getattr(node, "error", None)
         if error is not None:
             errors.append(
                 Error(
@@ -2735,7 +2722,7 @@ def get_model_doc(
                 )
             )
         if append_model_errors:
-            node_errors = node.errors if isinstance(node, HasErrors) else None
+            node_errors = getattr(node, "errors", None)
             if node_errors is not None:
                 for e in node_errors:
                     errors.append(
@@ -2748,16 +2735,15 @@ def get_model_doc(
                     )
 
     def get_keyword_name_token_from_line(line: int) -> Optional[Token]:
-        for keyword_name in keyword_name_nodes:
-            if keyword_name.lineno == line:
-                return cast(Token, keyword_name.get_token(RobotToken.KEYWORD_NAME))
-
-        return None
+        keyword_name = keyword_name_nodes.get(line, None)
+        if keyword_name is None:
+            return None
+        return cast(Token, keyword_name.get_token(RobotToken.KEYWORD_NAME))
 
     def get_argument_definitions_from_line(
         line: int,
     ) -> List[ArgumentDefinition]:
-        keyword_node = next((k for k in keywords_nodes if k.lineno == line), None)
+        keyword_node = keywords_nodes.get(line, None)
         if keyword_node is None:
             return []
 

{robotcode_robot-0.95.0 → robotcode_robot-0.95.1}/src/robotcode/robot/diagnostics/model_helper.py

@@ -665,12 +665,12 @@ class ModelHelper:
 
     @classmethod
     def get_keyword_definition_at_token(cls, library_doc: LibraryDoc, token: Token) -> Optional[KeywordDoc]:
-        return cls.get_keyword_definition_at_line(library_doc, token.value, token.lineno)
+        return cls.get_keyword_definition_at_line(library_doc, token.lineno)
 
     @classmethod
-    def get_keyword_definition_at_line(cls, library_doc: LibraryDoc, value: str, line: int) -> Optional[KeywordDoc]:
+    def get_keyword_definition_at_line(cls, library_doc: LibraryDoc, line: int) -> Optional[KeywordDoc]:
         return next(
-            (k for k in library_doc.keywords.iter_all(value) if k.line_no == line),
+            (k for k in library_doc.keywords.keywords if k.line_no == line),
             None,
         )
 

{robotcode_robot-0.95.0 → robotcode_robot-0.95.1}/src/robotcode/robot/utils/ast.py

@@ -38,13 +38,6 @@ def cached_isinstance(obj: Any, *expected_types: Type[_T]) -> TypeGuard[Union[_T
         return False
 
 
-# def cached_isinstance(obj: Any, *expected_types: type) -> bool:
-#     try:
-#         return isinstance(obj, expected_types)
-#     except TypeError:
-#         return False
-
-
 def iter_nodes(node: ast.AST, descendants: bool = True) -> Iterator[ast.AST]:
     for _field, value in ast.iter_fields(node):
         if cached_isinstance(value, list):

{robotcode_robot-0.95.0 → robotcode_robot-0.95.1}/src/robotcode/robot/utils/robot_path.py

@@ -6,7 +6,7 @@ from typing import Optional, Union
 
 def find_file_ex(
     path: Union[Path, "PathLike[str]", str],
-    basedir: Union[Path, PathLike[str], str] = ".",
+    basedir: Union[Path, "PathLike[str]", str] = ".",
     file_type: Optional[str] = None,
 ) -> str:
     from robot.errors import DataError
@@ -33,7 +33,7 @@ def find_file_ex(
 
 def find_file(
     path: Union[Path, "PathLike[str]", str],
-    basedir: Union[Path, PathLike[str], str] = ".",
+    basedir: Union[Path, "PathLike[str]", str] = ".",
     file_type: Optional[str] = None,
 ) -> str:
     return find_file_ex(path, basedir, file_type)

{robotcode_robot-0.95.0 → robotcode_robot-0.95.1}/src/robotcode/robot/utils/stubs.py

@@ -1,22 +1,4 @@
-from __future__ import annotations
-
-from typing import Any, Dict, Iterator, List, Optional, Protocol, Set, runtime_checkable
-
-
-@runtime_checkable
-class HasError(Protocol):
-    error: Optional[str]
-
-
-@runtime_checkable
-class HasErrors(Protocol):
-    errors: Optional[List[str]]
-
-
-@runtime_checkable
-class HeaderAndBodyBlock(Protocol):
-    header: Any
-    body: List[Any]
+from typing import Any, Dict, Iterator, List, Protocol, Set, runtime_checkable
 
 
 @runtime_checkable

{robotcode_robot-0.95.0 → robotcode_robot-0.95.1}/src/robotcode/robot/utils/visitor.py

@@ -2,7 +2,6 @@ import ast
 from abc import ABC
 from typing import (
     Any,
-    AsyncIterator,
     Callable,
     Dict,
     Iterator,
@@ -37,32 +36,6 @@ def iter_field_values(node: ast.AST) -> Iterator[Any]:
             pass
 
 
-def iter_child_nodes(node: ast.AST) -> Iterator[ast.AST]:
-    for _name, field in iter_fields(node):
-        if isinstance(field, ast.AST):
-            yield field
-        elif isinstance(field, list):
-            for item in field:
-                if isinstance(item, ast.AST):
-                    yield item
-
-
-async def iter_nodes(node: ast.AST) -> AsyncIterator[ast.AST]:
-    for _name, value in iter_fields(node):
-        if isinstance(value, list):
-            for item in value:
-                if isinstance(item, ast.AST):
-                    yield item
-                    async for n in iter_nodes(item):
-                        yield n
-
-        elif isinstance(value, ast.AST):
-            yield value
-
-            async for n in iter_nodes(value):
-                yield n
-
-
 class VisitorFinder(ABC):
     __cls_finder_cache__: Dict[Type[Any], Optional[Callable[..., Any]]]
 

robotcode_robot-0.95.0/src/robotcode/robot/__version__.py

@@ -1 +0,0 @@
-__version__ = "0.95.0"