tensoracle 1.5.0__tar.gz → 1.6.0__tar.gz

{tensoracle-1.5.0 → tensoracle-1.6.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: tensoracle
-Version: 1.5.0
+Version: 1.6.0
 Summary: Build, save, reuse, and execute TensorRT engines from safetensors weights
 Project-URL: documentation, https://sync-dev-org.github.io/tensoracle/
 Project-URL: repository, https://github.com/sync-dev-org/tensoracle
@@ -110,7 +110,7 @@ def graph(network: trt.INetworkDefinition) -> None:
 
 declaration = EngineBuild(
     inputs={"features": InputShape.ranged((1, 1, 2), (1, 64, 2), (1, 448, 2))},
-    settings=BuilderSettings(workspace_limit=1 << 30, optimization_level=3),
+    settings=BuilderSettings(workspace_limit=None, optimization_level=3),
 )
 plan: bytes = build_serialized_engine(graph, declaration)
 ```
@@ -119,6 +119,8 @@ Use `InputShape.fixed((1, 64, 2))` for one input size; the graph may declare tha
 
 The engine's precision is determined by the tensor types that the graph function places in the network. For an fp16 graph, use `trt.float16` tensors and `np.float16` weights where needed; the graph can also contain fp32 tensors. `EngineBuild` declares input shapes and builder settings. TF32 is always disabled; `BuilderSettings(tf32=True)` raises `ValueError`. The function returns serialized plan bytes. Invalid declarations raise `ValueError`, and a failed TensorRT build raises `RuntimeError`.
 
+`BuilderSettings.workspace_limit` defaults to `None`, which leaves the workspace limit at TensorRT's default without calling `set_memory_pool_limit`. To impose a limit, pass a positive integer in bytes, such as `workspace_limit=4 << 30` for 4 GiB. Zero, negative values, booleans, and noninteger values raise `ValueError`.
+
 The same API builds bf16, int8, and fp8 graphs. Cast tensors to `trt.bfloat16` for bf16; for int8/fp8, place `add_quantize` / `add_dequantize` layers and load their scales from safetensors. The application determines scales with an external quantization library and chooses output quality limits with `compare_outputs`. fp8 targets sm89 and sm120; bf16 and int8 also target sm86. Follow [Build bf16, int8, and fp8 engines](https://github.com/sync-dev-org/tensoracle/blob/main/docs/precision.md) for a complete example, NumPy dtype constraints, and comparison against an fp32 engine. Use different engine names or graph versions for different precisions.
 
 ## Save and reopen an engine
@@ -144,7 +146,9 @@ handle = open_engine(
 engine = handle.engine  # Keep handle.runtime alive while using the engine.
 ```
 
-Saved files live in the `tensoracle` directory under `XDG_CACHE_HOME`, or under the home directory's `.cache` when that variable is unset. The same rule applies on every OS; on Windows the home directory is `%USERPROFILE%`, so the default is `%USERPROFILE%\.cache\tensoracle`. The cache identity includes the contents of all declared safetensors weight files and optional `plugins` files, the engine name, graph version, input shapes, builder settings, the GPU's compatibility properties, OS, CPU architecture, and TensorRT version. The GPU is the device of the current CUDA context, or device 0 when no context is current. Its properties are the product name, compute capability, memory bus width, L2 cache size, shared memory limits, texture alignment, multiprocessor count, whether the GPU is integrated, ECC mode, and total memory; another device with the same properties reuses the saved engine. Raise `graph_version` when graph code changes; without a version change, the previous engine is reused. Use a different `name` or `graph_version` for engines with different tensor types, such as fp32 and fp16. Include in `graph_version` any other caller value that changes the engine contents but is not part of the cache identity, such as a plugin manifest or a build recipe. Pass `force_rebuild=True` to replace a cached engine even when it is intact. tensoracle closes a saved engine file after reading it, so another process using an opened engine does not block replacement. On Windows, a process that keeps the saved file itself open prevents replacement or removal with `PermissionError`; after that process closes the file, a file left empty by the failed rebuild is rejected as `CorruptEngineError` and can be rebuilt with `force_rebuild=True`.
+Saved files live in the `tensoracle` directory under `XDG_CACHE_HOME`, or under the home directory's `.cache` when that variable is unset. The same rule applies on every OS; on Windows the home directory is `%USERPROFILE%`, so the default is `%USERPROFILE%\.cache\tensoracle`. The cache identity includes the contents of all declared safetensors weight files and optional `plugins` files, the engine name, graph version, input shapes, the builder's `optimization_level` and `tf32` settings, the GPU's compatibility properties, OS, CPU architecture, and TensorRT version. The GPU is the device of the current CUDA context, or device 0 when no context is current. Its properties are the product name, compute capability, memory bus width, L2 cache size, shared memory limits, texture alignment, multiprocessor count, whether the GPU is integrated, ECC mode, and total memory; another device with the same properties reuses the saved engine. Raise `graph_version` when graph code changes; without a version change, the previous engine is reused. Use a different `name` or `graph_version` for engines with different tensor types, such as fp32 and fp16. Include in `graph_version` any other caller value that changes the engine contents but is not part of the cache identity, such as a plugin manifest or a build recipe. Pass `force_rebuild=True` to replace a cached engine even when it is intact. tensoracle closes a saved engine file after reading it, so another process using an opened engine does not block replacement. On Windows, a process that keeps the saved file itself open prevents replacement or removal with `PermissionError`; after that process closes the file, a file left empty by the failed rebuild is rejected as `CorruptEngineError` and can be rebuilt with `force_rebuild=True`.
+
+`workspace_limit` is excluded from the cache identity. Changing it reuses a matching saved engine; pass `force_rebuild=True` to `open_engine` to build again with the new limit. The saved header records the workspace limit used for that build, including `None`, as a reference outside the conditions used for matching. Cache reads leave this reference unchanged. `tensoracle cache list` shows the recorded limit.
 
 `plugins` names native TensorRT plugin libraries. Both `open_engine` and `build_serialized_engine` accept it. Each function checks that every library exports `getCreators`, loads it through TensorRT's registry, and retains it for the process before building the graph or deserializing an engine. Repeating the same library does not register it twice. `open_engine` also hashes the loaded library bytes into the engine identity; a changed library selects a different saved engine in a new process. A missing, unreadable, or incompatible library, or a library changed after loading in the same process, raises `PluginLibraryError` before a cached plan is opened. Keep the library and its cubin bundle together in the caller's wheel.
 
@@ -170,7 +174,7 @@ tensoracle cache prune --max-size 10GiB
 
 The commands use the same `XDG_CACHE_HOME` / home `.cache` directory as `open_engine`. They read only filesystem metadata, engine headers, and saved weight digest records. They do not read or checksum the plan body, load the original weights, deserialize engines, import TensorRT, or query a GPU. Listing recognizes the header format; it does not establish that an engine can be loaded.
 
-`cache list` prints one JSON object with `directory`, `entries`, and `total_size_bytes`. Each entry contains the file name, size in bytes, recorded time in UTC (`recorded_at`) and exact nanoseconds (`recorded_at_ns`), and the complete header conditions. This distinguishes engines with the same name and graph version but different weights or plugins. `weight_paths` associates each weight digest with paths from valid, checksum-verified `weight-*.json` records whose SHA-256 matches that digest; an empty `paths` array means unknown. These paths are references and do not establish which application uses an engine or whether the weight file still exists. Empty files have status `building or leftover`; unreadable or invalid headers have status `unrecognized` and a reason.
+`cache list` prints one JSON object with `directory`, `entries`, and `total_size_bytes`. Each entry contains the file name, size in bytes, recorded time in UTC (`recorded_at`) and exact nanoseconds (`recorded_at_ns`), and the complete header conditions. This distinguishes engines with the same name and graph version but different weights or plugins. Each recognized entry also contains `workspace_limit`: a positive integer in bytes for an explicit build limit, JSON `null` when the build left the limit at TensorRT's default, or `"unknown"` when the header has no reference value. `weight_paths` associates each weight digest with paths from valid, checksum-verified `weight-*.json` records whose SHA-256 matches that digest; an empty `paths` array means unknown. These paths are references and do not establish which application uses an engine or whether the weight file still exists. Empty files have status `building or leftover`; unreadable or invalid headers have status `unrecognized` and a reason.
 
 An engine's `.engine` modification time records its initial save or the last successful `open_engine` cache read. Failed loads and these management commands leave that time unchanged. A timestamp write failure, including a read-only cache, does not prevent a successful load, and a disappeared file is never recreated to record its time. The record describes the time of `open_engine`, not whether inference continues afterward. Files saved before timestamp recording was introduced, and files whose timestamp could not be written, may not reflect the actual last successful read.
 

{tensoracle-1.5.0 → tensoracle-1.6.0}/README.md

@@ -77,7 +77,7 @@ def graph(network: trt.INetworkDefinition) -> None:
 
 declaration = EngineBuild(
     inputs={"features": InputShape.ranged((1, 1, 2), (1, 64, 2), (1, 448, 2))},
-    settings=BuilderSettings(workspace_limit=1 << 30, optimization_level=3),
+    settings=BuilderSettings(workspace_limit=None, optimization_level=3),
 )
 plan: bytes = build_serialized_engine(graph, declaration)
 ```
@@ -86,6 +86,8 @@ Use `InputShape.fixed((1, 64, 2))` for one input size; the graph may declare tha
 
 The engine's precision is determined by the tensor types that the graph function places in the network. For an fp16 graph, use `trt.float16` tensors and `np.float16` weights where needed; the graph can also contain fp32 tensors. `EngineBuild` declares input shapes and builder settings. TF32 is always disabled; `BuilderSettings(tf32=True)` raises `ValueError`. The function returns serialized plan bytes. Invalid declarations raise `ValueError`, and a failed TensorRT build raises `RuntimeError`.
 
+`BuilderSettings.workspace_limit` defaults to `None`, which leaves the workspace limit at TensorRT's default without calling `set_memory_pool_limit`. To impose a limit, pass a positive integer in bytes, such as `workspace_limit=4 << 30` for 4 GiB. Zero, negative values, booleans, and noninteger values raise `ValueError`.
+
 The same API builds bf16, int8, and fp8 graphs. Cast tensors to `trt.bfloat16` for bf16; for int8/fp8, place `add_quantize` / `add_dequantize` layers and load their scales from safetensors. The application determines scales with an external quantization library and chooses output quality limits with `compare_outputs`. fp8 targets sm89 and sm120; bf16 and int8 also target sm86. Follow [Build bf16, int8, and fp8 engines](https://github.com/sync-dev-org/tensoracle/blob/main/docs/precision.md) for a complete example, NumPy dtype constraints, and comparison against an fp32 engine. Use different engine names or graph versions for different precisions.
 
 ## Save and reopen an engine
@@ -111,7 +113,9 @@ handle = open_engine(
 engine = handle.engine  # Keep handle.runtime alive while using the engine.
 ```
 
-Saved files live in the `tensoracle` directory under `XDG_CACHE_HOME`, or under the home directory's `.cache` when that variable is unset. The same rule applies on every OS; on Windows the home directory is `%USERPROFILE%`, so the default is `%USERPROFILE%\.cache\tensoracle`. The cache identity includes the contents of all declared safetensors weight files and optional `plugins` files, the engine name, graph version, input shapes, builder settings, the GPU's compatibility properties, OS, CPU architecture, and TensorRT version. The GPU is the device of the current CUDA context, or device 0 when no context is current. Its properties are the product name, compute capability, memory bus width, L2 cache size, shared memory limits, texture alignment, multiprocessor count, whether the GPU is integrated, ECC mode, and total memory; another device with the same properties reuses the saved engine. Raise `graph_version` when graph code changes; without a version change, the previous engine is reused. Use a different `name` or `graph_version` for engines with different tensor types, such as fp32 and fp16. Include in `graph_version` any other caller value that changes the engine contents but is not part of the cache identity, such as a plugin manifest or a build recipe. Pass `force_rebuild=True` to replace a cached engine even when it is intact. tensoracle closes a saved engine file after reading it, so another process using an opened engine does not block replacement. On Windows, a process that keeps the saved file itself open prevents replacement or removal with `PermissionError`; after that process closes the file, a file left empty by the failed rebuild is rejected as `CorruptEngineError` and can be rebuilt with `force_rebuild=True`.
+Saved files live in the `tensoracle` directory under `XDG_CACHE_HOME`, or under the home directory's `.cache` when that variable is unset. The same rule applies on every OS; on Windows the home directory is `%USERPROFILE%`, so the default is `%USERPROFILE%\.cache\tensoracle`. The cache identity includes the contents of all declared safetensors weight files and optional `plugins` files, the engine name, graph version, input shapes, the builder's `optimization_level` and `tf32` settings, the GPU's compatibility properties, OS, CPU architecture, and TensorRT version. The GPU is the device of the current CUDA context, or device 0 when no context is current. Its properties are the product name, compute capability, memory bus width, L2 cache size, shared memory limits, texture alignment, multiprocessor count, whether the GPU is integrated, ECC mode, and total memory; another device with the same properties reuses the saved engine. Raise `graph_version` when graph code changes; without a version change, the previous engine is reused. Use a different `name` or `graph_version` for engines with different tensor types, such as fp32 and fp16. Include in `graph_version` any other caller value that changes the engine contents but is not part of the cache identity, such as a plugin manifest or a build recipe. Pass `force_rebuild=True` to replace a cached engine even when it is intact. tensoracle closes a saved engine file after reading it, so another process using an opened engine does not block replacement. On Windows, a process that keeps the saved file itself open prevents replacement or removal with `PermissionError`; after that process closes the file, a file left empty by the failed rebuild is rejected as `CorruptEngineError` and can be rebuilt with `force_rebuild=True`.
+
+`workspace_limit` is excluded from the cache identity. Changing it reuses a matching saved engine; pass `force_rebuild=True` to `open_engine` to build again with the new limit. The saved header records the workspace limit used for that build, including `None`, as a reference outside the conditions used for matching. Cache reads leave this reference unchanged. `tensoracle cache list` shows the recorded limit.
 
 `plugins` names native TensorRT plugin libraries. Both `open_engine` and `build_serialized_engine` accept it. Each function checks that every library exports `getCreators`, loads it through TensorRT's registry, and retains it for the process before building the graph or deserializing an engine. Repeating the same library does not register it twice. `open_engine` also hashes the loaded library bytes into the engine identity; a changed library selects a different saved engine in a new process. A missing, unreadable, or incompatible library, or a library changed after loading in the same process, raises `PluginLibraryError` before a cached plan is opened. Keep the library and its cubin bundle together in the caller's wheel.
 
@@ -137,7 +141,7 @@ tensoracle cache prune --max-size 10GiB
 
 The commands use the same `XDG_CACHE_HOME` / home `.cache` directory as `open_engine`. They read only filesystem metadata, engine headers, and saved weight digest records. They do not read or checksum the plan body, load the original weights, deserialize engines, import TensorRT, or query a GPU. Listing recognizes the header format; it does not establish that an engine can be loaded.
 
-`cache list` prints one JSON object with `directory`, `entries`, and `total_size_bytes`. Each entry contains the file name, size in bytes, recorded time in UTC (`recorded_at`) and exact nanoseconds (`recorded_at_ns`), and the complete header conditions. This distinguishes engines with the same name and graph version but different weights or plugins. `weight_paths` associates each weight digest with paths from valid, checksum-verified `weight-*.json` records whose SHA-256 matches that digest; an empty `paths` array means unknown. These paths are references and do not establish which application uses an engine or whether the weight file still exists. Empty files have status `building or leftover`; unreadable or invalid headers have status `unrecognized` and a reason.
+`cache list` prints one JSON object with `directory`, `entries`, and `total_size_bytes`. Each entry contains the file name, size in bytes, recorded time in UTC (`recorded_at`) and exact nanoseconds (`recorded_at_ns`), and the complete header conditions. This distinguishes engines with the same name and graph version but different weights or plugins. Each recognized entry also contains `workspace_limit`: a positive integer in bytes for an explicit build limit, JSON `null` when the build left the limit at TensorRT's default, or `"unknown"` when the header has no reference value. `weight_paths` associates each weight digest with paths from valid, checksum-verified `weight-*.json` records whose SHA-256 matches that digest; an empty `paths` array means unknown. These paths are references and do not establish which application uses an engine or whether the weight file still exists. Empty files have status `building or leftover`; unreadable or invalid headers have status `unrecognized` and a reason.
 
 An engine's `.engine` modification time records its initial save or the last successful `open_engine` cache read. Failed loads and these management commands leave that time unchanged. A timestamp write failure, including a read-only cache, does not prevent a successful load, and a disappeared file is never recreated to record its time. The record describes the time of `open_engine`, not whether inference continues afterward. Files saved before timestamp recording was introduced, and files whose timestamp could not be written, may not reflect the actual last successful read.
 

{tensoracle-1.5.0 → tensoracle-1.6.0}/docs/index.md

@@ -74,6 +74,8 @@ handle = open_engine(
 
 `my_model` represents the application's model package. On a valid cache hit, `open_engine` does not call `graph`; on a miss, it builds and saves a new engine. Raise `graph_version` when the graph code changes or when any other caller value that changes the engine contents but is not part of the cache identity changes, such as a plugin manifest or a build recipe. `open_engine` itself does not execute the engine or manage GPU buffers. Create an execution unit from its returned handle to enqueue inference. Saved engines live under `XDG_CACHE_HOME/tensoracle`, or `~/.cache/tensoracle` when `XDG_CACHE_HOME` is unset. On Windows, `~` is `%USERPROFILE%`. See the [complete cache example](https://github.com/sync-dev-org/tensoracle#save-and-reopen-an-engine) for the declaration and expected input and output types.
 
+`workspace_limit` is excluded from the cache identity; `optimization_level` and `tf32` remain in the conditions. Changing only the workspace limit reuses a matching saved engine. Pass `force_rebuild=True` to `open_engine` to build again with the new limit. The saved header records the workspace limit used for that build, including `None`, as a reference outside the conditions used for matching. Cache reads leave this reference unchanged. `tensoracle cache list` shows the recorded limit.
+
 ### Manage saved engines
 
 Inspect saved engines and preview or perform cleanup with the installed command:
@@ -88,7 +90,7 @@ tensoracle cache prune --max-size 10GiB
 
 The commands use the same `XDG_CACHE_HOME` / home `.cache` directory as `open_engine`. They read only filesystem metadata, engine headers, and saved weight digest records. They do not read or checksum the plan body, load the original weights, deserialize engines, import TensorRT, or query a GPU. Listing recognizes the header format; it does not establish that an engine can be loaded.
 
-`cache list` prints one JSON object with `directory`, `entries`, and `total_size_bytes`. Each entry contains the file name, size in bytes, recorded time in UTC (`recorded_at`) and exact nanoseconds (`recorded_at_ns`), and the complete header conditions. This distinguishes engines with the same name and graph version but different weights or plugins. `weight_paths` associates each weight digest with paths from valid, checksum-verified `weight-*.json` records whose SHA-256 matches that digest; an empty `paths` array means unknown. These paths are references and do not establish which application uses an engine or whether the weight file still exists. Empty files have status `building or leftover`; unreadable or invalid headers have status `unrecognized` and a reason.
+`cache list` prints one JSON object with `directory`, `entries`, and `total_size_bytes`. Each entry contains the file name, size in bytes, recorded time in UTC (`recorded_at`) and exact nanoseconds (`recorded_at_ns`), and the complete header conditions. This distinguishes engines with the same name and graph version but different weights or plugins. Each recognized entry also contains `workspace_limit`: a positive integer in bytes for an explicit build limit, JSON `null` when the build left the limit at TensorRT's default, or `"unknown"` when the header has no reference value. `weight_paths` associates each weight digest with paths from valid, checksum-verified `weight-*.json` records whose SHA-256 matches that digest; an empty `paths` array means unknown. These paths are references and do not establish which application uses an engine or whether the weight file still exists. Empty files have status `building or leftover`; unreadable or invalid headers have status `unrecognized` and a reason.
 
 An engine's `.engine` modification time records its initial save or the last successful `open_engine` cache read. Failed loads and these management commands leave that time unchanged. A timestamp write failure, including a read-only cache, does not prevent a successful load, and a disappeared file is never recreated to record its time. The record describes the time of `open_engine`, not whether inference continues afterward. Files saved before timestamp recording was introduced, and files whose timestamp could not be written, may not reflect the actual last successful read.
 
@@ -252,7 +254,7 @@ Engines with loops or conditionals, or layers or plugins that synchronize with t
 
 ### Build a standard graph
 
-Define `graph(network)` with TensorRT's Python network API and load model weights from safetensors. Describe each graph input with `InputShape.fixed` or `InputShape.ranged`, and pass an `EngineBuild` declaration to `build_serialized_engine`. `EngineBuild` declares input shapes and builder settings; the graph function determines precision through the tensor types it places in the network. The supported precisions are fp32 (with TF32 disabled), fp16, bf16, int8, and fp8. The [bf16, int8, and fp8 guide](precision.md) shows tensor casts, explicit Q/DQ layers, and scales supplied through safetensors; fp8 targets sm89 and sm120. `open_engine` uses the same declaration plus a name, graph version, weight files, and `EngineIO` to save and reuse a checked engine. Use a different `name` or `graph_version` for engines with different tensor types, such as fp32 and fp16. The [graph example](https://github.com/sync-dev-org/tensoracle#define-and-build-a-standard-graph) shows the exact calls.
+Define `graph(network)` with TensorRT's Python network API and load model weights from safetensors. Describe each graph input with `InputShape.fixed` or `InputShape.ranged`, and pass an `EngineBuild` declaration to `build_serialized_engine`. `EngineBuild` declares input shapes and builder settings; the graph function determines precision through the tensor types it places in the network. `BuilderSettings.workspace_limit` defaults to `None`, leaving the workspace limit at TensorRT's default. To impose a limit, pass a positive integer in bytes, such as `workspace_limit=4 << 30` for 4 GiB. Zero, negative values, booleans, and noninteger values raise `ValueError`. The supported precisions are fp32 (with TF32 disabled), fp16, bf16, int8, and fp8. The [bf16, int8, and fp8 guide](precision.md) shows tensor casts, explicit Q/DQ layers, and scales supplied through safetensors; fp8 targets sm89 and sm120. `open_engine` uses the same declaration plus a name, graph version, weight files, and `EngineIO` to save and reuse a checked engine. Use a different `name` or `graph_version` for engines with different tensor types, such as fp32 and fp16. The [graph example](https://github.com/sync-dev-org/tensoracle#define-and-build-a-standard-graph) shows the exact calls.
 
 The application runs the engine and passes a CPU NumPy candidate output and a corresponding reference output to `compare_outputs`. The application chooses the acceptance limits. See [Compare output arrays](https://github.com/sync-dev-org/tensoracle#compare-output-arrays).
 

{tensoracle-1.5.0 → tensoracle-1.6.0}/src/tensoracle/_build.py

@@ -69,10 +69,16 @@ class InputShape:
 class BuilderSettings:
     """TensorRT builder options that affect the serialized engine."""
 
-    workspace_limit: int = 1 << 30
+    workspace_limit: int | None = None
     optimization_level: int = 3
     tf32: bool = False
 
+    def __post_init__(self) -> None:
+        if self.workspace_limit is not None and (
+            type(self.workspace_limit) is not int or self.workspace_limit <= 0
+        ):
+            raise ValueError("workspace_limit must be a positive integer or None")
+
 
 @dataclass(frozen=True)
 class EngineBuild:
@@ -103,8 +109,6 @@ def _build_serialized_engine(
 ) -> tuple[bytes, tuple[str, ...]]:
     if declaration.settings.tf32:
         raise ValueError("TF32 cannot be enabled")
-    if declaration.settings.workspace_limit <= 0:
-        raise ValueError("workspace_limit must be positive")
     if not 0 <= declaration.settings.optimization_level <= 5:
         raise ValueError("optimization_level must be between 0 and 5")
 
@@ -125,9 +129,10 @@ def _build_serialized_engine(
         _warn_shape_tensor_outputs(output_names, stacklevel=3)
         config = builder.create_builder_config()
         config.clear_flag(trt.BuilderFlag.TF32)
-        config.set_memory_pool_limit(
-            trt.MemoryPoolType.WORKSPACE, declaration.settings.workspace_limit
-        )
+        if declaration.settings.workspace_limit is not None:
+            config.set_memory_pool_limit(
+                trt.MemoryPoolType.WORKSPACE, declaration.settings.workspace_limit
+            )
         config.builder_optimization_level = declaration.settings.optimization_level
 
         inputs = {

{tensoracle-1.5.0 → tensoracle-1.6.0}/src/tensoracle/_cache.py

@@ -7,7 +7,7 @@ import os
 import platform
 import tempfile
 from collections.abc import Callable, Mapping, Sequence
-from dataclasses import asdict, dataclass
+from dataclasses import dataclass
 from dataclasses import field as dataclass_field
 from pathlib import Path
 from typing import TYPE_CHECKING
@@ -125,7 +125,11 @@ def open_engine(
         handle = _open_plan(
             plan, path, declaration, io, actual_logger, shape_tensor_outputs=shape_tensor_outputs
         )
-        header = {"conditions": conditions, "plan_sha256": hashlib.sha256(plan).hexdigest()}
+        header = {
+            "conditions": conditions,
+            "plan_sha256": hashlib.sha256(plan).hexdigest(),
+            "workspace_limit": declaration.settings.workspace_limit,
+        }
         if shape_tensor_outputs:
             header["shape_tensor_outputs"] = list(shape_tensor_outputs)
         header_bytes = _json_bytes(header)
@@ -286,7 +290,10 @@ def _conditions(
             }
             for name, shape in declaration.inputs.items()
         },
-        "builder_settings": asdict(declaration.settings),
+        "builder_settings": {
+            "optimization_level": declaration.settings.optimization_level,
+            "tf32": declaration.settings.tf32,
+        },
         "gpu": _gpu_identity(),
         "os": platform.system(),
         "architecture": platform.machine(),

{tensoracle-1.5.0 → tensoracle-1.6.0}/src/tensoracle/_cli.py

@@ -58,6 +58,7 @@ def _inspect(path: Path) -> _Entry:
                     raise OSError("file changed during inspection")
             details["status"] = "recognized"
             details["conditions"] = header["conditions"]
+            details["workspace_limit"] = header.get("workspace_limit", "unknown")
     except (OSError, CorruptEngineError) as error:
         details["reason"] = str(error)
     return _Entry(path, observed, details)

{tensoracle-1.5.0 → tensoracle-1.6.0}/src/tensoracle/_version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '1.5.0'
-__version_tuple__ = version_tuple = (1, 5, 0)
+__version__ = version = '1.6.0'
+__version_tuple__ = version_tuple = (1, 6, 0)
 
 __commit_id__ = commit_id = None

{tensoracle-1.5.0 → tensoracle-1.6.0}/tests/test_build.py

@@ -187,8 +187,23 @@ def test_tf32_request_is_rejected_before_graph_is_built():
 
 
 @pytest.mark.req("SP-TENSORACLE-013")
-def test_tf32_is_disabled_and_other_builder_settings_are_applied(monkeypatch):
-    """The builder clears TF32 while applying the declared workspace and optimization level."""
+@pytest.mark.req("SP-TENSORACLE-052")
+@pytest.mark.parametrize(
+    "settings, workspace_calls",
+    [
+        (BuilderSettings(optimization_level=2), []),
+        (BuilderSettings(workspace_limit=None, optimization_level=2), []),
+        (
+            BuilderSettings(workspace_limit=4096, optimization_level=2),
+            [(trt.MemoryPoolType.WORKSPACE, 4096)],
+        ),
+    ],
+    ids=["default-workspace", "explicit-none", "positive-workspace"],
+)
+def test_tf32_is_disabled_and_other_builder_settings_are_applied(
+    monkeypatch, settings, workspace_calls
+):
+    """The builder clears TF32 and sets a workspace limit only for an explicit positive integer."""
     import tensoracle._build as module
 
     class Config:
@@ -196,13 +211,13 @@ def test_tf32_is_disabled_and_other_builder_settings_are_applied(monkeypatch):
 
         def __init__(self):
             self.flags = {trt.BuilderFlag.TF32}
-            self.workspace = None
+            self.workspace_calls = []
 
         def clear_flag(self, flag):
             self.flags.discard(flag)
 
         def set_memory_pool_limit(self, pool, limit):
-            self.workspace = (pool, limit)
+            self.workspace_calls.append((pool, limit))
 
     class Network:
         num_inputs = 1
@@ -229,10 +244,20 @@ def test_tf32_is_disabled_and_other_builder_settings_are_applied(monkeypatch):
     monkeypatch.setattr(module.trt, "Builder", Builder)
     declaration = EngineBuild(
         inputs={"features": InputShape.fixed((1, 3, 2))},
-        settings=BuilderSettings(workspace_limit=4096, optimization_level=2),
+        settings=settings,
     )
     assert build_serialized_engine(lambda network: None, declaration) == b"plan"
     config = observed[0].config
     assert trt.BuilderFlag.TF32 not in config.flags
-    assert config.workspace == (trt.MemoryPoolType.WORKSPACE, 4096)
+    assert config.workspace_calls == workspace_calls
     assert config.builder_optimization_level == 2
+
+
+@pytest.mark.req("SP-TENSORACLE-052")
+@pytest.mark.parametrize("workspace_limit", [0, -1, True, False, 1.5, "4096"])
+def test_invalid_workspace_limit_is_rejected_before_building(monkeypatch, workspace_limit):
+    """Zero, negatives, booleans, and nonintegers fail before creating a TensorRT builder."""
+    monkeypatch.setattr(trt, "Builder", lambda logger: pytest.fail("builder was created"))
+    with pytest.raises(ValueError, match="workspace_limit"):
+        declaration = EngineBuild({}, BuilderSettings(workspace_limit=workspace_limit))
+        build_serialized_engine(lambda network: pytest.fail("graph was built"), declaration)

{tensoracle-1.5.0 → tensoracle-1.6.0}/tests/test_cache.py

@@ -347,6 +347,7 @@ def test_corrupt_plan_and_changed_header_fail_before_deserialization(tmp_path, m
 @pytest.mark.gpu
 @pytest.mark.req("SP-TENSORACLE-002")
 @pytest.mark.req("SP-TENSORACLE-011")
+@pytest.mark.req("SP-TENSORACLE-052")
 def test_force_rebuild_uses_changed_weight_contents_and_preserves_old_engine(tmp_path, monkeypatch):
     """A forced rebuild saves under the new digest without replacing the old engine."""
     monkeypatch.setenv("XDG_CACHE_HOME", str(tmp_path / "cache"))
@@ -378,7 +379,7 @@ def test_force_rebuild_uses_changed_weight_contents_and_preserves_old_engine(tmp
     offset = len(b"TENSORACLE\x01")
     old_header_size = int.from_bytes(old_engine[offset : offset + 8], "big")
     old_header = json.loads(old_engine[offset + 8 : offset + 8 + old_header_size])
-    assert old_header.keys() == {"conditions", "plan_sha256"}
+    assert old_header.keys() == {"conditions", "plan_sha256", "workspace_limit"}
 
     before = weights.stat()
     changed = bytearray(weights.read_bytes())
@@ -618,7 +619,6 @@ def test_each_declared_condition_selects_a_distinct_cache_entry(tmp_path, monkey
         {"shape": (1, 4, 2)},
         {"input_range": ((1, 1, 2), (1, 3, 2), (1, 5, 2))},
         {"input_range": ((1, 1, 2), (1, 3, 2), (1, 6, 2))},
-        {"settings": tensoracle.BuilderSettings(workspace_limit=2048, optimization_level=0)},
         {"settings": tensoracle.BuilderSettings(optimization_level=1)},
     ]
     paths = {open_case(**variant).path for variant in variants}

{tensoracle-1.5.0 → tensoracle-1.6.0}/tests/test_cache_cli.py

@@ -22,7 +22,9 @@ def saved_cache(tmp_path, monkeypatch):
     return directory
 
 
-def save_engine(directory, filename="one.engine", *, conditions=None, mtime=OLD_NS, size=None):
+def save_engine(
+    directory, filename="one.engine", *, conditions=None, mtime=OLD_NS, size=None, metadata=None
+):
     if conditions is None:
         conditions = {
             "name": "encoder",
@@ -36,7 +38,9 @@ def save_engine(directory, filename="one.engine", *, conditions=None, mtime=OLD_
             "architecture": "x86_64",
             "tensorrt_version": "11.0",
         }
-    header = json.dumps({"conditions": conditions, "plan_sha256": "0" * 64}).encode()
+    header = json.dumps(
+        {"conditions": conditions, "plan_sha256": "0" * 64, **(metadata or {})}
+    ).encode()
     path = directory / filename
     path.write_bytes(b"TENSORACLE\x01" + len(header).to_bytes(8, "big") + header + b"plan")
     if size is not None:
@@ -104,6 +108,26 @@ def test_list_distinguishes_all_conditions_and_preserves_recorded_time(saved_cac
     )
 
 
+@pytest.mark.req("SP-TENSORACLE-043")
+@pytest.mark.req("SP-TENSORACLE-052")
+@pytest.mark.parametrize(
+    "metadata, expected",
+    [({"workspace_limit": None}, None), ({"workspace_limit": 4096}, 4096), ({}, "unknown")],
+    ids=["tensorrt-default", "explicit-limit", "missing-record"],
+)
+def test_list_shows_recorded_workspace_limit_or_unknown(saved_cache, capsys, metadata, expected):
+    """Listing distinguishes TensorRT's default, an explicit byte limit, and a missing record."""
+    path, conditions = save_engine(saved_cache, metadata=metadata)
+    contents = path.read_bytes()
+    status, (listing,), stderr = call_cli(capsys, "list")
+    assert status == 0 and not stderr
+    entry = listing["entries"][0]
+    assert entry["workspace_limit"] == expected
+    assert entry["conditions"] == conditions
+    assert path.read_bytes() == contents
+    assert path.stat().st_mtime_ns == OLD_NS
+
+
 @pytest.mark.req("SP-TENSORACLE-049")
 @pytest.mark.parametrize(
     "damage", ["missing", "json", "version", "type", "checksum", "digest", "mismatch", "valid"]

{tensoracle-1.5.0 → tensoracle-1.6.0}/tests/test_cache_management.py

@@ -39,19 +39,60 @@ def open_cached(tmp_path, monkeypatch):
     def graph(network):
         built.append(True)
 
-    def open_engine(*, io=None):
+    def open_engine(*, io=None, settings=None, force_rebuild=False):
         return tensoracle.open_engine(
             graph,
-            tensoracle.EngineBuild({}),
+            tensoracle.EngineBuild({}, settings or tensoracle.BuilderSettings()),
             name="timestamp",
             graph_version="1",
             weights=(weight,),
             io=io or tensoracle.EngineIO({}, {}),
+            force_rebuild=force_rebuild,
         )
 
     return open_engine, built
 
 
+@pytest.mark.req("SP-TENSORACLE-052")
+@pytest.mark.parametrize("workspace_limit", [None, 8192])
+def test_workspace_limit_changes_reuse_saved_engine(open_cached, workspace_limit):
+    """Changing only the workspace limit reuses the same file without invoking the graph."""
+    open_engine, built = open_cached
+    first = open_engine(settings=tensoracle.BuilderSettings(workspace_limit=4096))
+    contents = first.path.read_bytes()
+    reopened = open_engine(settings=tensoracle.BuilderSettings(workspace_limit=workspace_limit))
+    assert reopened.path == first.path
+    assert built == [True]
+    assert first.path.read_bytes() == contents
+
+
+@pytest.mark.req("SP-TENSORACLE-052")
+@pytest.mark.req("SP-TENSORACLE-011")
+@pytest.mark.parametrize("workspace_limit", [None, 4096])
+def test_saved_engine_records_workspace_limit_and_updates_it_only_on_rebuild(
+    open_cached, workspace_limit
+):
+    """Headers record the actual build's workspace outside conditions and forced rebuilds replace it."""
+    open_engine, built = open_cached
+
+    def header(path):
+        with path.open("rb") as stream:
+            return cache._read_header(stream, path, path.stat().st_size)
+
+    first = open_engine(settings=tensoracle.BuilderSettings(workspace_limit=workspace_limit))
+    original = header(first.path)
+    assert original["workspace_limit"] == workspace_limit
+    assert original["conditions"]["builder_settings"] == {"optimization_level": 3, "tf32": False}
+    changed_limit = 8192 if workspace_limit is None else None
+    rebuilt = open_engine(
+        settings=tensoracle.BuilderSettings(workspace_limit=changed_limit), force_rebuild=True
+    )
+    assert rebuilt.path == first.path
+    assert header(rebuilt.path)["workspace_limit"] == changed_limit
+    assert header(rebuilt.path)["conditions"] == original["conditions"]
+    assert built == [True, True]
+
+
 @pytest.mark.req("SP-TENSORACLE-042")
 @pytest.mark.req("SP-TENSORACLE-048")
 @pytest.mark.req("SP-TENSORACLE-046")

{tensoracle-1.5.0 → tensoracle-1.6.0}/tests/test_weight_hash.py

@@ -297,6 +297,7 @@ def test_record_lives_in_user_cache_directory(tmp_path, monkeypatch, xdg):
 
 @pytest.mark.req("SP-TENSORACLE-002")
 @pytest.mark.req("SP-TENSORACLE-009")
+@pytest.mark.req("SP-TENSORACLE-052")
 def test_engine_identity_matches_the_full_hash_calculation(tmp_path, monkeypatch):
     """Stored digests produce the same conditions and engine name as full file hashing."""
     root = tmp_path / "cache"
@@ -312,7 +313,7 @@ def test_engine_identity_matches_the_full_hash_calculation(tmp_path, monkeypatch
         "weights": [hashlib.sha256(weight.read_bytes()).hexdigest()],
         "plugins": [hashlib.sha256(plugin.read_bytes()).hexdigest()],
         "inputs": {"features": {"minimum": [1, 3, 2], "optimum": [1, 3, 2], "maximum": [1, 3, 2]}},
-        "builder_settings": {"workspace_limit": 1 << 30, "optimization_level": 3, "tf32": False},
+        "builder_settings": {"optimization_level": 3, "tf32": False},
         "gpu": {"name": "GPU A"},
         "os": cache.platform.system(),
         "architecture": cache.platform.machine(),