robotcode-robot 0.94.0__py3-none-any.whl → 0.95.0__py3-none-any.whl

robotcode/robot/diagnostics/namespace_analyzer.py

@@ -8,7 +8,7 @@ from dataclasses import dataclass
 from io import StringIO
 from pathlib import Path
 from tokenize import TokenError, generate_tokens
-from typing import TYPE_CHECKING, Any, Dict, Iterator, List, Optional, Set, Tuple, Union, cast
+from typing import TYPE_CHECKING, Any, Callable, Dict, Iterator, List, Optional, Set, Tuple, Union, cast
 
 from robot.errors import VariableError
 from robot.parsing.lexer.tokens import Token
@@ -28,9 +28,8 @@ from robot.parsing.model.statements import (
     Variable,
     VariablesImport,
 )
-from robot.utils.escaping import split_from_equals, unescape
+from robot.utils.escaping import unescape
 from robot.variables.finders import NOT_FOUND, NumberFinder
-from robot.variables.search import contains_variable, is_scalar_assign, is_variable, search_variable
 from robotcode.core.concurrent import check_current_task_canceled
 from robotcode.core.lsp.types import (
     CodeDescription,
@@ -43,6 +42,7 @@ from robotcode.core.lsp.types import (
     Range,
 )
 from robotcode.core.uri import Uri
+from robotcode.core.utils.logging import LoggingDescriptor
 
 from ..utils import get_robot_version
 from ..utils.ast import (
@@ -53,11 +53,13 @@ from ..utils.ast import (
     strip_variable_token,
     tokenize_variables,
 )
+from ..utils.variables import contains_variable, is_scalar_assign, is_variable, search_variable, split_from_equals
 from ..utils.visitor import Visitor
 from .entities import (
     ArgumentDefinition,
     EnvironmentVariableDefinition,
     GlobalVariableDefinition,
+    InvalidVariableError,
     LibraryEntry,
     LocalVariableDefinition,
     TestVariableDefinition,
@@ -94,6 +96,9 @@ class AnalyzerResult:
 
 
 class NamespaceAnalyzer(Visitor):
+
+    _logger = LoggingDescriptor()
+
     def __init__(
         self,
         model: ast.AST,
@@ -126,8 +131,11 @@ class NamespaceAnalyzer(Visitor):
         self._overridden_variables: Dict[VariableDefinition, VariableDefinition] = {}
 
         self._in_setting = False
+        self._in_block_setting = False
 
         self._suite_variables = self._variables.copy()
+        self._block_variables: Optional[Dict[VariableMatcher, VariableDefinition]] = None
+        self._end_block_handlers: Optional[List[Callable[[], None]]] = None
 
     def run(self) -> AnalyzerResult:
         self._diagnostics = []
@@ -146,10 +154,11 @@ class NamespaceAnalyzer(Visitor):
         except BaseException as e:
             self._append_diagnostics(
                 range_from_node(self._model),
-                message=f"Fatal: can't analyze namespace '{e}')",
+                message=f"Fatal: can't analyze namespace '{e}'.",
                 severity=DiagnosticSeverity.ERROR,
                 code=type(e).__qualname__,
             )
+            self._logger.exception(e)
 
         return AnalyzerResult(
             self._diagnostics,
@@ -379,6 +388,15 @@ class NamespaceAnalyzer(Visitor):
         finally:
             self._in_setting = False
 
+    def _visit_block_settings_statement(
+        self, node: Statement, severity: DiagnosticSeverity = DiagnosticSeverity.ERROR
+    ) -> None:
+        self._in_block_setting = True
+        try:
+            self._visit_settings_statement(node, severity)
+        finally:
+            self._in_block_setting = False
+
     def _analyze_token_expression_variables(
         self, token: Token, severity: DiagnosticSeverity = DiagnosticSeverity.ERROR
     ) -> None:
@@ -476,7 +494,7 @@ class NamespaceAnalyzer(Visitor):
                         range=range_from_token(var_token),
                         message=f"Environment variable '{var.name}' not found.",
                         severity=severity,
-                        code=Error.ENVIROMMENT_VARIABLE_NOT_FOUND,
+                        code=Error.ENVIRONMENT_VARIABLE_NOT_FOUND,
                     )
 
             if var.type == VariableDefinitionType.ENVIRONMENT_VARIABLE:
@@ -531,6 +549,20 @@ class NamespaceAnalyzer(Visitor):
             )
         )
 
+    KEYWORDS_WITH_EXPRESSIONS = [
+        "BuiltIn.Evaluate",
+        "BuiltIn.Should Be True",
+        "BuiltIn.Should Not Be True",
+        "BuiltIn.Skip If",
+        "BuiltIn.Continue For Loop If",
+        "BuiltIn.Exit For Loop If",
+        "BuiltIn.Return From Keyword If",
+        "BuiltIn.Run Keyword And Return If",
+        "BuiltIn.Pass Execution If",
+        "BuiltIn.Run Keyword If",
+        "BuiltIn.Run Keyword Unless",
+    ]
+
     def _analyze_keyword_call(
         self,
         node: ast.AST,
@@ -552,13 +584,11 @@ class NamespaceAnalyzer(Visitor):
             if not allow_variables and not is_not_variable_token(keyword_token):
                 return None
 
-            result = self._finder.find_keyword(keyword, raise_keyword_error=False, handle_bdd_style=False)
+            result = self._finder.find_keyword(keyword, raise_keyword_error=False)
 
-            if result is None:
+            if result is not None and self._finder.result_bdd_prefix:
                 keyword_token = ModelHelper.strip_bdd_prefix(self._namespace, keyword_token)
 
-                result = self._finder.find_keyword(keyword, raise_keyword_error=False)
-
             kw_range = range_from_token(keyword_token)
 
             if keyword:
@@ -710,19 +740,7 @@ class NamespaceAnalyzer(Visitor):
             )
 
         if result is not None:
-            if result.longname in [
-                "BuiltIn.Evaluate",
-                "BuiltIn.Should Be True",
-                "BuiltIn.Should Not Be True",
-                "BuiltIn.Skip If",
-                "BuiltIn.Continue For Loop If",
-                "BuiltIn.Exit For Loop If",
-                "BuiltIn.Return From Keyword If",
-                "BuiltIn.Run Keyword And Return If",
-                "BuiltIn.Pass Execution If",
-                "BuiltIn.Run Keyword If",
-                "BuiltIn.Run Keyword Unless",
-            ]:
+            if result.longname in self.KEYWORDS_WITH_EXPRESSIONS:
                 tokens = argument_tokens
                 if tokens and (token := tokens[0]):
                     self._analyze_token_expression_variables(token)
@@ -896,7 +914,29 @@ class NamespaceAnalyzer(Visitor):
 
         if keyword_token is not None and keyword_token.value and keyword_token.value.upper() not in ("", "NONE"):
             self._analyze_token_variables(keyword_token)
-            self._analyze_statement_variables(node)
+            self._visit_block_settings_statement(node)
+
+            self._analyze_keyword_call(
+                node,
+                keyword_token,
+                [e for e in node.get_tokens(Token.ARGUMENT)],
+                allow_variables=True,
+                ignore_errors_if_contains_variables=True,
+            )
+
+    def visit_Teardown(self, node: Fixture) -> None:  # noqa: N802
+        keyword_token = node.get_token(Token.NAME)
+
+        # TODO: calculate possible variables in NAME
+
+        if keyword_token is not None and keyword_token.value and keyword_token.value.upper() not in ("", "NONE"):
+
+            def _handler() -> None:
+                self._analyze_token_variables(keyword_token)
+                self._analyze_statement_variables(node)
+
+            if self._end_block_handlers is not None:
+                self._end_block_handlers.append(_handler)
 
             self._analyze_keyword_call(
                 node,
@@ -984,9 +1024,15 @@ class NamespaceAnalyzer(Visitor):
         self._current_testcase_or_keyword_name = node.name
         old_variables = self._variables
         self._variables = self._variables.copy()
+        self._end_block_handlers = []
         try:
             self.generic_visit(node)
+
+            for handler in self._end_block_handlers:
+                handler()
+
         finally:
+            self._end_block_handlers = None
             self._variables = old_variables
             self._current_testcase_or_keyword_name = None
             self._template = None
@@ -1029,13 +1075,21 @@ class NamespaceAnalyzer(Visitor):
         self._current_testcase_or_keyword_name = node.name
         old_variables = self._variables
         self._variables = self._variables.copy()
+        self._end_block_handlers = []
         try:
             arguments = next((v for v in node.body if isinstance(v, Arguments)), None)
             if arguments is not None:
                 self._visit_Arguments(arguments)
+            self._block_variables = self._variables.copy()
 
             self.generic_visit(node)
+
+            for handler in self._end_block_handlers:
+                handler()
+
         finally:
+            self._end_block_handlers = None
+            self._block_variables = None
             self._variables = old_variables
             self._current_testcase_or_keyword_name = None
             self._current_keyword_doc = None
@@ -1132,7 +1186,7 @@ class NamespaceAnalyzer(Visitor):
                             )
                         )
 
-            except VariableError:
+            except (VariableError, InvalidVariableError):
                 pass
 
     def _analyze_assign_statement(self, node: Statement) -> None:
@@ -1172,7 +1226,7 @@ class NamespaceAnalyzer(Visitor):
                             )
                         )
 
-            except VariableError:
+            except (VariableError, InvalidVariableError):
                 pass
 
     def visit_InlineIfHeader(self, node: Statement) -> None:  # noqa: N802
@@ -1186,7 +1240,7 @@ class NamespaceAnalyzer(Visitor):
         variables = node.get_tokens(Token.VARIABLE)
         for variable in variables:
             variable_token = self._get_variable_token(variable)
-            if variable_token is not None:
+            if variable_token is not None and is_variable(variable_token.value):
                 existing_var = self._find_variable(variable_token.value)
 
                 if existing_var is None or existing_var.type not in [
@@ -1248,7 +1302,7 @@ class NamespaceAnalyzer(Visitor):
                             source=self._namespace.source,
                         )
 
-            except VariableError:
+            except (VariableError, InvalidVariableError):
                 pass
 
     def _format_template(self, template: str, arguments: Tuple[str, ...]) -> Tuple[str, Tuple[str, ...]]:
@@ -1351,7 +1405,7 @@ class NamespaceAnalyzer(Visitor):
         self._visit_settings_statement(node, DiagnosticSeverity.HINT)
 
     def visit_Timeout(self, node: Statement) -> None:  # noqa: N802
-        self._analyze_statement_variables(node, DiagnosticSeverity.HINT)
+        self._visit_block_settings_statement(node)
 
     def visit_SingleValue(self, node: Statement) -> None:  # noqa: N802
         self._visit_settings_statement(node, DiagnosticSeverity.HINT)
@@ -1399,19 +1453,35 @@ class NamespaceAnalyzer(Visitor):
                     code=Error.DEPRECATED_HEADER,
                 )
 
-    def visit_ReturnSetting(self, node: Statement) -> None:  # noqa: N802
-        self._analyze_statement_variables(node)
+    if get_robot_version() >= (7, 0):
 
-        if get_robot_version() >= (7, 0):
-            token = node.get_token(Token.RETURN_SETTING)
-            if token is not None and token.error:
-                self._append_diagnostics(
-                    range=range_from_node_or_token(node, token),
-                    message=token.error,
-                    severity=DiagnosticSeverity.WARNING,
-                    tags=[DiagnosticTag.DEPRECATED],
-                    code=Error.DEPRECATED_RETURN_SETTING,
-                )
+        def visit_ReturnSetting(self, node: Statement) -> None:  # noqa: N802
+
+            def _handler() -> None:
+                self._analyze_statement_variables(node)
+
+            if self._end_block_handlers is not None:
+                self._end_block_handlers.append(_handler)
+
+            if get_robot_version() >= (7, 0):
+                token = node.get_token(Token.RETURN_SETTING)
+                if token is not None and token.error:
+                    self._append_diagnostics(
+                        range=range_from_node_or_token(node, token),
+                        message=token.error,
+                        severity=DiagnosticSeverity.WARNING,
+                        tags=[DiagnosticTag.DEPRECATED],
+                        code=Error.DEPRECATED_RETURN_SETTING,
+                    )
+
+    else:
+
+        def visit_Return(self, node: Statement) -> None:  # noqa: N802
+            def _handler() -> None:
+                self._analyze_statement_variables(node)
+
+            if self._end_block_handlers is not None:
+                self._end_block_handlers.append(_handler)
 
     def _check_import_name(self, value: Optional[str], node: ast.AST, type: str) -> None:
         if not value:
@@ -1540,11 +1610,18 @@ class NamespaceAnalyzer(Visitor):
                 default_value=default_value or None,
             )
 
-        vars = self._suite_variables if self._in_setting else self._variables
+        vars = (
+            self._block_variables
+            if self._block_variables and self._in_block_setting
+            else self._suite_variables if self._in_setting else self._variables
+        )
 
-        matcher = VariableMatcher(name)
+        try:
+            matcher = VariableMatcher(name)
 
-        return vars.get(matcher, None)
+            return vars.get(matcher, None)
+        except (VariableError, InvalidVariableError):
+            return None
 
     def _is_number(self, name: str) -> bool:
         if name.startswith("$"):

robotcode/robot/utils/match.py

@@ -3,13 +3,13 @@ from functools import lru_cache
 _transform_table = str.maketrans("", "", "_ ")
 
 
-@lru_cache(maxsize=5000)
+@lru_cache(maxsize=None)
 def normalize(text: str) -> str:
     # return text.lower().replace("_", "").replace(" ", "")
     return text.casefold().translate(_transform_table)
 
 
-@lru_cache(maxsize=5000)
+@lru_cache(maxsize=None)
 def normalize_namespace(text: str) -> str:
     return text.lower().replace(" ", "")
 

robotcode/robot/utils/robot_path.py

@@ -1,21 +1,11 @@
-from __future__ import annotations
-
 import sys
 from os import PathLike
 from pathlib import Path
 from typing import Optional, Union
 
 
-def find_file(
-    path: 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)
-
-
 def find_file_ex(
-    path: Union[Path, PathLike[str], str],
+    path: Union[Path, "PathLike[str]", str],
     basedir: Union[Path, PathLike[str], str] = ".",
     file_type: Optional[str] = None,
 ) -> str:
@@ -25,6 +15,7 @@ def find_file_ex(
     ret = _find_absolute_path(path) if path.is_absolute() else _find_relative_path(path, basedir)
     if ret:
         return str(ret)
+
     default = file_type or "File"
 
     file_type = (
@@ -40,15 +31,23 @@ def find_file_ex(
     raise DataError("%s '%s' does not exist." % (file_type, path))
 
 
-def _find_absolute_path(path: Union[Path, PathLike[str], str]) -> Optional[str]:
+def find_file(
+    path: 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)
+
+
+def _find_absolute_path(path: Union[Path, "PathLike[str]", str]) -> Optional[str]:
     if _is_valid_file(path):
         return str(path)
     return None
 
 
 def _find_relative_path(
-    path: Union[Path, PathLike[str], str],
-    basedir: Union[Path, PathLike[str], str],
+    path: Union[Path, "PathLike[str]", str],
+    basedir: Union[Path, "PathLike[str]", str],
 ) -> Optional[str]:
     for base in [basedir, *sys.path]:
         if not base:
@@ -65,6 +64,6 @@ def _find_relative_path(
     return None
 
 
-def _is_valid_file(path: Union[Path, PathLike[str], str]) -> bool:
+def _is_valid_file(path: Union[Path, "PathLike[str]", str]) -> bool:
     path = Path(path)
     return path.is_file() or (path.is_dir() and Path(path, "__init__.py").is_fifo())

robotcode/robot/utils/variables.py

@@ -1,3 +1,13 @@
+import functools
+from typing import Optional, Tuple, cast
+
+from robot.utils.escaping import split_from_equals as robot_split_from_equals
+from robot.variables.search import VariableMatch as RobotVariableMatch
+from robot.variables.search import contains_variable as robot_contains_variable
+from robot.variables.search import is_scalar_assign as robot_is_scalar_assign
+from robot.variables.search import is_variable as robot_is_variable
+from robot.variables.search import search_variable as robot_search_variable
+
 BUILTIN_VARIABLES = [
     "${CURDIR}",
     "${EMPTY}",
@@ -35,3 +45,28 @@ BUILTIN_VARIABLES = [
     "${DEBUG_FILE}",
     "${OUTPUT_DIR}",
 ]
+
+
+@functools.lru_cache(maxsize=512)
+def contains_variable(string: str, identifiers: str = "$@&") -> bool:
+    return cast(bool, robot_contains_variable(string, identifiers))
+
+
+@functools.lru_cache(maxsize=512)
+def is_scalar_assign(string: str, allow_assign_mark: bool = False) -> bool:
+    return cast(bool, robot_is_scalar_assign(string, allow_assign_mark))
+
+
+@functools.lru_cache(maxsize=512)
+def is_variable(string: str, identifiers: str = "$@&") -> bool:
+    return cast(bool, robot_is_variable(string, identifiers))
+
+
+@functools.lru_cache(maxsize=512)
+def search_variable(string: str, identifiers: str = "$@&%*", ignore_errors: bool = False) -> RobotVariableMatch:
+    return robot_search_variable(string, identifiers, ignore_errors)
+
+
+@functools.lru_cache(maxsize=512)
+def split_from_equals(string: str) -> Tuple[str, Optional[str]]:
+    return cast(Tuple[str, Optional[str]], robot_split_from_equals(string))

{robotcode_robot-0.94.0.dist-info → robotcode_robot-0.95.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: robotcode-robot
-Version: 0.94.0
+Version: 0.95.0
 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.94.0
+Requires-Dist: robotcode-core==0.95.0
 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.dist-info/RECORD

@@ -0,0 +1,32 @@
+robotcode/robot/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+robotcode/robot/__version__.py,sha256=1KBvo1_4ig2ZeMfCvFApYtfDll8Ysfu6h45ByRERz1E,23
+robotcode/robot/py.typed,sha256=bWew9mHgMy8LqMu7RuqQXFXLBxh2CRx0dUbSx-3wE48,27
+robotcode/robot/config/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+robotcode/robot/config/loader.py,sha256=bNJwr_XdCoUzpG2ag0BH33PIfiCwn0GMxn7q_Sw3zOk,8103
+robotcode/robot/config/model.py,sha256=sgr6-4_E06g-yIXW41Z-NtIXZ_7JMmR5WvUD7kTUqu4,89106
+robotcode/robot/config/utils.py,sha256=xY-LH31BidWzonpvSrle-4HvKrp02I7IRqU2JwlL4Ls,2931
+robotcode/robot/diagnostics/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+robotcode/robot/diagnostics/data_cache.py,sha256=Wge9HuxSUiBVMmrmlsYSMmG2ad7f3Texwox0Dm8lN7U,2969
+robotcode/robot/diagnostics/diagnostics_modifier.py,sha256=3dDsu8-ET6weIvv7Sk3IQaPYFNxnXUs8Y7gpGTjfOBs,9796
+robotcode/robot/diagnostics/document_cache_helper.py,sha256=n903UxVXM4Uq4fPxN5s-dugQAKcWUwf4Nw4q0CJV7aw,23902
+robotcode/robot/diagnostics/entities.py,sha256=dA5jTt1pSCLvWWC_DkHPjfBZmnS80dVt3gZptASR3Uo,11008
+robotcode/robot/diagnostics/errors.py,sha256=vRH7HiZOfQIC-L7ys2Bj9ULYxLpUH7I03qJRSkEx08k,1813
+robotcode/robot/diagnostics/imports_manager.py,sha256=lmwg_wYFZLNx_o0u856_5JihXHPLBei2vfr6Puhlm-c,59127
+robotcode/robot/diagnostics/keyword_finder.py,sha256=O3EHA93ZGqNI-TocvSYAmWz7INWakhhfBeiXq57wepM,17421
+robotcode/robot/diagnostics/library_doc.py,sha256=6j_7qy5O-dFAbVmwjn_sDkBHrFvghJwu0fvPcLhJnMw,100901
+robotcode/robot/diagnostics/model_helper.py,sha256=-dRXt__coz-m2HaMLTqgQEUF6ylH0QZxj5hUv2DBJyQ,31017
+robotcode/robot/diagnostics/namespace.py,sha256=Y6HDBKIYyCc3qCg2TT-orB9mASd-Ii4fkZuIpcFQMbk,75417
+robotcode/robot/diagnostics/namespace_analyzer.py,sha256=NlvfAEYH_GyE1ZQ1JH9vR9yPfki3Xmw9TyNEc-B0mtM,74067
+robotcode/robot/diagnostics/workspace_config.py,sha256=3SoewUj_LZB1Ki5hXM8oxQpJr6vyiog66SUw-ibODSA,2478
+robotcode/robot/utils/__init__.py,sha256=OjNPMn_XSnfaMCyKd8Kmq6vlRt6mIGlzW4qiiD3ykUg,447
+robotcode/robot/utils/ast.py,sha256=_ob36KHFY776n9dhljn0xAWVoUDb7pV86fPW40vIirY,11266
+robotcode/robot/utils/markdownformatter.py,sha256=Cj4NjComTcNZf8uuezvtBbZqPMLjS237RknMopZYETk,11418
+robotcode/robot/utils/match.py,sha256=Vtz1ueT6DIZZ4hKyXgvTg1A3x2puBwHgvjw1oAYBn5w,632
+robotcode/robot/utils/robot_path.py,sha256=6XfNjnIVQREwgUR7r0eUMHgLnduXKTpHWy2Dvs_MbPo,1763
+robotcode/robot/utils/stubs.py,sha256=6-DMI_CQVJHDgG13t-zINKGCRb_Q7MQPm0_AkfhAEvE,748
+robotcode/robot/utils/variables.py,sha256=XNPUDpghGy_f_Fne9lJ4OST-kFi-72Nrr0yJUu6f_Oc,2169
+robotcode/robot/utils/visitor.py,sha256=V3ZtpzrCilKpLQfDXUcjapd2uGq12XxbHppNPOl_Jns,3080
+robotcode_robot-0.95.0.dist-info/METADATA,sha256=ucoFRI1dSKtBhbXI3KtxfGXyEbIXRUHxBoe7LURhGVY,2240
+robotcode_robot-0.95.0.dist-info/WHEEL,sha256=1yFddiXMmvYK7QYTqtRNtX66WJ0Mz8PYEiEUoOUUxRY,87
+robotcode_robot-0.95.0.dist-info/licenses/LICENSE.txt,sha256=B05uMshqTA74s-0ltyHKI6yoPfJ3zYgQbvcXfDVGFf8,10280
+robotcode_robot-0.95.0.dist-info/RECORD,,

robotcode_robot-0.94.0.dist-info/RECORD

@@ -1,31 +0,0 @@
-robotcode/robot/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-robotcode/robot/__version__.py,sha256=BbCpQB0IaKmq_fOtysTb_iVtvqbH-vHS1DoS1eLd4w8,23
-robotcode/robot/py.typed,sha256=bWew9mHgMy8LqMu7RuqQXFXLBxh2CRx0dUbSx-3wE48,27
-robotcode/robot/config/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-robotcode/robot/config/loader.py,sha256=bNJwr_XdCoUzpG2ag0BH33PIfiCwn0GMxn7q_Sw3zOk,8103
-robotcode/robot/config/model.py,sha256=sgr6-4_E06g-yIXW41Z-NtIXZ_7JMmR5WvUD7kTUqu4,89106
-robotcode/robot/config/utils.py,sha256=xY-LH31BidWzonpvSrle-4HvKrp02I7IRqU2JwlL4Ls,2931
-robotcode/robot/diagnostics/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-robotcode/robot/diagnostics/diagnostics_modifier.py,sha256=3dDsu8-ET6weIvv7Sk3IQaPYFNxnXUs8Y7gpGTjfOBs,9796
-robotcode/robot/diagnostics/document_cache_helper.py,sha256=n903UxVXM4Uq4fPxN5s-dugQAKcWUwf4Nw4q0CJV7aw,23902
-robotcode/robot/diagnostics/entities.py,sha256=sNXKBdJEy7elkzc0P2qszHQQosbmcyWrCw3Za4-LSCE,11013
-robotcode/robot/diagnostics/errors.py,sha256=QpvimvU_-c13i6mNrOiIavr2BeClHThRk8Rh7zIbA1s,1813
-robotcode/robot/diagnostics/imports_manager.py,sha256=somlZbrkXasgU6KZmnf9Zfm4_3nqXEbi8Er5kSO-48Y,58999
-robotcode/robot/diagnostics/keyword_finder.py,sha256=KQKZN0lf4D8qRERRx1JUeEdSHFgRfs0wEcu0XH2xJ-A,16809
-robotcode/robot/diagnostics/library_doc.py,sha256=2qPU1MeD4uiUAipV0U3JUxQAKhr9TH_WwDM_rDdMZuw,98862
-robotcode/robot/diagnostics/model_helper.py,sha256=9JGZN_dBXMPP06WsAIDz5Q_Fg3F3Rq1n-7Rc72etivo,30864
-robotcode/robot/diagnostics/namespace.py,sha256=_KNsoQS5UJB6Laa8Ic0FrQZjxngxmaKO36KJ260qyug,76054
-robotcode/robot/diagnostics/namespace_analyzer.py,sha256=z1AyGQXMoq1up3LrPSLWJHHNUI_j_iwIj9ucLJcg7gU,71399
-robotcode/robot/diagnostics/workspace_config.py,sha256=3SoewUj_LZB1Ki5hXM8oxQpJr6vyiog66SUw-ibODSA,2478
-robotcode/robot/utils/__init__.py,sha256=OjNPMn_XSnfaMCyKd8Kmq6vlRt6mIGlzW4qiiD3ykUg,447
-robotcode/robot/utils/ast.py,sha256=_ob36KHFY776n9dhljn0xAWVoUDb7pV86fPW40vIirY,11266
-robotcode/robot/utils/markdownformatter.py,sha256=Cj4NjComTcNZf8uuezvtBbZqPMLjS237RknMopZYETk,11418
-robotcode/robot/utils/match.py,sha256=ofyfXgrvVddl7a064Dk5Kiqp3a-n_6gTIgqDbL3E80Q,632
-robotcode/robot/utils/robot_path.py,sha256=qKBh1cEnReBBLKkWu4gB9EzM-scAwE4xJc1m6v2LRN0,1786
-robotcode/robot/utils/stubs.py,sha256=6-DMI_CQVJHDgG13t-zINKGCRb_Q7MQPm0_AkfhAEvE,748
-robotcode/robot/utils/variables.py,sha256=fEl8S37lb_mD4hn2MZRAlkiuLGBjAOeZVK0r2o2CfPw,742
-robotcode/robot/utils/visitor.py,sha256=V3ZtpzrCilKpLQfDXUcjapd2uGq12XxbHppNPOl_Jns,3080
-robotcode_robot-0.94.0.dist-info/METADATA,sha256=ZC2K7aAay0qTvzWb38ymbXwS1Ufd8OvfKZdICK2A1uw,2240
-robotcode_robot-0.94.0.dist-info/WHEEL,sha256=1yFddiXMmvYK7QYTqtRNtX66WJ0Mz8PYEiEUoOUUxRY,87
-robotcode_robot-0.94.0.dist-info/licenses/LICENSE.txt,sha256=B05uMshqTA74s-0ltyHKI6yoPfJ3zYgQbvcXfDVGFf8,10280
-robotcode_robot-0.94.0.dist-info/RECORD,,