robotcode-robot 1.2.0__py3-none-any.whl → 1.3.0.dev1__py3-none-any.whl

robotcode/robot/__version__.py

@@ -1 +1 @@
-__version__ = "1.2.0"
+__version__ = "1.3.0-dev1"

robotcode/robot/config/model.py

@@ -2371,11 +2371,11 @@ class RobotConfig(RobotExtendBaseProfile):
 
             Examples:
             ```toml
-            default_profiles = "default"
+            default-profiles = "default"
             ```
 
             ```toml
-            default_profiles = ["default", "Firefox"]
+            default-profiles = ["default", "Firefox"]
             ```
             """
     )

robotcode/robot/diagnostics/entities.py

@@ -17,10 +17,9 @@ from typing_extensions import Concatenate, ParamSpec
 
 from robot.parsing.lexer.tokens import Token
 from robotcode.core.lsp.types import Position, Range
-from robotcode.robot.utils.match import normalize
 
 from ..utils.ast import range_from_token
-from ..utils.variables import search_variable
+from ..utils.variables import VariableMatcher
 
 if TYPE_CHECKING:
     from robotcode.robot.diagnostics.library_doc import KeywordDoc, LibraryDoc
@@ -164,48 +163,6 @@ class VariablesImport(Import):
         return hash((type(self), self.name, self.args))
 
 
-class InvalidVariableError(Exception):
-    pass
-
-
-class VariableMatcher:
-    def __init__(self, name: str) -> None:
-        self.name = name
-
-        match = search_variable(name, "$@&%", ignore_errors=True)
-
-        if match.base is None:
-            raise InvalidVariableError(f"Invalid variable '{name}'")
-
-        self.base = match.base
-
-        self.normalized_name = normalize(self.base)
-
-    def __eq__(self, o: object) -> bool:
-        if type(o) is VariableMatcher:
-            return o.normalized_name == self.normalized_name
-
-        if type(o) is str:
-            match = search_variable(o, "$@&%", ignore_errors=True)
-            base = match.base
-            if base is None:
-                return False
-
-            normalized = normalize(base)
-            return self.normalized_name == normalized
-
-        return False
-
-    def __hash__(self) -> int:
-        return hash(self.normalized_name)
-
-    def __str__(self) -> str:
-        return self.name
-
-    def __repr__(self) -> str:
-        return f"{type(self).__name__}(name={self.name!r})"
-
-
 class VariableDefinitionType(Enum):
     VARIABLE = "suite variable"
     LOCAL_VARIABLE = "local variable"

robotcode/robot/diagnostics/errors.py

@@ -43,3 +43,4 @@ class Error:
     VARIABLE_OVERRIDDEN = "VariableOverridden"
     MODEL_ERROR = "ModelError"
     TOKEN_ERROR = "TokenError"
+    ASSIGN_MARK_ALLOWED_ONLY_ON_LAST_VAR = "AssignmentMarkAllowedOnlyOnLastVariable"

robotcode/robot/diagnostics/model_helper.py

@@ -253,7 +253,7 @@ class ModelHelper:
 
         return lib_entry, kw_namespace
 
-    match_extended = re.compile(
+    MATCH_EXTENDED = re.compile(
         r"""
     (.+?)          # base name (group 1)
     ([^\s\w].+)    # extended part (group 2)
@@ -500,9 +500,9 @@ class ModelHelper:
                     and sub_token.value[1:2] == "{"
                     and sub_token.value[-1:] == "}"
                 ):
-                    match = cls.match_extended.match(name[2:-1])
-                    if match is not None:
-                        base_name, _ = match.groups()
+                    extended_match = cls.MATCH_EXTENDED.match(name[2:-1])
+                    if extended_match is not None:
+                        base_name, _ = extended_match.groups()
                         name = f"{name[0]}{{{base_name.strip()}}}"
                         var = namespace.find_variable(
                             name,

robotcode/robot/diagnostics/namespace.py

@@ -55,6 +55,8 @@ from ..utils.ast import (
 from ..utils.stubs import Languages
 from ..utils.variables import (
     BUILTIN_VARIABLES,
+    InvalidVariableError,
+    VariableMatcher,
     is_scalar_assign,
     is_variable,
     search_variable,
@@ -66,7 +68,6 @@ from .entities import (
     EnvironmentVariableDefinition,
     GlobalVariableDefinition,
     Import,
-    InvalidVariableError,
     LibraryEntry,
     LibraryImport,
     LocalVariableDefinition,
@@ -76,7 +77,6 @@ from .entities import (
     TestCaseDefinition,
     TestVariableDefinition,
     VariableDefinition,
-    VariableMatcher,
     VariablesEntry,
     VariablesImport,
 )

robotcode/robot/diagnostics/namespace_analyzer.py

@@ -54,13 +54,20 @@ 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.variables import (
+    InvalidVariableError,
+    VariableMatcher,
+    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,
     TagDefinition,
@@ -68,7 +75,6 @@ from .entities import (
     TestVariableDefinition,
     VariableDefinition,
     VariableDefinitionType,
-    VariableMatcher,
     VariableNotFoundDefinition,
 )
 from .errors import DIAGNOSTICS_SOURCE_NAME, Error
@@ -186,19 +192,18 @@ class NamespaceAnalyzer(Visitor):
         if name_token is None:
             return
 
-        name = name_token.value
-
-        if name is not None:
-            match = search_variable(name, ignore_errors=True)
-            if not match.is_assign(allow_assign_mark=True):
+        if name_token.value is not None:
+            matcher = search_variable(
+                name_token.value[:-1].rstrip() if name_token.value.endswith("=") else name_token.value,
+                ignore_errors=True,
+            )
+            if not matcher.is_assign(allow_assign_mark=True) or matcher.name is None:
                 return
 
-            if name.endswith("="):
-                name = name[:-1].rstrip()
+            name = matcher.name
+
+            stripped_name_token = strip_variable_token(name_token, matcher=matcher)
 
-            stripped_name_token = strip_variable_token(
-                Token(name_token.type, name, name_token.lineno, name_token.col_offset, name_token.error)
-            )
             r = range_from_token(stripped_name_token)
 
             existing_var = self._find_variable(name)
@@ -413,7 +418,7 @@ class NamespaceAnalyzer(Visitor):
         self, token: Token, severity: DiagnosticSeverity = DiagnosticSeverity.ERROR
     ) -> None:
         for var_token, var in self._iter_expression_variables_from_token(token):
-            self._handle_find_variable_result(token, var_token, var, severity)
+            self._handle_find_variable_result(var_token, var, severity)
 
     def _append_error_from_node(
         self,
@@ -479,11 +484,10 @@ class NamespaceAnalyzer(Visitor):
 
     def _analyze_token_variables(self, token: Token, severity: DiagnosticSeverity = DiagnosticSeverity.ERROR) -> None:
         for var_token, var in self._iter_variables_from_token(token):
-            self._handle_find_variable_result(token, var_token, var, severity)
+            self._handle_find_variable_result(var_token, var, severity)
 
     def _handle_find_variable_result(
         self,
-        token: Token,
         var_token: Token,
         var: VariableDefinition,
         severity: DiagnosticSeverity = DiagnosticSeverity.ERROR,
@@ -664,6 +668,9 @@ class NamespaceAnalyzer(Visitor):
             else:
                 self._keyword_references[result].add(Location(self._namespace.document_uri, kw_range))
 
+                if result.is_embedded:
+                    self._analyze_token_variables(keyword_token)
+
                 if result.errors:
                     self._append_diagnostics(
                         range=kw_range,
@@ -1016,7 +1023,6 @@ class NamespaceAnalyzer(Visitor):
             )
             return
 
-        self._analyze_token_variables(keyword_token)
         self._analyze_statement_variables(node)
 
         self._analyze_keyword_call(
@@ -1224,25 +1230,61 @@ class NamespaceAnalyzer(Visitor):
                 pass
 
     def _analyze_assign_statement(self, node: Statement) -> None:
+        token_with_assign_mark: Optional[Token] = None
         for assign_token in node.get_tokens(Token.ASSIGN):
             variable_token = self._get_variable_token(assign_token)
 
+            if token_with_assign_mark is not None:
+                r = range_from_token(token_with_assign_mark)
+                r.start.character = r.end.character - 1
+                self._append_diagnostics(
+                    range=r,
+                    message="Assign mark '=' can be used only with the last variable.",
+                    severity=DiagnosticSeverity.ERROR,
+                    code=Error.ASSIGN_MARK_ALLOWED_ONLY_ON_LAST_VAR,
+                )
+
+            if assign_token.value.endswith("="):
+                token_with_assign_mark = assign_token
+
             try:
                 if variable_token is not None:
                     matcher = VariableMatcher(variable_token.value)
-                    existing_var = next(
-                        (
-                            v
-                            for k, v in self._variables.items()
-                            if k == matcher
-                            and v.type in [VariableDefinitionType.ARGUMENT, VariableDefinitionType.LOCAL_VARIABLE]
-                        ),
-                        None,
-                    )
+                    stripped_variable_token = strip_variable_token(variable_token, matcher=matcher)
+                    if matcher.name is None:
+                        return
+
+                    if matcher.items:
+                        existing_var = self._find_variable(matcher.name)
+                        if existing_var is None:
+                            self._handle_find_variable_result(
+                                stripped_variable_token,
+                                VariableNotFoundDefinition(
+                                    stripped_variable_token.lineno,
+                                    stripped_variable_token.col_offset,
+                                    stripped_variable_token.lineno,
+                                    stripped_variable_token.end_col_offset,
+                                    self._namespace.source,
+                                    matcher.name,
+                                    stripped_variable_token,
+                                ),
+                            )
+                            return
+                    else:
+                        existing_var = next(
+                            (
+                                v
+                                for k, v in self._variables.items()
+                                if k == matcher
+                                and v.type in [VariableDefinitionType.ARGUMENT, VariableDefinitionType.LOCAL_VARIABLE]
+                            ),
+                            None,
+                        )
+
                     if existing_var is None:
                         var_def = LocalVariableDefinition(
-                            name=variable_token.value,
-                            name_token=strip_variable_token(variable_token),
+                            name=matcher.name,
+                            name_token=stripped_variable_token,
                             line_no=variable_token.lineno,
                             col_offset=variable_token.col_offset,
                             end_line_no=variable_token.lineno,
@@ -1256,7 +1298,7 @@ class NamespaceAnalyzer(Visitor):
                         self._variable_references[existing_var].add(
                             Location(
                                 self._namespace.document_uri,
-                                range_from_token(strip_variable_token(variable_token)),
+                                range_from_token(stripped_variable_token),
                             )
                         )
 
@@ -1747,9 +1789,9 @@ class NamespaceAnalyzer(Visitor):
                     and var_token.value[1:2] == "{"
                     and var_token.value[-1:] == "}"
                 ):
-                    match = ModelHelper.match_extended.match(name[2:-1])
-                    if match is not None:
-                        base_name, _ = match.groups()
+                    extended_match = ModelHelper.MATCH_EXTENDED.match(name[2:-1])
+                    if extended_match is not None:
+                        base_name, _ = extended_match.groups()
                         name = f"{name[0]}{{{base_name.strip()}}}"
                         var = self._find_variable(name)
                         sub_sub_token = Token(

robotcode/robot/utils/ast.py

@@ -11,6 +11,7 @@ from robot.parsing.lexer.tokens import Token
 from robot.parsing.model.statements import EmptyLine, Statement
 from robotcode.core.lsp.types import Position, Range
 
+from ..utils.variables import VariableMatcher, search_variable
 from . import get_robot_version
 from .visitor import Visitor
 
@@ -325,23 +326,22 @@ def iter_over_keyword_names_and_owners(
             yield ".".join(tokens[:i]), ".".join(tokens[i:])
 
 
-def strip_variable_token(token: Token) -> Token:
-    if (
-        token.type == Token.VARIABLE
-        and token.value[:1] in "$@&%"
-        and token.value[1:2] == "{"
-        and token.value[-1:] == "}"
-    ):
-        value = token.value[2:-1]
-
-        stripped_value = value.lstrip()
-        stripped_offset = len(value) - len(stripped_value)
-        return Token(
-            token.type,
-            stripped_value.rstrip(),
-            token.lineno,
-            token.col_offset + 2 + stripped_offset,
-        )
+def strip_variable_token(token: Token, identifiers: str = "$@&%*", matcher: Optional[VariableMatcher] = None) -> Token:
+    if token.type == Token.VARIABLE:
+        if matcher is None:
+            matcher = search_variable(token.value, identifiers, ignore_errors=True)
+
+        if matcher.is_variable():
+            value = matcher.base
+
+            stripped_value = value.lstrip()
+            stripped_offset = len(value) - len(stripped_value)
+            return Token(
+                token.type,
+                matcher.base.strip(),
+                token.lineno,
+                token.col_offset + 2 + stripped_offset,
+            )
 
     return token
 

robotcode/robot/utils/variables.py

@@ -1,12 +1,92 @@
 import functools
-from typing import Optional, Tuple, cast
+from typing import Any, 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
+from robotcode.robot.utils.match import normalize
+
+
+class InvalidVariableError(Exception):
+    pass
+
+
+class VariableMatcher:
+    def __init__(self, string: str, identifiers: str = "$@&%", ignore_errors: bool = True) -> None:
+        self.string = string
+
+        self.match = robot_search_variable(string, identifiers=identifiers, ignore_errors=ignore_errors)
+
+        if not ignore_errors and self.match.base is None:
+            raise InvalidVariableError(f"Invalid variable '{string}'")
+
+        self.base = self.match.base
+        self.identifier = self.match.identifier
+        self.name = "%s{%s}" % (self.identifier, self.base.strip()) if self.base else None
+        self.items = self.match.items
+        self.start = self.match.start
+        self.end = self.match.end
+        self.after = self.match.after
+        self.before = self.match.before
+
+        self.normalized_name = normalize(self.base) if self.base else None
+
+    def __eq__(self, o: object) -> bool:
+        if self.normalized_name is None:
+            return False
+
+        if type(o) is VariableMatcher:
+            return o.normalized_name == self.normalized_name
+
+        if type(o) is str:
+            match = search_variable(o, "$@&%", ignore_errors=True)
+            base = match.base
+            if base is None:
+                return False
+
+            normalized = normalize(base)
+            return self.normalized_name == normalized
+
+        return False
+
+    def __hash__(self) -> int:
+        return hash(self.normalized_name)
+
+    def __str__(self) -> str:
+        return self.string
+
+    def __repr__(self) -> str:
+        return f"{type(self).__name__}(name={self.string!r})"
+
+    def resolve_base(self, variables: Any, ignore_errors: bool = False) -> None:
+        self.match.resolve_base(variables, ignore_errors)
+
+    def is_variable(self) -> bool:
+        return bool(self.match.is_variable())
+
+    def is_scalar_variable(self) -> bool:
+        return bool(self.match.is_scalar_variable())
+
+    def is_list_variable(self) -> bool:
+        return bool(self.match.is_list_variable())
+
+    def is_dict_variable(self) -> bool:
+        return bool(self.match.is_dict_variable())
+
+    def is_assign(self, allow_assign_mark: bool = False) -> bool:
+        return bool(self.match.is_assign(allow_assign_mark))
+
+    def is_scalar_assign(self, allow_assign_mark: bool = False) -> bool:
+        return bool(self.match.is_scalar_assign(allow_assign_mark))
+
+    def is_list_assign(self, allow_assign_mark: bool = False) -> bool:
+        return bool(self.match.is_list_assign(allow_assign_mark))
+
+    def is_dict_assign(self, allow_assign_mark: bool = False) -> bool:
+        return bool(self.match.is_dict_assign(allow_assign_mark))
+
 
 BUILTIN_VARIABLES = [
     "${CURDIR}",
@@ -63,8 +143,8 @@ def is_variable(string: str, identifiers: str = "$@&") -> bool:
 
 
 @functools.lru_cache(maxsize=8192)
-def search_variable(string: str, identifiers: str = "$@&%*", ignore_errors: bool = False) -> RobotVariableMatch:
-    return robot_search_variable(string, identifiers, ignore_errors)
+def search_variable(string: str, identifiers: str = "$@&%*", ignore_errors: bool = False) -> VariableMatcher:
+    return VariableMatcher(string, identifiers, ignore_errors)
 
 
 @functools.lru_cache(maxsize=8192)

{robotcode_robot-1.2.0.dist-info → robotcode_robot-1.3.0.dev1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: robotcode-robot
-Version: 1.2.0
+Version: 1.3.0.dev1
 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.4.0,>=3.2.0
-Requires-Dist: robotcode-core==1.2.0
+Requires-Dist: robotcode-core==1.3.0-dev1
 Requires-Dist: robotframework>=4.1.0
 Requires-Dist: tomli>=1.1.0; python_version < '3.11'
 Description-Content-Type: text/markdown

{robotcode_robot-1.2.0.dist-info → robotcode_robot-1.3.0.dev1.dist-info}/RECORD

@@ -1,32 +1,32 @@
 robotcode/robot/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-robotcode/robot/__version__.py,sha256=MpAT5hgNoHnTtG1XRD_GV_A7QrHVU6vJjGSw_8qMGA4,22
+robotcode/robot/__version__.py,sha256=AWwdr9SBHDif_MzS0HLtSq_6ipM55E-2k8Y5FUnKvd8,27
 robotcode/robot/py.typed,sha256=bWew9mHgMy8LqMu7RuqQXFXLBxh2CRx0dUbSx-3wE48,27
 robotcode/robot/config/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 robotcode/robot/config/loader.py,sha256=qrP810HNMDpqhXopWa0dOa0Wq_zQfVctsNYKY6sLKGI,8654
-robotcode/robot/config/model.py,sha256=sgr6-4_E06g-yIXW41Z-NtIXZ_7JMmR5WvUD7kTUqu4,89106
+robotcode/robot/config/model.py,sha256=lN12CbUh_t0tMfMQpCi2Clcnpf8YTrh4KD1pbl6vpks,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=duLbcKzwqlCC1tBvJY8ASYh2LcIoCSs8_NgQ8NUQ7VU,3186
 robotcode/robot/diagnostics/diagnostics_modifier.py,sha256=6zJdXBd6g1QM12XJbsHd8gNNysECMnWlne3q8XNgBDo,9797
 robotcode/robot/diagnostics/document_cache_helper.py,sha256=5H0S7qDCeoEmqjMLUE7EQy9iZcZTYIUl5H1Pdvn5s5I,23886
-robotcode/robot/diagnostics/entities.py,sha256=I55YMxXpl7C1Sx6GgxRqb7vWMK7uWIoB7GhR1X9b66c,12983
-robotcode/robot/diagnostics/errors.py,sha256=RGnE4KCgNxQ58hNMBuAD3Q-qWqZVWZSZsCnhBGtQScw,1975
+robotcode/robot/diagnostics/entities.py,sha256=mcEg2DXhymqhwRLuhFcuErcZR_46XrqFI1JV4_0NIOo,11872
+robotcode/robot/diagnostics/errors.py,sha256=irVOZIcnpf611c9BdWXWpRu2esEl6SSN0EvZjA7p3bY,2060
 robotcode/robot/diagnostics/imports_manager.py,sha256=hu4Wp9b8J1jk55-NBqK2teQieWQF5D8LKxM5fyaxI1U,61156
 robotcode/robot/diagnostics/keyword_finder.py,sha256=dm4BA0ccp5V4C65CkSYUJUNXegSmvG24uu09T3eL6a4,17319
 robotcode/robot/diagnostics/library_doc.py,sha256=ruHS1bjOae0v4HQ2zH-B0baP_zs8BFa7mjsIb8tyvp4,100541
-robotcode/robot/diagnostics/model_helper.py,sha256=nq78e6TQ9Anvz_VSLW560lRTKrRjBsh7NoWttEvJ2hw,30973
-robotcode/robot/diagnostics/namespace.py,sha256=qSE-1z8U8AoE7HyY-cUMLgaEETjMB3gQr3IHLVdgFSU,78941
-robotcode/robot/diagnostics/namespace_analyzer.py,sha256=ksa9Mmexnvo8XWscm-OLqG9jd2lxetYLtmVx0KgCkj4,76047
+robotcode/robot/diagnostics/model_helper.py,sha256=RmKg1t5qsbSbW5uiehpFzJt157gDSQ1ayzXlur26AGI,31000
+robotcode/robot/diagnostics/namespace.py,sha256=J7Lwk4njBNlJ7C16nCB1QUZJoy8QmEqRCzfpU6-h56E,78941
+robotcode/robot/diagnostics/namespace_analyzer.py,sha256=Ybj7_dPdQHtuXenonCS_eVZaeV7-_TgFIUDGB9Hjz-c,77846
 robotcode/robot/diagnostics/workspace_config.py,sha256=gyKR5z-HpnjxPAui3YujgeZqXX7RYBO_ErGVlk7vnGc,2689
 robotcode/robot/utils/__init__.py,sha256=OjNPMn_XSnfaMCyKd8Kmq6vlRt6mIGlzW4qiiD3ykUg,447
-robotcode/robot/utils/ast.py,sha256=m5pNr2m84lmPP4yIstq5RHjLrj0u8RsSmy6iCXBnV4g,11092
+robotcode/robot/utils/ast.py,sha256=MmDs0EXa-GvGo-5Jf96alz5vDcQlksoIStvEOsqiVGk,11275
 robotcode/robot/utils/markdownformatter.py,sha256=v2p4T-d0wc0SuUJ4iLJJg1pHjgIA6dZX4l_XnZIXjXM,11690
 robotcode/robot/utils/match.py,sha256=9tG1OD9KS1v9ocWgsERSf6z_w9gAeE5LourNUYHzvTM,653
 robotcode/robot/utils/robot_path.py,sha256=Z-GVBOPA_xeD20bCJi4_AWaU0eQWvCym-YFtyRpXARE,1767
 robotcode/robot/utils/stubs.py,sha256=umugZYAyneFNgqRJBRMJPzm0u0B_TH8Sx_y-ykXnxpw,351
-robotcode/robot/utils/variables.py,sha256=-ldL8mRRSYYW2pwlm8IpoDeQcG6LYBqaYyV_7U3xsIc,2174
+robotcode/robot/utils/variables.py,sha256=zwRiorUiHp5GTmzLrJAhiVopcJC6-RywEHArKRtYzMY,4814
 robotcode/robot/utils/visitor.py,sha256=nP3O0qh3YYuxR6S8wYJRBFfNwIVgsgohURBlrnFkRYQ,2299
-robotcode_robot-1.2.0.dist-info/METADATA,sha256=Dd5RTDSIrkMDhJ9Rdm1I2imabCEtbN8T0lkOtqIK2dE,2238
-robotcode_robot-1.2.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-robotcode_robot-1.2.0.dist-info/licenses/LICENSE.txt,sha256=B05uMshqTA74s-0ltyHKI6yoPfJ3zYgQbvcXfDVGFf8,10280
-robotcode_robot-1.2.0.dist-info/RECORD,,
+robotcode_robot-1.3.0.dev1.dist-info/METADATA,sha256=dfSkzDRkqOMQfLyc0SBov-HUVpOf3J02y7ECAXXdxmI,2248
+robotcode_robot-1.3.0.dev1.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+robotcode_robot-1.3.0.dev1.dist-info/licenses/LICENSE.txt,sha256=B05uMshqTA74s-0ltyHKI6yoPfJ3zYgQbvcXfDVGFf8,10280
+robotcode_robot-1.3.0.dev1.dist-info/RECORD,,