robotcode-robot 0.91.0__py3-none-any.whl → 0.93.0__py3-none-any.whl

robotcode/robot/diagnostics/namespace.py

@@ -694,7 +694,14 @@ class Namespace:
         self._own_variables: Optional[List[VariableDefinition]] = None
         self._own_variables_lock = RLock(default_timeout=120, name="Namespace.own_variables")
         self._global_variables: Optional[List[VariableDefinition]] = None
+        self._global_variables_dict: Optional[Dict[VariableMatcher, VariableDefinition]] = None
         self._global_variables_lock = RLock(default_timeout=120, name="Namespace.global_variables")
+        self._global_variables_dict_lock = RLock(default_timeout=120, name="Namespace.global_variables_dict")
+
+        self._global_resolvable_variables: Optional[Dict[str, Any]] = None
+        self._global_resolvable_variables_lock = RLock(
+            default_timeout=120, name="Namespace._global_resolvable_variables_lock"
+        )
 
         self._suite_variables: Optional[Dict[str, Any]] = None
         self._suite_variables_lock = RLock(default_timeout=120, name="Namespace.global_variables")
@@ -993,9 +1000,12 @@ class Namespace:
         return self.imports_manager.get_command_line_variables()
 
     def _reset_global_variables(self) -> None:
-        with self._global_variables_lock, self._suite_variables_lock:
-            self._global_variables = None
-            self._suite_variables = None
+        with self._global_variables_lock, self._global_variables_dict_lock, self._suite_variables_lock:
+            with self._global_resolvable_variables_lock:
+                self._global_variables = None
+                self._global_variables_dict = None
+                self._suite_variables = None
+                self._global_resolvable_variables = None
 
     def get_global_variables(self) -> List[VariableDefinition]:
         with self._global_variables_lock:
@@ -1012,12 +1022,20 @@ class Namespace:
 
             return self._global_variables
 
+    def get_global_variables_dict(self) -> Dict[VariableMatcher, VariableDefinition]:
+        with self._global_variables_dict_lock:
+            if self._global_variables_dict is None:
+                self._global_variables_dict = {m: v for m, v in self.yield_variables()}
+
+            return self._global_variables_dict
+
     def yield_variables(
         self,
         nodes: Optional[List[ast.AST]] = None,
         position: Optional[Position] = None,
         skip_commandline_variables: bool = False,
         skip_local_variables: bool = False,
+        skip_global_variables: bool = False,
     ) -> Iterator[Tuple[VariableMatcher, VariableDefinition]]:
         yielded: Dict[VariableMatcher, VariableDefinition] = {}
 
@@ -1053,7 +1071,7 @@ class Namespace:
                     else []
                 )
             ],
-            self.get_global_variables(),
+            self.get_global_variables() if not skip_global_variables else [],
         ):
             if var.matcher not in yielded:
                 if skip_commandline_variables and isinstance(var, CommandLineVariableDefinition):
@@ -1063,17 +1081,7 @@ class Namespace:
 
                 yield var.matcher, var
 
-    def get_suite_variables(
-        self,
-        nodes: Optional[List[ast.AST]] = None,
-        position: Optional[Position] = None,
-    ) -> Dict[str, Any]:
-        if nodes:
-            return {
-                v.name: v.value
-                for k, v in self.yield_variables(nodes, position, skip_commandline_variables=True)
-                if v.has_value
-            }
+    def get_suite_variables(self) -> Dict[str, Any]:
         with self._suite_variables_lock:
             vars = {}
 
@@ -1093,11 +1101,21 @@ class Namespace:
         nodes: Optional[List[ast.AST]] = None,
         position: Optional[Position] = None,
     ) -> Dict[str, Any]:
-        return {
-            v.name: v.value
-            for k, v in self.yield_variables(nodes, position, skip_commandline_variables=True)
-            if v.has_value
-        }
+        if nodes:
+            return {
+                v.name: v.value
+                for k, v in self.yield_variables(nodes, position, skip_commandline_variables=True)
+                if v.has_value
+            }
+
+        with self._global_resolvable_variables_lock:
+            if self._global_resolvable_variables is None:
+                self._global_resolvable_variables = {
+                    v.name: v.value
+                    for k, v in self.yield_variables(nodes, position, skip_commandline_variables=True)
+                    if v.has_value
+                }
+            return self._global_resolvable_variables
 
     def get_variable_matchers(
         self,
@@ -1141,9 +1159,15 @@ class Namespace:
                 position,
                 skip_commandline_variables=skip_commandline_variables,
                 skip_local_variables=skip_local_variables,
+                skip_global_variables=True,
             ):
                 if matcher == m:
                     return v
+
+            result = self.get_global_variables_dict().get(matcher, None)
+            if matcher is not None:
+                return result
+
         except InvalidVariableError:
             if not ignore_error:
                 raise
@@ -1376,12 +1400,12 @@ class Namespace:
         source: Optional[str] = None,
         parent_import: Optional[Import] = None,
         parent_source: Optional[str] = None,
-        depth: int = 0,
     ) -> Optional[Dict[str, Any]]:
 
-        current_time = time.monotonic()
-        self._logger.debug(lambda: f"{'  '*depth}start imports for {self.document if top_level else source}")
-        try:
+        with self._logger.measure_time(
+            lambda: f"loading imports for {self.source if top_level else source}",
+            context_name="import",
+        ):
             for imp in imports:
                 if variables is None:
                     variables = self.get_suite_variables()
@@ -1418,7 +1442,6 @@ class Namespace:
                                     source=entry.library_doc.source,
                                     parent_import=imp if top_level else parent_import,
                                     parent_source=parent_source if top_level else source,
-                                    depth=depth + 1,
                                 )
                             except (SystemExit, KeyboardInterrupt):
                                 raise
@@ -1568,48 +1591,40 @@ class Namespace:
                                 code=Error.LIBRARY_ALREADY_IMPORTED,
                             )
 
-        finally:
-            self._logger.debug(
-                lambda: f"{'  '*depth}end imports for "
-                f"{self.document if top_level else source} in {time.monotonic() - current_time}s"
-            )
-
         return variables
 
+    def _import_lib(self, library: str, variables: Optional[Dict[str, Any]] = None) -> Optional[LibraryEntry]:
+        try:
+            return self._get_library_entry(
+                library,
+                (),
+                None,
+                str(Path(self.source).parent),
+                is_default_library=True,
+                variables=variables,
+            )
+        except (SystemExit, KeyboardInterrupt):
+            raise
+        except BaseException as e:
+            self.append_diagnostics(
+                range=Range.zero(),
+                message=f"Can't import default library '{library}': {str(e) or type(e).__name__}",
+                severity=DiagnosticSeverity.ERROR,
+                source="Robot",
+                code=type(e).__qualname__,
+            )
+            return None
+
     def _import_default_libraries(self, variables: Optional[Dict[str, Any]] = None) -> None:
-        def _import_lib(library: str, variables: Optional[Dict[str, Any]] = None) -> Optional[LibraryEntry]:
-            try:
-                return self._get_library_entry(
-                    library,
-                    (),
-                    None,
-                    str(Path(self.source).parent),
-                    is_default_library=True,
-                    variables=variables,
-                )
-            except (SystemExit, KeyboardInterrupt):
-                raise
-            except BaseException as e:
-                self.append_diagnostics(
-                    range=Range.zero(),
-                    message=f"Can't import default library '{library}': {str(e) or type(e).__name__}",
-                    severity=DiagnosticSeverity.ERROR,
-                    source="Robot",
-                    code=type(e).__qualname__,
-                )
-                return None
 
-        self._logger.debug(lambda: f"start import default libraries for document {self.document}")
-        try:
+        with self._logger.measure_time(lambda: f"importing default libraries for {self.source}", context_name="import"):
             if variables is None:
                 variables = self.get_suite_variables()
 
             for library in DEFAULT_LIBRARIES:
-                e = _import_lib(library, variables)
+                e = self._import_lib(library, variables)
                 if e is not None:
                     self._libraries[e.alias or e.name or e.import_name] = e
-        finally:
-            self._logger.debug(lambda: f"end import default libraries for document {self.document}")
 
     @_logger.call
     def _get_library_entry(
@@ -1820,8 +1835,6 @@ class Namespace:
 
     @_logger.call(condition=lambda self: not self._analyzed)
     def analyze(self) -> None:
-        import time
-
         from .namespace_analyzer import NamespaceAnalyzer
 
         with self._analyze_lock:
@@ -1830,53 +1843,43 @@ class Namespace:
 
                 self.ensure_initialized()
 
-                self._logger.debug(lambda: f"start analyze {self.document}")
-                start_time = time.monotonic()
-
-                try:
-                    result = NamespaceAnalyzer(self.model, self, self.create_finder()).run()
+                with self._logger.measure_time(lambda: f"analyzing document {self.source}", context_name="analyze"):
+                    try:
+                        result = NamespaceAnalyzer(self.model, self, self.create_finder()).run()
 
-                    self._diagnostics += result.diagnostics
-                    self._keyword_references = result.keyword_references
-                    self._variable_references = result.variable_references
-                    self._local_variable_assignments = result.local_variable_assignments
-                    self._namespace_references = result.namespace_references
+                        self._diagnostics += result.diagnostics
+                        self._keyword_references = result.keyword_references
+                        self._variable_references = result.variable_references
+                        self._local_variable_assignments = result.local_variable_assignments
+                        self._namespace_references = result.namespace_references
 
-                    lib_doc = self.get_library_doc()
+                        lib_doc = self.get_library_doc()
 
-                    if lib_doc.errors is not None:
-                        for err in lib_doc.errors:
-                            self.append_diagnostics(
-                                range=Range(
-                                    start=Position(
-                                        line=((err.line_no - 1) if err.line_no is not None else 0),
-                                        character=0,
-                                    ),
-                                    end=Position(
-                                        line=((err.line_no - 1) if err.line_no is not None else 0),
-                                        character=0,
+                        if lib_doc.errors is not None:
+                            for err in lib_doc.errors:
+                                self.append_diagnostics(
+                                    range=Range(
+                                        start=Position(
+                                            line=((err.line_no - 1) if err.line_no is not None else 0),
+                                            character=0,
+                                        ),
+                                        end=Position(
+                                            line=((err.line_no - 1) if err.line_no is not None else 0),
+                                            character=0,
+                                        ),
                                     ),
-                                ),
-                                message=err.message,
-                                severity=DiagnosticSeverity.ERROR,
-                                source=DIAGNOSTICS_SOURCE_NAME,
-                                code=err.type_name,
-                            )
-                # TODO: implement CancelationToken
-                except CancelledError:
-                    canceled = True
-                    self._logger.debug("analyzing canceled")
-                    raise
-                finally:
-                    self._analyzed = not canceled
-
-                    self._logger.debug(
-                        lambda: (
-                            f"end analyzed {self.document} succeed in {time.monotonic() - start_time}s"
-                            if self._analyzed
-                            else f"end analyzed {self.document} failed in {time.monotonic() - start_time}s"
-                        )
-                    )
+                                    message=err.message,
+                                    severity=DiagnosticSeverity.ERROR,
+                                    source=DIAGNOSTICS_SOURCE_NAME,
+                                    code=err.type_name,
+                                )
+                    # TODO: implement CancelationToken
+                    except CancelledError:
+                        canceled = True
+                        self._logger.debug("analyzing canceled")
+                        raise
+                    finally:
+                        self._analyzed = not canceled
 
                 self.has_analysed(self)
 

robotcode/robot/diagnostics/workspace_config.py

@@ -55,3 +55,20 @@ class CacheConfig(ConfigBase):
 @dataclass
 class AnalysisRobotConfig(ConfigBase):
     global_library_search_order: List[str] = field(default_factory=list)
+
+
+@config_section("robotcode.analysis.diagnosticModifiers")
+@dataclass
+class AnalysisDiagnosticModifiersConfig(ConfigBase):
+    ignore: List[str] = field(default_factory=list)
+    error: List[str] = field(default_factory=list)
+    warning: List[str] = field(default_factory=list)
+    information: List[str] = field(default_factory=list)
+    hint: List[str] = field(default_factory=list)
+
+
+@dataclass
+class WorkspaceAnalysisConfig:
+    cache: CacheConfig = field(default_factory=CacheConfig)
+    robot: AnalysisRobotConfig = field(default_factory=AnalysisRobotConfig)
+    modifiers: AnalysisDiagnosticModifiersConfig = field(default_factory=AnalysisDiagnosticModifiersConfig)

robotcode/robot/utils/ast.py

@@ -2,7 +2,9 @@ from __future__ import annotations
 
 import ast
 import itertools
-from typing import Any, Iterator, List, Optional, Sequence, Set, Tuple
+from typing import Any, Dict, Iterator, List, Optional, Sequence, Set, Tuple, Type, TypeVar, Union
+
+from typing_extensions import TypeGuard
 
 from robot.errors import VariableError
 from robot.parsing.lexer.tokens import Token
@@ -17,17 +19,42 @@ if get_robot_version() < (7, 0):
 else:
     from robot.variables.search import VariableMatches as VariableIterator
 
+_cached_isinstance_cache: Dict[Tuple[type, Tuple[type, ...]], bool] = {}
+
+_T = TypeVar("_T")
+
+
+def cached_isinstance(obj: Any, *expected_types: Type[_T]) -> TypeGuard[Union[_T]]:
+    try:
+        t = type(obj)
+        if (t, expected_types) in _cached_isinstance_cache:
+            return _cached_isinstance_cache[(t, expected_types)]
+
+        _cached_isinstance_cache[(t, expected_types)] = result = isinstance(obj, expected_types)
+
+        return result
+
+    except TypeError:
+        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 isinstance(value, list):
+        if cached_isinstance(value, list):
             for item in value:
-                if isinstance(item, ast.AST):
+                if cached_isinstance(item, ast.AST):
                     yield item
                     if descendants:
                         yield from iter_nodes(item)
 
-        elif isinstance(value, ast.AST):
+        elif cached_isinstance(value, ast.AST):
             yield value
             if descendants:
                 yield from iter_nodes(value)
@@ -53,7 +80,7 @@ class FirstAndLastRealStatementFinder(Visitor):
         return finder.first_statement, finder.last_statement
 
     def visit_Statement(self, statement: ast.AST) -> None:  # noqa: N802
-        if not isinstance(statement, EmptyLine):
+        if not cached_isinstance(statement, EmptyLine):
             if self.first_statement is None:
                 self.first_statement = statement
 
@@ -63,7 +90,7 @@ class FirstAndLastRealStatementFinder(Visitor):
 def _get_non_data_range_from_node(
     node: ast.AST, only_start: bool = False, allow_comments: bool = False
 ) -> Optional[Range]:
-    if isinstance(node, Statement) and node.tokens:
+    if cached_isinstance(node, Statement) and node.tokens:
         start_token = next(
             (
                 v
@@ -115,7 +142,7 @@ def range_from_node(
     allow_comments: bool = False,
 ) -> Range:
     if skip_non_data:
-        if isinstance(node, Statement) and node.tokens:
+        if cached_isinstance(node, Statement) and node.tokens:
             result = _get_non_data_range_from_node(node, only_start, allow_comments)
             if result is not None:
                 return result

{robotcode_robot-0.91.0.dist-info → robotcode_robot-0.93.0.dist-info}/METADATA

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

@@ -0,0 +1,30 @@
+robotcode/robot/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+robotcode/robot/__version__.py,sha256=W-KEJT0wpRrG8XJ2aDG4NSyzaUucgZR9y6mwfCTlku4,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=MlOPXC3mUVjNB2rHn5UJK7NnUPa8S4mE3qojILOi_Mk,23756
+robotcode/robot/diagnostics/entities.py,sha256=dWZFSrAuW9wzW9AEDSr-stseexLbJIYfdScfAbBj4FY,11002
+robotcode/robot/diagnostics/errors.py,sha256=HCE0h0_ui1tx-6pJHs0r4s09ZHmArYwKUo-_lBl9K-4,1600
+robotcode/robot/diagnostics/imports_manager.py,sha256=GvcIEqghVjtliTWUwQo4N-xier00CGnEh_eO7l05cJg,57187
+robotcode/robot/diagnostics/library_doc.py,sha256=7m29COvY_YlK_n9dj57q0c7sFRThoR_X4bgdZapWwaY,98160
+robotcode/robot/diagnostics/model_helper.py,sha256=_5ixKKMrb-nY-uvV8_WjJ1rlNlz7gT7kHM5NYi_hjVg,30232
+robotcode/robot/diagnostics/namespace.py,sha256=lH5RReu-fW0g8CZBh9LKWHItCZh14D-XFvFdYUvBoDg,90151
+robotcode/robot/diagnostics/namespace_analyzer.py,sha256=3eC1xEBm_foCnqoHk8Cj6O11UXOHcHxWnfuKP8M5KIQ,51369
+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=0XZZ5wDU2yfzIuShjG7h79PgzMaQJ501WH4YRFcG1VM,11615
+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=uYLqEhGPmzWKWI3SSrmCaYMwtKvNShvbiPZ4b3FavX8,3241
+robotcode_robot-0.93.0.dist-info/METADATA,sha256=64V1dXSzlmT6KArsIP0YqCm79s_oPXVm3MXBlenwx2E,2240
+robotcode_robot-0.93.0.dist-info/WHEEL,sha256=1yFddiXMmvYK7QYTqtRNtX66WJ0Mz8PYEiEUoOUUxRY,87
+robotcode_robot-0.93.0.dist-info/licenses/LICENSE.txt,sha256=B05uMshqTA74s-0ltyHKI6yoPfJ3zYgQbvcXfDVGFf8,10280
+robotcode_robot-0.93.0.dist-info/RECORD,,

robotcode_robot-0.91.0.dist-info/RECORD

@@ -1,30 +0,0 @@
-robotcode/robot/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-robotcode/robot/__version__.py,sha256=RBon26SFk4Bs08h0XAmTYW8lrYs3N9ihifF9r6VT4Vc,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=LpGqJAdysvVSZpccW-Il52xn9RMBBb9X94emlBY7zCc,6077
-robotcode/robot/config/model.py,sha256=w2qqxPwuv-N3GEZsCaaxFxU5iPfQr3oS1mqMkZFkRPU,88891
-robotcode/robot/config/utils.py,sha256=c_WZg39DJgM6kXcAH_h-v68qhf1eStJ0TslTawaJoZw,2827
-robotcode/robot/diagnostics/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-robotcode/robot/diagnostics/diagnostics_modifier.py,sha256=9AFptQsdw_TvgBkKqutpvI8WKsOUXipXQDOExarJJy4,6903
-robotcode/robot/diagnostics/document_cache_helper.py,sha256=pa9AdSbEFZJ6VSdZluGyfzyZPjzBfNFAv5pXJEM-7fc,22664
-robotcode/robot/diagnostics/entities.py,sha256=AtrqPAS3XUC-8VpFmqMXfMKjQHmfxXZlyGWWFaEBpQA,10979
-robotcode/robot/diagnostics/errors.py,sha256=HCE0h0_ui1tx-6pJHs0r4s09ZHmArYwKUo-_lBl9K-4,1600
-robotcode/robot/diagnostics/imports_manager.py,sha256=qE__lm0Hsj3R0gUauXRmbWJPYihNjk3O-c5hcICGQjc,56251
-robotcode/robot/diagnostics/library_doc.py,sha256=CHgyC9GMRQFP3fGTxWa139rIcGIk8Ys6Q_ZIDSgse7k,97324
-robotcode/robot/diagnostics/model_helper.py,sha256=_5ixKKMrb-nY-uvV8_WjJ1rlNlz7gT7kHM5NYi_hjVg,30232
-robotcode/robot/diagnostics/namespace.py,sha256=jCUb5GmMDA6KTr2BnwHD_0Mp_gTg1XGskUvRYPL7XQ0,89543
-robotcode/robot/diagnostics/namespace_analyzer.py,sha256=3eC1xEBm_foCnqoHk8Cj6O11UXOHcHxWnfuKP8M5KIQ,51369
-robotcode/robot/diagnostics/workspace_config.py,sha256=lWNq1KmGGJ9cHFNHn0QTCBHHzgz4AewTw0l-W4TKrj0,1803
-robotcode/robot/utils/__init__.py,sha256=OjNPMn_XSnfaMCyKd8Kmq6vlRt6mIGlzW4qiiD3ykUg,447
-robotcode/robot/utils/ast.py,sha256=ynxvXv1SHkAcF07m76ey9_zaGCYXhlPOnny7km-XWSQ,10479
-robotcode/robot/utils/markdownformatter.py,sha256=0XZZ5wDU2yfzIuShjG7h79PgzMaQJ501WH4YRFcG1VM,11615
-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=uYLqEhGPmzWKWI3SSrmCaYMwtKvNShvbiPZ4b3FavX8,3241
-robotcode_robot-0.91.0.dist-info/METADATA,sha256=Cl7XlzEEn_Q5xmyv7C6R09JliQm1pL45DGuC-M4cSrY,2240
-robotcode_robot-0.91.0.dist-info/WHEEL,sha256=1yFddiXMmvYK7QYTqtRNtX66WJ0Mz8PYEiEUoOUUxRY,87
-robotcode_robot-0.91.0.dist-info/licenses/LICENSE.txt,sha256=B05uMshqTA74s-0ltyHKI6yoPfJ3zYgQbvcXfDVGFf8,10280
-robotcode_robot-0.91.0.dist-info/RECORD,,