testbench2robotframework 2.0.0__tar.gz → 2.0.1rc1__tar.gz

{testbench2robotframework-2.0.0 → testbench2robotframework-2.0.1rc1}/.gitignore

@@ -7,7 +7,6 @@ __pycache__/
 *.so
 ignore/
 .ruff_cache/
-tests/
 
 # Distribution / packaging
 .Python

{testbench2robotframework-2.0.0 → testbench2robotframework-2.0.1rc1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: testbench2robotframework
-Version: 2.0.0
+Version: 2.0.1rc1
 Summary: Robot Framework Code Generator from Keyword-Driven Tests in imbus TestBench 3.0 and newer
 Author-email: imbus AG <support@imbus.de>
 Requires-Python: >= 3.10
@@ -22,8 +22,10 @@ Requires-Dist: robotframework-tidy ; extra == "dev"
 Requires-Dist: datamodel-code-generator ; extra == "dev"
 Requires-Dist: ruff ; extra == "dev"
 Requires-Dist: twine ; extra == "dev"
+Requires-Dist: orjson ; extra == "fast"
 Project-URL: Repository, https://github.com/imbus/testbench2robotframework
 Provides-Extra: dev
+Provides-Extra: fast
 
 # TestBench2RobotFramework
 
@@ -33,14 +35,14 @@ This can be used for automated test execution with Robot Framework, triggered by
 
 ## Documentation
 
-The documentation is available in the [docs](./docs) folder of this repository.
+The documentation is available in the [TestBench Ecosystem Documentation](https://imbus.github.io/testbench-ecosystem-documentation/testbench2robotframework/intro).
 
 ## Releases
 
-Releases are published on GitHub and available via [PyPI](https://pypi.org/project/testbench2robotframework/).
+Releases are published on [GitHub](https://github.com/imbus/testbench2robotframework/releases) and available via [PyPI](https://pypi.org/project/testbench2robotframework/).
 
 ## Requirements
 
 - Python 3.10 or higher
-- TestBench version >= 4
+- TestBench version >= 4.1
 

{testbench2robotframework-2.0.0 → testbench2robotframework-2.0.1rc1}/README.md

@@ -6,13 +6,13 @@ This can be used for automated test execution with Robot Framework, triggered by
 
 ## Documentation
 
-The documentation is available in the [docs](./docs) folder of this repository.
+The documentation is available in the [TestBench Ecosystem Documentation](https://imbus.github.io/testbench-ecosystem-documentation/testbench2robotframework/intro).
 
 ## Releases
 
-Releases are published on GitHub and available via [PyPI](https://pypi.org/project/testbench2robotframework/).
+Releases are published on [GitHub](https://github.com/imbus/testbench2robotframework/releases) and available via [PyPI](https://pypi.org/project/testbench2robotframework/).
 
 ## Requirements
 
 - Python 3.10 or higher
-- TestBench version >= 4
+- TestBench version >= 4.1

{testbench2robotframework-2.0.0 → testbench2robotframework-2.0.1rc1}/docs/configuration/overview.md

@@ -85,6 +85,9 @@ file. This is noted per option below.
 | [`resource-mapping`](#library-mapping--resource-mapping) | `--resource-mapping` | ✅ | G | mapping (`{}`) |
 | [`forced-import`](#forced-import) | — | ✅ | G | table of lists (`{}`) |
 | [`metadata`](#metadata) | `--metadata` | ✅ | G | mapping (`{}`) |
+| [`attachments-directory`](#attachments-directory) | `--attachments-directory` | ✅ | G | path (empty) |
+| [`attachments-variable`](#attachments-variable) | — | ✅ | G | variable name (`ITB_ATTACHMENTS_DIR`) |
+| [`keep-extracted-report`](#keep-extracted-report) | — | ✅ | G · F | bool (`false`) |
 | [`merge-protocol`](#merge-protocol) | `--no-merge-protocol` | ✅ | F | bool (`true`) |
 | [`keyword-comment-style`](#keyword-comment-style) | — | ✅ | F | `STRUCTURED` \| `FLAT` (`STRUCTURED`) |
 | [`keyword-comment-max-depth`](#keyword-comment-max-depth) | — | ✅ | F | int (`5`) |
@@ -117,6 +120,94 @@ testbench2robotframework generate-tests -d ./suites.zip my_report.zip
 output-directory = "{root}/Generated"
 ```
 
+#### `output-directory` with `fetch-results`
+
+For `fetch-results` the option names the updated report. The input report is only
+read when `-d` is given; **without `-d` the input report itself is updated** and
+the original, unexecuted report is gone afterwards.
+
+| Input report | `-d` | Result |
+|---|---|---|
+| `report.zip` | `result.zip` | `result.zip` is created; `report.zip` is unchanged. |
+| `report.zip` | `result/` | `result/` is created (or merged into) as a directory; `report.zip` is unchanged. |
+| `report/` | `result.zip` | `result.zip` is created; `report/` is unchanged. |
+| `report/` | `result/` | `result/` is created (or merged into); `report/` is unchanged. |
+| `report.zip` | *none* | `report.zip` is **overwritten** with the updated report. |
+| `report/` | *none* | The files in `report/` are **updated in place**; no ZIP is created. |
+
+Keep the original report if you need it for a second run — for example to merge
+another execution with [`merge-protocol`](#merge-protocol) — or always pass `-d`.
+
+### `keep-extracted-report`
+
+Where a `.zip` report is extracted to while a command reads it. By default that is
+a temporary directory in the working directory, removed when the command is done.
+With `true` the report is extracted to a directory of the same name next to the
+ZIP (`report.zip` → `report/`), replacing that directory if it exists, and left
+there afterwards — for example to look at the report's attachments. Has no effect
+when the report is given as a directory. **Configuration file only.**
+
+- **Values:** `true` / `false`. Default: `false`.
+
+```toml
+keep-extracted-report = true
+```
+
+:::note
+Up to version 2.0 `fetch-results` always left the extracted report next to the
+ZIP. Set `keep-extracted-report = true` to keep that behaviour.
+:::
+
+### `attachments-directory`
+
+Where `generate-tests` copies the report's `attachments/` folder to — every
+attachment: representatives of reference data types (`representatives/DT-<key>/`),
+files attached to test case sets and test cases, and whatever else is in there.
+Empty (the default) exports nothing. The target is emptied before copying.
+
+- **Values:** a path, empty, or a path starting with `{root}`. Default: empty.
+- **CLI:** `--attachments-directory`.
+
+How the path is given decides how the generated suites refer to it:
+
+| Value | Copied to | Value of the [attachments variable](#attachments-variable) in every suite |
+|---|---|---|
+| relative, e.g. `attachments` | `<output-directory>/attachments` | `${CURDIR}/../attachments` — relative to the suite (`..` per directory level), so the output directory can be moved as a whole |
+| absolute, e.g. `/data/run1/attachments` | exactly there | `/data/run1/attachments` |
+| `{root}/…` | the absolute path it resolves to | that absolute path |
+
+With a `.zip` `output-directory`, a relative attachments directory ends up inside
+the archive.
+
+```bash
+testbench2robotframework generate-tests --attachments-directory attachments my_report.zip
+robot ./Generated                                   # finds the attachments by itself
+```
+```toml
+attachments-directory = "attachments"
+```
+
+### `attachments-variable`
+
+The Robot Framework variable through which generated keyword calls address
+attachments, for example
+`${ITB_ATTACHMENTS_DIR}/representatives/DT-6917529030000126275/Vorlage.xml`.
+When [`attachments-directory`](#attachments-directory) is set, every suite whose
+keyword calls refer to the variable gets a `*** Variables ***` section defining it
+(see the table above) — suites without attachments and `__init__.robot` files stay
+as they are. A `--variable` on the `robot` command line still overrides that
+default. Without `attachments-directory` no section is written and the variable
+has to be passed to `robot`. **Configuration file only.**
+
+- **Values:** a variable name without `${}`, or empty. Default: `ITB_ATTACHMENTS_DIR`.
+- **Empty:** attachments are written as paths relative to the report's
+  `attachments` folder (`representatives/DT-…/Vorlage.xml`) and no section is
+  generated — for runs started from inside that folder.
+
+```toml
+attachments-variable = "ITB_ATTACHMENTS_DIR"
+```
+
 ### `create-output-zip`
 
 For `generate-tests` only: in addition to the normal directory output, also

{testbench2robotframework-2.0.0 → testbench2robotframework-2.0.1rc1}/docs/usage/fetch_results.md

@@ -36,8 +36,10 @@ TestBench report the suites were generated from.
 - **In:** the original TestBench report (the same directory or ZIP file the suites
   were generated from) **and** the Robot Framework `output.xml` of the run.
 - **Out:** an updated TestBench JSON report you can import back into TestBench.
-  With `-d` it is written to a new location; without it, the input report is
-  updated in place.
+  With `-d` it is written to a new location and the input report stays untouched;
+  **without `-d` the input report is overwritten**. All six input/output
+  combinations are listed under
+  [`output-directory` with `fetch-results`](../configuration/overview.md#output-directory-with-fetch-results).
 
 ![Robot Framework log.html](../media/robot-suite-log.png)<br />
 **Img-1:** Robot Framework `log.html` of a test run
@@ -146,6 +148,34 @@ is controlled by
 decides what happens when an attachment of the same name already exists. Files
 larger than 10 MB are skipped with an error message.
 
+### The `itb-reference:` marker
+
+A marker is the word `itb-reference:` followed by one value without whitespace.
+The marker is removed from the message before it becomes the execution comment;
+a message may carry several markers.
+
+```robotframework
+Set Test Message    Screenshot taken.\n\nitb-reference: screenshot.png    append=True
+```
+
+The value is resolved like a URI reference:
+
+| Value | Meaning |
+|---|---|
+| `screenshot.png`, `results/run.zip` | **Relative** to the directory of the `output.xml` — the Robot output directory. |
+| `file:///var/log/run.zip`, `file:///C:/log/run.zip` | **Absolute** path. A `file:` URI is always absolute ([RFC 8089](https://www.rfc-editor.org/rfc/rfc8089)); `file:///run.zip` is the file `run.zip` in the file system root, *not* in the output directory. |
+| `my%20file.png` | Percent-encoding is decoded. |
+
+A relative value is the right choice for files Robot wrote into its output
+directory, and the only form that resolves to the same file both here and in a
+browser showing `log.html`. Use an absolute `file:` URI for files outside the
+output directory. Both are looked up first as given (relative to the current
+working directory), then relative to the `output.xml`.
+
+A file that cannot be found is skipped with a warning; with
+`reference-behaviour = "REFERENCE"` an absolute path is stored even if it does
+not exist on the machine running `fetch-results`.
+
 ---
 
 ## The full round trip

{testbench2robotframework-2.0.0 → testbench2robotframework-2.0.1rc1}/docs/usage/generate_tests.md

@@ -260,3 +260,38 @@ Higher-level (compound) TestBench keywords can be rendered as a Robot Framework
 Extra `Metadata` entries — including values pulled from the test case set model
 via `{$tcs...}` placeholders — can be added to every suite with
 [`metadata`](../configuration/overview.md#metadata).
+
+### Use attachments as parameter values
+
+A parameter whose representative is a file attached in TestBench arrives in the
+generated keyword call as a path into the report's attachments:
+
+```robotframework
+${message}    Get File    ${ITB_ATTACHMENTS_DIR}/representatives/DT-6917529030000126275/file.xml
+```
+
+TestBench exports such files to `attachments/representatives/DT-<data type key>/`
+inside the report. Two ways to make them available at execution time:
+
+- Let `generate-tests` copy them next to the suites with
+  [`attachments-directory`](../configuration/overview.md#attachments-directory).
+  Every suite that uses attachments then defines `${ITB_ATTACHMENTS_DIR}`
+  relative to itself and the output directory runs as it is:
+
+  ```bash
+  testbench2robotframework generate-tests --attachments-directory attachments my_report.zip
+  robot ./Generated
+  ```
+
+- Or keep the report where it is and point the variable to its `attachments`
+  directory when running:
+
+  ```bash
+  robot --variable ITB_ATTACHMENTS_DIR:/path/to/my_report/attachments ./Generated
+  ```
+
+The variable's name is set by
+[`attachments-variable`](../configuration/overview.md#attachments-variable).
+Inside compound keywords the data type is taken from the outermost call the value
+was passed down from. If no data type can be found, the file name is written as is
+and a warning is logged.

{testbench2robotframework-2.0.0 → testbench2robotframework-2.0.1rc1}/pyproject.toml

@@ -24,6 +24,8 @@ dependencies = [
 ]
 
 [project.optional-dependencies]
+# Faster reading and writing of large reports; used automatically when installed.
+fast = ["orjson"]
 dev = [
   "build",
   "check-manifest",
@@ -112,6 +114,10 @@ exclude = [
 [tool.pytest.ini_options]
 minversion = "6.0"
 addopts = "-ra --spec"
+# Test classes end in 'Tests'. The default 'Test*' would also match the TestBench
+# model classes (TestCaseSet, TestStructureTree, ...) imported into test modules
+# and flood the run with PytestCollectionWarnings.
+python_classes = "*Tests"
 testpaths = [
     "tests",
 ]

{testbench2robotframework-2.0.0 → testbench2robotframework-2.0.1rc1}/testbench2robotframework/__init__.py

@@ -17,4 +17,4 @@ suites and enhancing the TestBench report with execution results from Robot Fram
 
 from .testbench2robotframework import testbench2robotframework  # noqa: F401
 
-__version__ = "2.0.0"
+__version__ = "2.0.1rc1"

testbench2robotframework-2.0.1rc1/testbench2robotframework/attachments.py

@@ -0,0 +1,66 @@
+"""Exporting the attachments of a TestBench report next to the generated suites.
+
+The report keeps every attached file below 'attachments/': representatives of
+reference data types under 'representatives/DT-<key>/', files of test case sets
+and test cases directly in the folder, and whatever else a TestBench extension
+put there. The whole folder is copied - the library does not know all consumers.
+"""
+
+from __future__ import annotations
+
+import posixpath
+import shutil
+from dataclasses import dataclass
+from pathlib import Path, PurePath
+
+from .config import Configuration
+from .log import logger
+from .utils import get_generation_directory, resolve_root_placeholder
+
+REPORT_ATTACHMENTS_DIR = "attachments"
+
+
+@dataclass(frozen=True)
+class AttachmentsExport:
+    """Where the attachments go, and how the suites refer to that place."""
+
+    target: Path
+    # Set when 'attachments-directory' is a relative path: the target lies inside the
+    # output directory and suites address it relative to themselves, so the whole
+    # output directory stays movable. None for an absolute target.
+    relative_to_output: PurePath | None
+
+
+def attachments_export(config: Configuration) -> AttachmentsExport | None:
+    if not config.attachments_directory:
+        return None
+    given = Path(resolve_root_placeholder(config.attachments_directory))
+    if given.is_absolute():
+        return AttachmentsExport(given, None)
+    output_directory = get_generation_directory(config.output_directory)
+    return AttachmentsExport(output_directory.with_suffix("") / given, PurePath(given))
+
+
+def variable_value(export: AttachmentsExport, suite_directory: PurePath) -> str:
+    """The value the attachments variable gets in a suite lying in 'suite_directory'.
+
+    'suite_directory' is relative to the output directory. Forward slashes
+    throughout; Robot Framework and Python accept them on every platform.
+    """
+    if export.relative_to_output is None:
+        return export.target.as_posix()
+    relative = posixpath.relpath(export.relative_to_output.as_posix(), suite_directory.as_posix())
+    return f"${{CURDIR}}/{relative}"
+
+
+def copy_attachments(report_directory: Path, target: Path) -> None:
+    """Copies the report's attachments folder to 'target', replacing what is there."""
+    if target.exists():
+        shutil.rmtree(target)
+    source = report_directory / REPORT_ATTACHMENTS_DIR
+    if not source.is_dir():
+        logger.debug(f"The report has no '{REPORT_ATTACHMENTS_DIR}' folder.")
+        target.mkdir(parents=True)
+        return
+    shutil.copytree(source, target)
+    logger.info(f"Attachments copied to {target}.")

{testbench2robotframework-2.0.0 → testbench2robotframework-2.0.1rc1}/testbench2robotframework/cli.py

@@ -100,6 +100,13 @@ def testbench2robotframework_cli():
     type=click.Path(path_type=Path),
     help="Directory or ZIP archive containing the generated test suites.",
 )
+@click.option(
+    "--attachments-directory",
+    type=str,
+    help="""Copies the report's attachments there. A relative path lies inside the
+    output directory and the suites address it relative to themselves; an absolute
+    path is used as given. Without it, attachments are not exported.""",
+)
 @click.option(
     "--compound-keyword-logging",
     type=click.Choice(["GROUP", "COMMENT", "NONE"], case_sensitive=False),
@@ -173,6 +180,7 @@ def testbench2robotframework_cli():
 )
 @click.argument("testbench-report", type=click.Path(path_type=Path))
 def generate_tests(  # noqa: PLR0913
+    attachments_directory: str | None,
     clean: bool | None,
     compound_keyword_logging: str,
     config: Path,
@@ -244,6 +252,9 @@ def generate_tests(  # noqa: PLR0913
     configuration["resource-root"] = list(resource_root) or configuration.get(
         "resource-root", DEFAULT_RESOURCE_ROOTS
     )
+    configuration["attachments-directory"] = attachments_directory or configuration.get(
+        "attachments-directory", ""
+    )
     testbench2robotframework(testbench_report, configuration)
 
 

{testbench2robotframework-2.0.0 → testbench2robotframework-2.0.1rc1}/testbench2robotframework/config.py

@@ -237,6 +237,9 @@ class Configuration:
     _: KW_ONLY
     include_blocked: bool = False
     merge_protocol: bool = True
+    keep_extracted_report: bool = False
+    attachments_directory: str = ""
+    attachments_variable: str = "ITB_ATTACHMENTS_DIR"
     clean_mode: CleanMode = CleanMode.GENERATED
     keyword_comment_style: KeywordCommentStyle = KeywordCommentStyle.STRUCTURED
     keyword_comment_max_depth: int = 5
@@ -271,6 +274,9 @@ class Configuration:
                 }
             ),
             merge_protocol=dictionary.get("merge-protocol", True),
+            keep_extracted_report=dictionary.get("keep-extracted-report", False),
+            attachments_directory=dictionary.get("attachments-directory", "").replace("\\", "/"),
+            attachments_variable=dictionary.get("attachments-variable", "ITB_ATTACHMENTS_DIR"),
             keyword_comment_style=KeywordCommentStyle(
                 dictionary.get("keyword-comment-style", "STRUCTURED").upper()
             ),

{testbench2robotframework-2.0.0 → testbench2robotframework-2.0.1rc1}/testbench2robotframework/execution_artifacts.py

@@ -9,6 +9,10 @@ from .config import AttachmentConflictBehaviour, ReferenceBehaviour
 from .log import logger
 from .model import ReferenceAssignment, ReferenceKind
 
+# A 'file:' URI is always absolute (RFC 8089): 'file:///x.zip' is '/x.zip', the
+# file system root. Files in the Robot output directory are referenced by a
+# relative value without scheme, which 'ExecutionArtifactInfo' resolves against
+# the directory of the output.xml. See docs/usage/fetch_results.md.
 FILE_URI_SCHEME = "file://"
 MEGABYTE = 1000 * 1000
 
@@ -137,8 +141,12 @@ class ExecutionArtifactStorage:
         if not attachment_folder_path.exists():
             attachment_folder_path.mkdir(parents=True, exist_ok=True)
         if not (attachment_folder_path / filename).exists():
-            return self._use_new_attachment(filename, artifact_value, attachment_folder_path)
-        return self._dispatch_attachment_copy(filename, artifact_value, attachment_folder_path)
+            stored_file = self._use_new_attachment(filename, artifact_value, attachment_folder_path)
+        else:
+            stored_file = self._dispatch_attachment_copy(
+                filename, artifact_value, attachment_folder_path
+            )
+        return f"{attachment_folder_path.name}/{stored_file}"
 
     def _process_artifact(self, artifact: str) -> str | None:
         artifact_info = ExecutionArtifactInfo(artifact, self.output_xml)

testbench2robotframework-2.0.1rc1/testbench2robotframework/json_codec.py

@@ -0,0 +1,55 @@
+"""JSON encoding and decoding of report files - with orjson when it is installed.
+
+orjson (Rust) parses and serializes several times faster than the standard
+library, which matters for reports whose test case files reach megabytes.
+It is optional: ``pip install testbench2robotframework[fast]``. Without it the
+standard library is used; the files are identical apart from key order and
+whitespace details neither TestBench nor this package depend on.
+"""
+
+from __future__ import annotations
+
+import json
+from enum import Enum
+from pathlib import Path
+from typing import Any
+
+try:
+    import orjson
+except ImportError:  # pragma: no cover - depends on the environment
+    orjson = None
+
+JSONDecodeError = json.JSONDecodeError
+
+
+def _default(value: Any) -> Any:
+    return value.value if isinstance(value, Enum) else str(value)
+
+
+def dumps(content: Any) -> str:
+    """Compact JSON, the way TestBench exports it."""
+    if orjson is not None:
+        return orjson.dumps(content, default=_default).decode("utf-8")
+    return json.dumps(content, default=_default)
+
+
+def loads(text: str | bytes) -> Any:
+    """Raises 'JSONDecodeError' (the standard library's) for invalid input."""
+    if orjson is not None:
+        try:
+            return orjson.loads(text)
+        except orjson.JSONDecodeError as error:
+            raise JSONDecodeError(str(error), "", 0) from error
+    return json.loads(text)
+
+
+def write_json(filepath: str | Path, content: Any) -> None:
+    Path(filepath).write_text(dumps(content), encoding="utf-8")
+
+
+def read_json_file(filepath: str | Path) -> Any:
+    return loads(Path(filepath).read_bytes())
+
+
+def using_orjson() -> bool:
+    return orjson is not None

{testbench2robotframework-2.0.0 → testbench2robotframework-2.0.1rc1}/testbench2robotframework/json_reader.py

@@ -1,9 +1,8 @@
-import json
 import sys
 from dataclasses import dataclass
-from json import JSONDecodeError
 from pathlib import Path
 
+from .json_codec import JSONDecodeError, read_json_file
 from .log import logger
 from .model import (
     ReferenceAssignment,
@@ -162,8 +161,7 @@ class TestBenchJsonReader:
 
 def read_json(filepath: str | Path, silent=True):
     try:
-        with Path(filepath).open(encoding="utf-8") as json_file:
-            return json.load(json_file)
+        return read_json_file(filepath)
     except FileNotFoundError:
         if not silent:
             logger.error(f"File '{filepath}' does not exist.")

{testbench2robotframework-2.0.0 → testbench2robotframework-2.0.1rc1}/testbench2robotframework/json_writer.py

@@ -1,9 +1,9 @@
 import json
 from dataclasses import asdict
-from enum import Enum
 from pathlib import Path
 
 from .config import Configuration
+from .json_codec import write_json
 from .log import logger
 from .model import (
     ReferenceAssignment,
@@ -41,36 +41,17 @@ def write_test_structure_element(
     else:
         filepath = Path(json_dir) / Path(f"{test_structure_element.uniqueID}.json")
         content = asdict(test_structure_element)
-    with Path(filepath).open("w+", encoding="utf8") as output_file:
-        json.dump(
-            content,
-            output_file,
-            indent=2,
-            default=lambda o: o.value if isinstance(o, Enum) else str(o),
-        )
+    write_json(filepath, content)
 
 
 def write_main_protocol(json_dir: str, main_protocol: list[TestCaseSetExecutionForImport]) -> None:
-    protocol = [asdict(tcs) for tcs in main_protocol]
-    filepath = Path(json_dir) / Path("protocol.json")
-    with Path(filepath).open("w+", encoding="utf8") as output_file:
-        json.dump(
-            protocol,
-            output_file,
-            indent=2,
-            default=lambda o: o.value if isinstance(o, Enum) else str(o),
-        )
+    write_json(Path(json_dir) / "protocol.json", [asdict(tcs) for tcs in main_protocol])
 
 
 def write_references(json_dir: str, references: list[ReferenceAssignment]) -> None:
-    filepath = Path(json_dir) / Path("references.json")
-    with Path(filepath).open("w+", encoding="utf8") as output_file:
-        json.dump(
-            [asdict(ref) for ref in references],
-            output_file,
-            indent=2,
-            default=lambda o: o.value if isinstance(o, Enum) else str(o),
-        )
+    write_json(Path(json_dir) / "references.json", [asdict(ref) for ref in references])
+
+
 
 
 def write_default_config(config_file):

{testbench2robotframework-2.0.0 → testbench2robotframework-2.0.1rc1}/testbench2robotframework/model_utils.py

@@ -1,5 +1,6 @@
 from dataclasses import fields, is_dataclass
 from enum import Enum
+from functools import cache
 from types import UnionType as TypesUnion
 from typing import Any, TypeVar, get_args, get_origin, get_type_hints
 from typing import Union as TypingUnion
@@ -36,14 +37,25 @@ def get_origin_from_type_hint(type_hint):
     raise ValueError(ERROR_UNKNOWN_TYPE_HINT_ORIGIN)
 
 
+@cache
+def _type_hints_and_fields(cls: type) -> tuple[dict[str, Any], tuple]:
+    """Resolved annotations and fields of a dataclass, computed once per class.
+
+    'get_type_hints' evaluates every annotation anew on each call - with lazy
+    annotations (Python 3.14) that means compiling the forward references again.
+    A report holds hundreds of thousands of model objects, so this dominated the
+    whole read time before it was cached.
+    """
+    return get_type_hints(cls), fields(cls)
+
+
 def from_dict(cls: type[T], data: dict) -> T:
     if not isinstance(cls, type) or not is_dataclass(cls):
         raise ValueError(ERROR_NOT_A_DATACLASS.format(dataclass=cls.__name__))
     if data is None:
         raise ValueError(ERROR_NONETYPE_DATA)
     cls_dict = {}
-    class_type_hints = get_type_hints(cls)
-    class_fields = fields(cls)
+    class_type_hints, class_fields = _type_hints_and_fields(cls)
     if len(class_fields) < len(data):
         raise ValueError(ERROR_TOO_MANY_DATA_FIELDS)
     for cls_field in class_fields: