robotcode-analyze 2.7.0__tar.gz → 2.8.0.dev8__tar.gz

{robotcode_analyze-2.7.0 → robotcode_analyze-2.8.0.dev8}/.gitignore

@@ -279,6 +279,9 @@ dist
 # vuepress build output
 .vuepress/dist
 
+# Astro (documentation site)
+docs/.astro/
+
 # Serverless directories
 .serverless/
 
@@ -339,7 +342,7 @@ bundled/libs
 # .agents
 .agents/
 skills-lock.json
-.claude
+#.claude
 
 # sarif files
 /**/*.sarif.json

{robotcode_analyze-2.7.0 → robotcode_analyze-2.8.0.dev8}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.4
+Metadata-Version: 2.5
 Name: robotcode-analyze
-Version: 2.7.0
+Version: 2.8.0-dev.8
 Summary: RobotCode analyze plugin for Robot Framework
 Project-URL: Homepage, https://robotcode.io
 Project-URL: Donate, https://opencollective.com/robotcode
@@ -20,14 +20,15 @@ Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
 Classifier: Programming Language :: Python :: 3.14
+Classifier: Programming Language :: Python :: 3.15
 Classifier: Programming Language :: Python :: Implementation :: CPython
 Classifier: Programming Language :: Python :: Implementation :: PyPy
 Classifier: Topic :: Utilities
 Classifier: Typing :: Typed
 Requires-Python: >=3.10
-Requires-Dist: robotcode-plugin==2.7.0
-Requires-Dist: robotcode-robot==2.7.0
-Requires-Dist: robotcode==2.7.0
+Requires-Dist: robotcode-plugin==2.8.0-dev.8
+Requires-Dist: robotcode-robot==2.8.0-dev.8
+Requires-Dist: robotcode==2.8.0-dev.8
 Requires-Dist: robotframework>=5.0.0
 Description-Content-Type: text/markdown
 

{robotcode_analyze-2.7.0 → robotcode_analyze-2.8.0.dev8}/pyproject.toml

@@ -18,6 +18,7 @@ classifiers = [
   "Programming Language :: Python :: 3.12",
   "Programming Language :: Python :: 3.13",
   "Programming Language :: Python :: 3.14",
+  "Programming Language :: Python :: 3.15",
   "Programming Language :: Python :: Implementation :: CPython",
   "Programming Language :: Python :: Implementation :: PyPy",
   "Operating System :: OS Independent",
@@ -28,9 +29,9 @@ classifiers = [
 ]
 dependencies = [
   "robotframework>=5.0.0",
-  "robotcode-plugin==2.7.0",
-  "robotcode-robot==2.7.0",
-  "robotcode==2.7.0",
+  "robotcode-plugin==2.8.0-dev.8",
+  "robotcode-robot==2.8.0-dev.8",
+  "robotcode==2.8.0-dev.8",
 ]
 dynamic = ["version"]
 

robotcode_analyze-2.8.0.dev8/src/robotcode/analyze/__version__.py

@@ -0,0 +1 @@
+__version__ = "2.8.0-dev.8"

{robotcode_analyze-2.7.0 → robotcode_analyze-2.8.0.dev8}/src/robotcode/analyze/cache/cli.py

@@ -43,7 +43,7 @@ def _resolve_cache(
     cache_base_path = root_folder or Path.cwd()
     if analyzer_config is not None and isinstance(analyzer_config, AnalyzeConfig):
         if analyzer_config.cache is not None and analyzer_config.cache.cache_dir is not None:
-            cache_base_path = Path(analyzer_config.cache.cache_dir)
+            cache_base_path = cache_base_path / analyzer_config.cache.cache_dir
 
     cache_base_path = resolve_cache_base_path(cache_base_path)
 
@@ -271,7 +271,9 @@ def cache_list(app: Application, sections: Tuple[str, ...], patterns: Tuple[str,
                     entries = [e for e in db.list_entries(section) if _entry_matches(e.entry_name, patterns)]
                     if not entries:
                         continue
-                    lines.append(f"### {section.name.lower()} ({len(entries)} entries)")
+                    lines.append(
+                        f"### {section.name.lower()} ({len(entries)} {'entry' if len(entries) == 1 else 'entries'})"
+                    )
                     lines.append("")
                     lines.append("| Name | Size | Created | Modified |")
                     lines.append("|---|---:|---|---|")
@@ -292,7 +294,7 @@ def cache_list(app: Application, sections: Tuple[str, ...], patterns: Tuple[str,
                     if not entries:
                         continue
                     found = True
-                    app.echo(f"[{section.name.lower()}] ({len(entries)} entries)")
+                    app.echo(f"[{section.name.lower()}] ({len(entries)} {'entry' if len(entries) == 1 else 'entries'})")
                     for entry in entries:
                         size = _format_bytes(entry.meta_bytes + entry.data_bytes)
                         created = entry.created_at or "—"
@@ -360,11 +362,11 @@ def cache_clear(app: Application, sections: Tuple[str, ...], paths: Tuple[Path,
             for section in selected:
                 count = db.clear_section(section)
                 total += count
-                app.echo(f"Cleared {count} entries from {section.name.lower()}.")
+                app.echo(f"Cleared {count} {'entry' if count == 1 else 'entries'} from {section.name.lower()}.")
         else:
             total = db.clear_all()
 
-        app.echo(f"Removed {total} entries total.")
+        app.echo(f"Removed {total} {'entry' if total == 1 else 'entries'} total.")
     finally:
         db.close()
 
@@ -390,7 +392,7 @@ def _resolve_cache_root(
     cache_base_path = root_folder or Path.cwd()
     if analyzer_config is not None and isinstance(analyzer_config, AnalyzeConfig):
         if analyzer_config.cache is not None and analyzer_config.cache.cache_dir is not None:
-            cache_base_path = Path(analyzer_config.cache.cache_dir)
+            cache_base_path = cache_base_path / analyzer_config.cache.cache_dir
 
     cache_base_path = resolve_cache_base_path(cache_base_path)
 

{robotcode_analyze-2.7.0 → robotcode_analyze-2.8.0.dev8}/src/robotcode/analyze/cli.py

@@ -5,6 +5,7 @@ from robotcode.plugin import Application, pass_application
 from .__version__ import __version__
 from .cache.cli import cache_group
 from .code.cli import code
+from .dump_model import dump_model
 
 
 @click.group(
@@ -26,3 +27,4 @@ def analyze(app: Application) -> None:
 
 analyze.add_command(cache_group)
 analyze.add_command(code)
+analyze.add_command(dump_model)

{robotcode_analyze-2.7.0 → robotcode_analyze-2.8.0.dev8}/src/robotcode/analyze/code/cli.py

@@ -473,8 +473,8 @@ def code(
         Performs static code analysis to identify potential issues in the specified *PATHS*. The analysis detects syntax
         errors, missing keywords or variables, missing arguments, and other problems.
 
-        - **PATHS**: Can be individual files or directories. If no *PATHS* are provided, the current directory is
-          analyzed by default.
+        - **PATHS**: Can be individual files or directories. If no *PATHS* are provided, the whole project is
+          analyzed.
 
         The return code is a bitwise combination of the following values:
 

{robotcode_analyze-2.7.0 → robotcode_analyze-2.8.0.dev8}/src/robotcode/analyze/code/code_analyzer.py

@@ -136,6 +136,8 @@ class CodeAnalyzer(DiagnosticsContext):
                     # Always yield, even when empty: the result collector uses this to count analyzed files.
                     yield DocumentDiagnosticReport(document, diagnostics)
 
+            self.diagnostics.finish_folder(folder)
+
     def collect_documents(
         self, folder: WorkspaceFolder, paths: Iterable[Path] = (), filter_patterns: Iterable[str] = ()
     ) -> List[TextDocument]:
@@ -168,7 +170,12 @@ class CodeAnalyzer(DiagnosticsContext):
                     self.app.error(f"Error reading {file}: {e}")
                     continue
 
-        self.app.verbose(f"{file_counter} files in workspace folder '{folder.uri.to_path()}'")
-        self.app.verbose(f"Collected {len(documents)} files for analyzing in workspace folder '{folder.uri.to_path()}'")
+        self.app.verbose(
+            f"{file_counter} {'file' if file_counter == 1 else 'files'} in workspace folder '{folder.uri.to_path()}'"
+        )
+        self.app.verbose(
+            f"Collected {len(documents)} {'file' if len(documents) == 1 else 'files'} for analyzing "
+            f"in workspace folder '{folder.uri.to_path()}'"
+        )
 
         return documents

{robotcode_analyze-2.7.0 → robotcode_analyze-2.8.0.dev8}/src/robotcode/analyze/code/diagnostics_context.py

@@ -19,6 +19,9 @@ class DiagnosticHandlers:
     @event
     def document_collectors(sender, document: TextDocument) -> Optional[List[Diagnostic]]: ...
 
+    @event
+    def folder_finishers(sender, folder: WorkspaceFolder) -> None: ...
+
     def analyze_folder(self, folder: WorkspaceFolder) -> List[Union[List[Diagnostic], BaseException, None]]:
         return self.folder_analyzers(
             self,
@@ -42,6 +45,10 @@ class DiagnosticHandlers:
             return_exceptions=False,
         )
 
+    def finish_folder(self, folder: WorkspaceFolder) -> None:
+        """After the documents of a folder were analyzed and their diagnostics collected."""
+        self.folder_finishers(self, folder, return_exceptions=False)
+
 
 class DiagnosticsContext(ABC):
     @property

{robotcode_analyze-2.7.0 → robotcode_analyze-2.8.0.dev8}/src/robotcode/analyze/code/robot_framework_language_provider.py

@@ -58,10 +58,15 @@ class RobotFrameworkLanguageProvider(LanguageProvider):
         self.diagnostics_context.diagnostics.folder_analyzers.add(self.analyze_folder)
         self.diagnostics_context.diagnostics.document_analyzers.add(self.analyze_document)
         self.diagnostics_context.diagnostics.document_collectors.add(self.collect_diagnostics)
+        self.diagnostics_context.diagnostics.folder_finishers.add(self.finish_folder)
         if self.diagnostics_context.collect_unused:
             self.diagnostics_context.diagnostics.document_collectors.add(self.collect_unused_keywords)
             self.diagnostics_context.diagnostics.document_collectors.add(self.collect_unused_variables)
 
+    @property
+    def document_cache(self) -> DocumentsCacheHelper:
+        return self._document_cache
+
     def _update_python_path(self) -> None:
         root_path = (
             self.diagnostics_context.workspace.root_uri.to_path()
@@ -120,6 +125,10 @@ class RobotFrameworkLanguageProvider(LanguageProvider):
 
         return None
 
+    def finish_folder(self, sender: Any, folder: WorkspaceFolder) -> None:
+        # the cache is shared with the language server and other runs, so only files that do not exist lose entries
+        self._document_cache.remove_cached_analyses_of_missing_files(folder)
+
     def collect_diagnostics(self, sender: Any, document: TextDocument) -> Optional[List[Diagnostic]]:
         namespace = self._document_cache.get_namespace(document)
 

{robotcode_analyze-2.7.0 → robotcode_analyze-2.8.0.dev8}/src/robotcode/analyze/config.py

@@ -30,12 +30,14 @@ class ModifiersConfig(BaseOptions):
     extend_ignore: Optional[List[str]] = field(
         description="""
             Extend the diagnostics codes to ignore.
+            It takes effect in `[tool.robotcode-analyze.extend-modifiers]`, where it adds to the codes set so far,
+            for example in `robot.toml` when used in `.robot.toml`.
 
             Examples:
 
             ```toml
-            [tool.robotcode-analyze.modifiers]
-            extend_ignore = ["VariableNotFound", "multiple-keywords"]
+            [tool.robotcode-analyze.extend-modifiers]
+            extend-ignore = ["VariableNotFound", "multiple-keywords"]
             ```
         """,
         alias="extend-ignore",
@@ -55,12 +57,14 @@ class ModifiersConfig(BaseOptions):
     extend_error: Optional[List[str]] = field(
         description="""
             Extend the diagnostics codes to treat as errors.
+            It takes effect in `[tool.robotcode-analyze.extend-modifiers]`, where it adds to the codes set so far,
+            for example in `robot.toml` when used in `.robot.toml`.
 
             Examples:
 
             ```toml
-            [tool.robotcode-analyze.modifiers]
-            extend_error = ["VariableNotFound", "multiple-keywords"]
+            [tool.robotcode-analyze.extend-modifiers]
+            extend-error = ["VariableNotFound", "multiple-keywords"]
             ```
         """,
         alias="extend-error",
@@ -80,12 +84,14 @@ class ModifiersConfig(BaseOptions):
     extend_warning: Optional[List[str]] = field(
         description="""
             Extend the diagnostics codes to treat as warning.
+            It takes effect in `[tool.robotcode-analyze.extend-modifiers]`, where it adds to the codes set so far,
+            for example in `robot.toml` when used in `.robot.toml`.
 
             Examples:
 
             ```toml
-            [tool.robotcode-analyze.modifiers]
-            extend_warning = ["VariableNotFound", "multiple-keywords"]
+            [tool.robotcode-analyze.extend-modifiers]
+            extend-warning = ["VariableNotFound", "multiple-keywords"]
             ```
         """,
         alias="extend-warning",
@@ -105,12 +111,14 @@ class ModifiersConfig(BaseOptions):
     extend_information: Optional[List[str]] = field(
         description="""
             Extend the diagnostics codes to treat as information.
+            It takes effect in `[tool.robotcode-analyze.extend-modifiers]`, where it adds to the codes set so far,
+            for example in `robot.toml` when used in `.robot.toml`.
 
             Examples:
 
             ```toml
-            [tool.robotcode-analyze.modifiers]
-            extend_information = ["VariableNotFound", "multiple-keywords"]
+            [tool.robotcode-analyze.extend-modifiers]
+            extend-information = ["VariableNotFound", "multiple-keywords"]
             ```
         """,
         alias="extend-information",
@@ -130,12 +138,14 @@ class ModifiersConfig(BaseOptions):
     extend_hint: Optional[List[str]] = field(
         description="""
             Extend the diagnostics codes to treat as hint.
+            It takes effect in `[tool.robotcode-analyze.extend-modifiers]`, where it adds to the codes set so far,
+            for example in `robot.toml` when used in `.robot.toml`.
 
             Examples:
 
             ```toml
-            [tool.robotcode-analyze.modifiers]
-            extend_hint = ["VariableNotFound", "multiple-keywords"]
+            [tool.robotcode-analyze.extend-modifiers]
+            extend-hint = ["VariableNotFound", "multiple-keywords"]
             ```
         """,
         alias="extend-hint",
@@ -146,7 +156,15 @@ class ModifiersConfig(BaseOptions):
 class CacheConfig(BaseOptions):
     """Cache configuration."""
 
-    cache_dir: Optional[str] = field(description="Path to the cache directory.", alias="cache-dir")
+    cache_dir: Optional[str] = field(
+        description="""\
+            Path to the cache directory. A relative path counts from the project root.
+
+            `robotcode analyze` and the language server keep their cache there, in a `.robotcode_cache`
+            folder. For `robotcode analyze`, the `ROBOTCODE_CACHE_DIR` environment variable takes precedence.
+            """,
+        alias="cache-dir",
+    )
 
     ignored_libraries: Optional[List[str]] = field(
         description="""\
@@ -164,7 +182,11 @@ class CacheConfig(BaseOptions):
         alias="ignored-libraries",
     )
     extend_ignored_libraries: Optional[List[str]] = field(
-        description="Extend the ignored libraries setting.",
+        description="""\
+            Extend the ignored libraries setting.
+            It takes effect in `[tool.robotcode-analyze.extend-cache]`, where it adds to the list set so far,
+            for example in `robot.toml` when used in `.robot.toml`.
+            """,
         alias="extend-ignored-libraries",
     )
 
@@ -183,14 +205,18 @@ class CacheConfig(BaseOptions):
         alias="ignored-variables",
     )
     extend_ignored_variables: Optional[List[str]] = field(
-        description="Extend the ignored variables setting.",
+        description="""\
+            Extend the ignored variables setting.
+            It takes effect in `[tool.robotcode-analyze.extend-cache]`, where it adds to the list set so far,
+            for example in `robot.toml` when used in `.robot.toml`.
+            """,
         alias="extend-ignored-variables",
     )
 
     ignore_arguments_for_library: Optional[List[str]] = field(
         description="""\
             Specifies a list of libraries for which arguments will be ignored during analysis.
-            This is usefull if you have library that gets variables from a python file as arguments that contains
+            This is useful if you have a library that gets variables from a python file as arguments that contains
             complex data like big dictionaries or complex objects that **RobotCode** can't handle.
             You can specify a glob pattern that matches the library name or the source file.
 
@@ -207,7 +233,11 @@ class CacheConfig(BaseOptions):
         alias="ignore-arguments-for-library",
     )
     extend_ignore_arguments_for_library: Optional[List[str]] = field(
-        description="Extend the ignore arguments for library settings.",
+        description="""\
+            Extend the ignore arguments for library settings.
+            It takes effect in `[tool.robotcode-analyze.extend-cache]`, where it adds to the list set so far,
+            for example in `robot.toml` when used in `.robot.toml`.
+            """,
         alias="extend-ignore-arguments-for-library",
     )
 
@@ -277,7 +307,11 @@ class CodeConfig(BaseOptions):
         alias="exit-code-mask",
     )
     extend_exit_code_mask: Optional[ExitCodeMaskList] = field(
-        description="Extend the exit code mask setting.",
+        description="""\
+            Extend the exit code mask setting.
+            It takes effect in `[tool.robotcode-analyze.extend-code]`, where it adds to the mask set so far,
+            for example in `robot.toml` when used in `.robot.toml`.
+            """,
         alias="extend-exit-code-mask",
     )
 
@@ -367,7 +401,7 @@ class AnalyzeConfig(BaseOptions):
         description="""\
             Specifies a global [search order](https://robotframework.org/robotframework/latest/RobotFrameworkUserGuide.html#specifying-explicit-priority-between-libraries-and-resources)
             for libraries and resources.
-            This is usefull when you have libraries containing keywords with the same name. **RobotCode** is unable to
+            This is useful when you have libraries containing keywords with the same name. **RobotCode** is unable to
             analyze the library search order in a file specified with
                 [`Set Library Search Order`](https://robotframework.org/robotframework/latest/libraries/BuiltIn.html#Set%20Library%20Search%20Order),
             so you can define a global order here. Just make sure to call the `Set Library Search Order`
@@ -440,7 +474,6 @@ class AnalyzeConfig(BaseOptions):
             semantic_model=self.semantic_model if self.semantic_model is not None else False,
             cache=(
                 WorkspaceCacheConfig(
-                    # TODO savelocation
                     ignored_libraries=self.cache.ignored_libraries or [],
                     ignored_variables=self.cache.ignored_variables or [],
                     ignore_arguments_for_library=self.cache.ignore_arguments_for_library or [],
@@ -449,6 +482,7 @@ class AnalyzeConfig(BaseOptions):
                 if self.cache is not None
                 else WorkspaceCacheConfig()
             ),
+            cache_dir=self.cache.cache_dir if self.cache is not None else None,
             robot=AnalysisRobotConfig(
                 global_library_search_order=self.global_library_search_order or [],
                 load_library_timeout=self.load_library_timeout,

robotcode_analyze-2.8.0.dev8/src/robotcode/analyze/dump_model.py

@@ -0,0 +1,158 @@
+"""Hidden `robotcode analyze dump-model` command.
+
+Developer/diagnostic tool: builds the real namespace for a single file — same
+configuration path as `robotcode analyze code` (robot.toml, profiles,
+`-v`/`-V`/`-P` overrides) — with the semantic-model build forced on, and
+serializes the resulting `SemanticModel` to deterministic JSON. The JSON
+format carries no stability guarantee.
+"""
+
+import json
+from pathlib import Path
+from typing import Optional, Tuple
+
+import click
+
+from robotcode.core.utils.cli import show_hidden_arguments
+from robotcode.plugin import Application, pass_application
+from robotcode.robot.config.loader import load_robot_config_from_path
+from robotcode.robot.config.utils import get_config_files
+from robotcode.robot.diagnostics.semantic_analyzer.json_dump import model_to_dict
+
+from .code.code_analyzer import CodeAnalyzer
+from .code.robot_framework_language_provider import RobotFrameworkLanguageProvider
+from .config import AnalyzeConfig
+
+
+@click.command(name="dump-model", add_help_option=True, hidden=show_hidden_arguments())
+@click.option(
+    "-v",
+    "--variable",
+    metavar="name:value",
+    type=str,
+    multiple=True,
+    help="Set variables in the test data. see `robot --variable` option.",
+)
+@click.option(
+    "-V",
+    "--variablefile",
+    metavar="PATH",
+    type=str,
+    multiple=True,
+    help="Python or YAML file file to read variables from. see `robot --variablefile` option.",
+)
+@click.option(
+    "-P",
+    "--pythonpath",
+    metavar="PATH",
+    type=str,
+    multiple=True,
+    help="Additional locations where to search test libraries"
+    " and other extensions when they are imported. see `robot --pythonpath` option.",
+)
+@click.option(
+    "-o",
+    "--output",
+    metavar="FILE",
+    type=click.Path(dir_okay=False, writable=True, path_type=Path),
+    default=None,
+    help="Write the JSON dump to FILE instead of stdout.",
+)
+@click.argument("file", nargs=1, type=click.Path(exists=True, dir_okay=False, readable=True, path_type=Path))
+@pass_application
+def dump_model(
+    app: Application,
+    variable: Tuple[str, ...],
+    variablefile: Tuple[str, ...],
+    pythonpath: Tuple[str, ...],
+    output: Optional[Path],
+    file: Path,
+) -> None:
+    """\
+    Dumps the semantic model of a Robot Framework FILE as JSON.
+
+    Developer/diagnostic tool: the semantic-model build is forced regardless
+    of the `robotcode.experimental.semanticModel` setting. The JSON format is
+    not a stable interface and may change without notice.
+    """
+
+    config_files, root_folder, _ = get_config_files(
+        [file],
+        app.config.config_files,
+        root_folder=app.config.root,
+        no_vcs=app.config.no_vcs,
+        verbose_callback=app.verbose,
+    )
+
+    try:
+        robot_config = load_robot_config_from_path(
+            *config_files, extra_tools={"robotcode-analyze": AnalyzeConfig}, verbose_callback=app.verbose
+        )
+
+        analyzer_config = robot_config.tool.get("robotcode-analyze", None) if robot_config.tool is not None else None
+        if analyzer_config is None:
+            analyzer_config = AnalyzeConfig()
+
+        robot_profile = robot_config.combine_profiles(
+            *(app.config.profiles or []), verbose_callback=app.verbose, error_callback=app.error
+        ).evaluated_with_env()
+    except (TypeError, ValueError) as e:
+        raise click.ClickException(str(e)) from e
+
+    if variable:
+        if robot_profile.variables is None:
+            robot_profile.variables = {}
+        for v in variable:
+            name, value = v.split(":", 1) if ":" in v else (v, "")
+            robot_profile.variables.update({name: value})
+
+    if pythonpath:
+        if robot_profile.python_path is None:
+            robot_profile.python_path = []
+        robot_profile.python_path.extend(pythonpath)
+
+    if variablefile:
+        if robot_profile.variable_files is None:
+            robot_profile.variable_files = []
+        for vf in variablefile:
+            robot_profile.variable_files.append(vf)
+
+    analysis_config = analyzer_config.to_workspace_analysis_config()
+    analysis_config.semantic_model = True
+
+    analyzer = CodeAnalyzer(
+        app=app,
+        analysis_config=analysis_config,
+        robot_profile=robot_profile,
+        root_folder=root_folder,
+    )
+
+    provider = next((h for h in analyzer.language_handlers if isinstance(h, RobotFrameworkLanguageProvider)), None)
+    if provider is None:
+        raise click.ClickException("no Robot Framework language provider available")
+
+    try:
+        document = analyzer.workspace.documents.get_or_open_document(file.absolute())
+        namespace = provider.document_cache.get_namespace(document)
+        namespace.analyze()
+    except (SystemExit, KeyboardInterrupt):
+        raise
+    except BaseException as e:
+        raise click.ClickException(f"cannot analyze '{file}': {e}") from e
+
+    semantic_model = namespace.semantic_model
+    if semantic_model is None:
+        raise click.ClickException(f"no semantic model was built for '{file}'")
+
+    dump = model_to_dict(
+        semantic_model,
+        workspace_root=analyzer.root_folder,
+        source=str(document.uri.to_path()),
+    )
+    text = json.dumps(dump, indent=2, ensure_ascii=False)
+
+    if output is not None:
+        output.write_text(text + "\n", encoding="utf-8")
+        app.verbose(f"Semantic model written to {output}")
+    else:
+        click.echo(text)

robotcode_analyze-2.7.0/src/robotcode/analyze/__version__.py

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