cascade-cms-rest 3.2.2__tar.gz → 3.3.0__tar.gz

{cascade_cms_rest-3.2.2 → cascade_cms_rest-3.3.0}/.github/workflows/release.yml

@@ -6,7 +6,7 @@ on:
       - "v*.*.*"
 
 permissions:
-  contents: write
+  contents: read
   id-token: write
 
 jobs:
@@ -28,20 +28,6 @@ jobs:
           name: dist
           path: dist/
 
-  release:
-    needs: build
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/download-artifact@v4
-        with:
-          name: dist
-          path: dist/
-      - name: Create GitHub release
-        uses: softprops/action-gh-release@v2
-        with:
-          files: dist/*
-          generate_release_notes: true
-
   publish:
     name: Publish to PyPI
     needs: build

{cascade_cms_rest-3.2.2 → cascade_cms_rest-3.3.0}/AGENTS.md

@@ -26,6 +26,19 @@ skill-authoring workflow and how to rebuild release artifacts — both depend
 on the *published* `cascade-cms-rest` package, not a local copy, so nothing
 here needs to stay in sync with them beyond tagging a release.
 
+## Logging and console output
+
+- `CascadeWrapperBase(environmentVariables, debug=None, *, exit_on_failure=True,
+  log_dir=None)` — there is no response cache and no `configurationVariables`.
+- Status lines (`[INIT]`, `[LOG]: <path>`, `[DONE]`, the tally, `[EXIT]`, console `[ERROR]`)
+  go to **stderr**; stdout belongs to the caller's script.
+- The logfile records the tally line and, last, `[EXIT-CODE]: <outcome>` (see the README's
+  Logging section for the outcomes). Agents verify a run by reading the logfile at the
+  `[LOG]` path, not by capturing console output.
+- `log_dir` (explicit parameter) beats a debug config's `log_dir`; default `./logs`. Log
+  filenames are `{SERVER}[_debug]_{timestamp}_{n}.log`.
+- The API bearer token is masked (`cascade_cms.redaction.mask_token`) wherever it could surface.
+
 ## Maintaining the CHANGELOG
 
 Each section in `CHANGELOG.md` should include a note at the bottom listing

{cascade_cms_rest-3.2.2 → cascade_cms_rest-3.3.0}/CHANGELOG.md

@@ -2,6 +2,36 @@
 
 All notable changes to this project will be documented in this file.
 
+## [3.3.0]
+
+### Removed
+- **BREAKING: response caching is removed entirely** (no persistent and no in-memory cache): `CacheHandler`, `default_cache_backend()`, `OperationLogger.log_cache_hit()` and `ResponseParser._cacheable`. No `./cache` directory is created.
+- **BREAKING: `configurationVariables` is removed from `CascadeWrapperBase`** with no deprecation period. `CascadeWrapperBase(environmentVariables, debug=None, *, exit_on_failure=True, log_dir=None)`; `exit_on_failure` is now keyword-only.
+- **BREAKING: `backendConfig` is removed from `CascadeCMSRestDriver`.**
+- **BREAKING: `python-dotenv` is no longer a dependency**, and `aiohttp-client-cache` is dropped. `aiohttp` is now a direct dependency (`>=3.14.3`).
+
+### Changed
+- **BREAKING: status lines go to stderr instead of stdout** (`[INIT]`, `[DEBUG]`, `[DONE]`, the tally, `[EXIT]`, console `[ERROR]`). Anything reading the tally from stdout must read stderr or the logfile.
+- **BREAKING: a non-200 HTTP status is now a `CascadeError` (category CASCADE, message `"<status> <reason>"`)**, no longer a NETWORK failure. The response body is never read or logged.
+- **BREAKING: `ResponseParser.serializer` is now required**; the `RuntimeWarning` branch is gone.
+- **BREAKING: `RequestExecutor.parser` is now required** (the unused default was removed). `RequestExecutor` is exported from `cascade_cms/__init__.py`.
+- Log filenames now include microseconds and a per-process serial (`{SERVER}[_debug]_{timestamp}_{n}.log`), so two wrappers created in the same second never share a file.
+- A batch-level failure's prefix follows its cause: `[NETWORK]` for network causes, `[CASCADE-REST-CMS]` otherwise.
+- `CascadeCMSRestDriver.close()` clears the closed event loop as the current loop.
+- Release process: the tag-triggered workflow no longer creates a GitHub release (PyPI publishing on tag push is unchanged, with `contents: read`), and `PUBLISHING.md` no longer has a manual `twine upload` step.
+
+### Added
+- `log_dir` keyword-only parameter on `CascadeWrapperBase` (normal and debug mode; created if missing; wins over a debug config's `log_dir`).
+- `[LOG]: <path>` is printed to stderr right after `[INIT]`.
+- The logfile records the tally line and a final `[EXIT-CODE]: <outcome>` line.
+- `cascade_cms.redaction.mask_token()`; the debug logfile masks the `Authorization` header to its last four characters (`Bearer ****abcd`).
+
+### Fixed
+- Each wrapper closes and releases its logfile handle on exit.
+- Verified (Python 3.12): Cascade's `Partitioned` session cookie no longer breaks requests now that the cache library is gone; no compatibility patch is needed in the library.
+
+**Files changed:** `src/cascade_cms/driver.py`, `src/cascade_cms/wrapper.py`, `src/cascade_cms/operation_logger.py`, `src/cascade_cms/cmstypes.py`, `src/cascade_cms/redaction.py` (added), `pyproject.toml`, `.github/workflows/release.yml`, `PUBLISHING.md`, `README.md`, `AGENTS.md`, `tests/test_driver.py`, `tests/test_non200.py` (added), `tests/test_redaction.py` (added), `tests/test_logging_exit.py` (added), `tests/edit_test.py`
+
 ## [3.2.2]
 
 ### Added

{cascade_cms_rest-3.2.2 → cascade_cms_rest-3.3.0}/PKG-INFO

@@ -1,15 +1,14 @@
 Metadata-Version: 2.5
 Name: cascade-cms-rest
-Version: 3.2.2
+Version: 3.3.0
 Summary: A typed, async REST client for Hannon Hill Cascade CMS
 Project-URL: Homepage, https://github.com/Sharkdroid/py-cascade-cms
 Author: Keith Shark
 License-Expression: MIT
 License-File: LICENSE
 Requires-Python: >=3.12
-Requires-Dist: aiohttp-client-cache[sqlite]
+Requires-Dist: aiohttp>=3.14.3
 Requires-Dist: pydantic>=2
-Requires-Dist: python-dotenv
 Provides-Extra: dev
 Requires-Dist: build; extra == 'dev'
 Requires-Dist: mypy; extra == 'dev'
@@ -36,13 +35,8 @@ environment_variables = {
     "CASCADE_URL": "...",
     "SERVER": "prod",  # label used for logfile naming
 }
-configuration_variables = {
-    "cache_name": "./cache/cache.sqlite",
-    "allowed_codes": (200,),
-    "allowed_methods": ("GET",),
-}
 
-with CascadeWrapperBase(environment_variables, configuration_variables) as cascade:
+with CascadeWrapperBase(environment_variables) as cascade:
     identifier = IdentifierType(identifier="e868f539ac1001062cfa029c4c5df4d0", asset_type="folder")
     cascade.operations.read(identifier)
     results = cascade.submit_requests(Asset)
@@ -69,7 +63,7 @@ def rewrite(asset):
     asset.keywords = "updated"
     return asset
 
-with CascadeWrapperBase(environment_variables, configuration_variables) as cascade:
+with CascadeWrapperBase(environment_variables) as cascade:
     cascade.operations.read(page_a).edit(page_a, rewrite).publish(page_a)
     cascade.operations.read(page_b).then(report)
     cascade.operations.delete(old_page)
@@ -114,14 +108,17 @@ manager owns it end to end:
   server) — `__exit__` then never raises; read `.success`/`.failed` off the results yourself.
 - The logfile's `!ERROR:` line is prefixed `[NETWORK]` for a network-layer failure or
   `[CASCADE-REST-CMS]` for any other library-side failure; a `CascadeError` or a callback
-  exception gets no prefix.
+  exception gets no prefix. A batch-level failure takes the prefix that matches its cause.
+- Cascade always answers HTTP 200 with a JSON body; a non-200 status (an HTML page from the
+  server layer, e.g. `501 Not Implemented`) is reported as a `CascadeError` whose message is the
+  status code and reason. The HTML body is never read or logged.
 - At exit, the console always prints a tally: `"{failed} failed, {succeeded} succeeded"`,
   cumulative across every `submit_requests()` call in the session, with `": reference log for
   details"` appended only when at least one failure came from the API, the network, or the
-  library itself (not from a callback-only failure).
+  library itself (not from a callback-only failure). The tally is also written to the logfile.
 
 ```python
-with CascadeWrapperBase(environment_variables, configuration_variables) as cascade:
+with CascadeWrapperBase(environment_variables) as cascade:
     cascade.operations.read(identifier)
     results = cascade.submit_requests(Asset)
     for asset in results.success:
@@ -132,11 +129,24 @@ with CascadeWrapperBase(environment_variables, configuration_variables) as casca
 
 ### Logging
 
-`CascadeWrapperBase` accepts an optional third `debug` argument. Leaving it as `None`
-(the default) runs in **normal mode**: a minimal console (`[INIT]`/`[RUNNING]`/`Processed: n/N`/
-`[DONE]`/`[EXIT]`) plus a simple logfile at `./logs/{SERVER}_{timestamp}.log`. Passing a dict
+`CascadeWrapperBase` accepts an optional second `debug` argument. Leaving it as `None`
+(the default) runs in **normal mode**: a minimal console (`[INIT]`/`[LOG]`/`[RUNNING]`/`n/N succeeded`/
+`[DONE]`/`[EXIT]`) plus a simple logfile at `./logs/{SERVER}_{timestamp}_{n}.log`. Passing a dict
 switches to **debug mode**: a quiet console and a verbose, nested logfile at
-`./logs/{SERVER}_debug_{timestamp}.log` describing every request, response, callback, and error.
+`./logs/{SERVER}_debug_{timestamp}_{n}.log` describing every request, response, callback, and error.
+Each wrapper gets its own file, even when two are created in the same second.
+
+- **Status lines go to stderr**, not stdout (`[INIT]`, `[LOG]`, `[DONE]`, the tally, `[EXIT]`,
+  console `[ERROR]` lines), so stdout stays free for your script's own output.
+- **`[LOG]: <path>`** is printed right after `[INIT]`, giving the path of this run's logfile.
+- **`log_dir=`** (keyword-only) sets the log directory in normal and debug mode; it is created if
+  missing and defaults to `./logs`. If a debug config also sets `log_dir`, the parameter wins.
+- **`[EXIT-CODE]:`** is the last line written to the logfile: `0` for a clean run, `1` when the
+  script ends with a failure, `1 (callback exception: <Type>)` / `1 (uncaught exception: <Type>)`
+  when an exception ends it, or `n/a (exit_on_failure disabled)`. Read the logfile for the tally
+  and exit code rather than capturing console output.
+- In debug mode with `show_network_headers`, the `Authorization` header is masked to its last four
+  characters (`Bearer ****abcd`).
 
 ```python
 debug_config = {
@@ -150,7 +160,7 @@ debug_config = {
     "response_line_limit": 8,   # -1 = dump full response body
 }
 
-with CascadeWrapperBase(environment_variables, configuration_variables, debug=debug_config) as cascade:
+with CascadeWrapperBase(environment_variables, debug=debug_config) as cascade:
     ...
 ```
 

{cascade_cms_rest-3.2.2 → cascade_cms_rest-3.3.0}/PUBLISHING.md

@@ -74,21 +74,16 @@
    git push origin master --tags       # Push commits + all tags
    ```
 
-### 6. Build & Publish to PyPI
+### 6. Publishing Happens Automatically
 
-   **Build:**
-   ```bash
-   python -m build
-   ```
-   
-   This creates `dist/cascade_cms_rest-3.0.2-py3-none-any.whl` and `.tar.gz`
+   Pushing the `v*` tag (step 5) triggers the **Release** workflow
+   (`.github/workflows/release.yml`), which builds the sdist and wheel and
+   publishes them to PyPI. Do **not** run `twine upload` by hand: the tag
+   already publishes via CI, so a manual upload collides ("file already
+   exists"), and a stale local `dist/` would re-upload old versions.
 
-   **Publish:**
-   ```bash
-   twine upload dist/*
-   ```
-   
-   You'll be prompted for PyPI credentials (or use `.pypirc` config)
+   Watch the workflow run in the GitHub Actions tab, then verify on PyPI
+   (below). The workflow does not create a GitHub release.
 
 ## Verification
 
@@ -112,12 +107,10 @@ git commit -m "Bump version to 3.0.2"
 # 4. Create an annotated tag (v-prefix is convention)
 git tag -a v3.0.2 -m "Release version 3.0.2"
 
-# 5. Push commits and tags to GitHub
+# 5. Push commits and tags to GitHub; the tag push publishes to PyPI via CI
 git push origin master --tags
 
-# 6. Build and publish to PyPI
-python -m build
-twine upload dist/*
+# 6. Verify on PyPI (https://pypi.org/project/cascade-cms-rest/)
 ```
 
 ## Troubleshooting

{cascade_cms_rest-3.2.2 → cascade_cms_rest-3.3.0}/README.md

@@ -15,13 +15,8 @@ environment_variables = {
     "CASCADE_URL": "...",
     "SERVER": "prod",  # label used for logfile naming
 }
-configuration_variables = {
-    "cache_name": "./cache/cache.sqlite",
-    "allowed_codes": (200,),
-    "allowed_methods": ("GET",),
-}
 
-with CascadeWrapperBase(environment_variables, configuration_variables) as cascade:
+with CascadeWrapperBase(environment_variables) as cascade:
     identifier = IdentifierType(identifier="e868f539ac1001062cfa029c4c5df4d0", asset_type="folder")
     cascade.operations.read(identifier)
     results = cascade.submit_requests(Asset)
@@ -48,7 +43,7 @@ def rewrite(asset):
     asset.keywords = "updated"
     return asset
 
-with CascadeWrapperBase(environment_variables, configuration_variables) as cascade:
+with CascadeWrapperBase(environment_variables) as cascade:
     cascade.operations.read(page_a).edit(page_a, rewrite).publish(page_a)
     cascade.operations.read(page_b).then(report)
     cascade.operations.delete(old_page)
@@ -93,14 +88,17 @@ manager owns it end to end:
   server) — `__exit__` then never raises; read `.success`/`.failed` off the results yourself.
 - The logfile's `!ERROR:` line is prefixed `[NETWORK]` for a network-layer failure or
   `[CASCADE-REST-CMS]` for any other library-side failure; a `CascadeError` or a callback
-  exception gets no prefix.
+  exception gets no prefix. A batch-level failure takes the prefix that matches its cause.
+- Cascade always answers HTTP 200 with a JSON body; a non-200 status (an HTML page from the
+  server layer, e.g. `501 Not Implemented`) is reported as a `CascadeError` whose message is the
+  status code and reason. The HTML body is never read or logged.
 - At exit, the console always prints a tally: `"{failed} failed, {succeeded} succeeded"`,
   cumulative across every `submit_requests()` call in the session, with `": reference log for
   details"` appended only when at least one failure came from the API, the network, or the
-  library itself (not from a callback-only failure).
+  library itself (not from a callback-only failure). The tally is also written to the logfile.
 
 ```python
-with CascadeWrapperBase(environment_variables, configuration_variables) as cascade:
+with CascadeWrapperBase(environment_variables) as cascade:
     cascade.operations.read(identifier)
     results = cascade.submit_requests(Asset)
     for asset in results.success:
@@ -111,11 +109,24 @@ with CascadeWrapperBase(environment_variables, configuration_variables) as casca
 
 ### Logging
 
-`CascadeWrapperBase` accepts an optional third `debug` argument. Leaving it as `None`
-(the default) runs in **normal mode**: a minimal console (`[INIT]`/`[RUNNING]`/`Processed: n/N`/
-`[DONE]`/`[EXIT]`) plus a simple logfile at `./logs/{SERVER}_{timestamp}.log`. Passing a dict
+`CascadeWrapperBase` accepts an optional second `debug` argument. Leaving it as `None`
+(the default) runs in **normal mode**: a minimal console (`[INIT]`/`[LOG]`/`[RUNNING]`/`n/N succeeded`/
+`[DONE]`/`[EXIT]`) plus a simple logfile at `./logs/{SERVER}_{timestamp}_{n}.log`. Passing a dict
 switches to **debug mode**: a quiet console and a verbose, nested logfile at
-`./logs/{SERVER}_debug_{timestamp}.log` describing every request, response, callback, and error.
+`./logs/{SERVER}_debug_{timestamp}_{n}.log` describing every request, response, callback, and error.
+Each wrapper gets its own file, even when two are created in the same second.
+
+- **Status lines go to stderr**, not stdout (`[INIT]`, `[LOG]`, `[DONE]`, the tally, `[EXIT]`,
+  console `[ERROR]` lines), so stdout stays free for your script's own output.
+- **`[LOG]: <path>`** is printed right after `[INIT]`, giving the path of this run's logfile.
+- **`log_dir=`** (keyword-only) sets the log directory in normal and debug mode; it is created if
+  missing and defaults to `./logs`. If a debug config also sets `log_dir`, the parameter wins.
+- **`[EXIT-CODE]:`** is the last line written to the logfile: `0` for a clean run, `1` when the
+  script ends with a failure, `1 (callback exception: <Type>)` / `1 (uncaught exception: <Type>)`
+  when an exception ends it, or `n/a (exit_on_failure disabled)`. Read the logfile for the tally
+  and exit code rather than capturing console output.
+- In debug mode with `show_network_headers`, the `Authorization` header is masked to its last four
+  characters (`Bearer ****abcd`).
 
 ```python
 debug_config = {
@@ -129,7 +140,7 @@ debug_config = {
     "response_line_limit": 8,   # -1 = dump full response body
 }
 
-with CascadeWrapperBase(environment_variables, configuration_variables, debug=debug_config) as cascade:
+with CascadeWrapperBase(environment_variables, debug=debug_config) as cascade:
     ...
 ```
 

{cascade_cms_rest-3.2.2 → cascade_cms_rest-3.3.0}/pyproject.toml

@@ -4,15 +4,14 @@ build-backend = "hatchling.build"
 
 [project]
 name = "cascade-cms-rest"
-version = "3.2.2"
+version = "3.3.0"
 description = "A typed, async REST client for Hannon Hill Cascade CMS"
 readme = "README.md"
 license = "MIT"
 requires-python = ">=3.12"          # uses `Self`, `TypeAlias`, PEP 604 unions
 authors = [{ name = "Keith Shark" }]
 dependencies = [
-    "aiohttp-client-cache[sqlite]",
-    "python-dotenv",
+    "aiohttp>=3.14.3",
     "pydantic>=2",
 ]
 

{cascade_cms_rest-3.2.2 → cascade_cms_rest-3.3.0}/src/cascade_cms/cmstypes.py

@@ -1060,31 +1060,25 @@ class ResponseParser[T](BaseModel):
     """Parses a raw response body, trying `CascadeError` first and falling
     back to `serializer` on the expected success shape.
 
-    `_content` holds the parsed result (either a `CascadeError` or a `T`),
-    and `_cacheable` is set to True only when the success-path parse
-    succeeds, so error responses are never cached.
+    `_content` holds the parsed result (either a `CascadeError` or a `T`).
     """
 
     model_config = ConfigDict(arbitrary_types_allowed=True)
 
-    serializer: TypeAdapter[Any] | AssetAdapter | None = None
+    serializer: TypeAdapter[Any] | AssetAdapter
     _content: T | CascadeError | None = PrivateAttr(default=None)
-    _cacheable: bool = PrivateAttr(default=False)
 
     def __init__(
         self,
         raw: bytes,
-        serializer: TypeAdapter[Any] | AssetAdapter | None = None,
+        serializer: TypeAdapter[Any] | AssetAdapter,
         **kwargs,
     ):
         super().__init__(serializer=serializer, **kwargs)
         try:
             self._content = CascadeError.model_validate_json(raw)
         except ValidationError:
-            if self.serializer is None:
-                raise RuntimeWarning("No serializer included...")
             self._content = self.serializer.validate_json(raw)  # type: ignore[assignment]
-            self._cacheable = True
 
 
 # ----- Parser Functions -----

{cascade_cms_rest-3.2.2 → cascade_cms_rest-3.3.0}/src/cascade_cms/driver.py

@@ -1,16 +1,13 @@
 import asyncio
 import hashlib
 from collections.abc import Callable
-from dataclasses import dataclass, field
+from dataclasses import dataclass
 from typing import Any, Literal, TypeVar
 
 from aiohttp import ClientResponse, ClientSession
-from aiohttp_client_cache import SQLiteBackend
-
-# from aiohttp_client_cache.session import CachedSession
-from aiohttp_client_cache.response import CachedResponse
 
 from .cmstypes import (
+    CascadeError,
     Payloads,
     ResponseParser,
     serialize_payload,
@@ -20,40 +17,6 @@ from .operation_logger import OperationLogger
 T = TypeVar("T")
 
 
-@dataclass
-class CacheHandler:
-    """Thin wrapper around an aiohttp-client-cache SQLite backend.
-
-    Only GET responses are ever cached (enforced by the backend's
-    `allowed_methods` config) so repeated reads skip the network,
-    while POST/PUT requests always hit the server.
-    """
-
-    cache_db: SQLiteBackend
-
-    async def get_response(
-        self,
-        key: str,
-    ) -> CachedResponse | None:
-        return await self.cache_db.get_response(key)
-
-    def get_cache_key(
-        self,
-        method: str,
-        url: str,
-    ) -> str:
-        """Returns a response in cach if it exists"""
-        return self.cache_db.create_key(method, url)
-
-    async def save_response(
-        self,
-        response: ClientResponse,
-        cache_key: str,
-    ):
-        """Check to see if response is cacheable"""
-        return await self.cache_db.save_response(response, cache_key)
-
-
 @dataclass
 class RequestExecutor[T]:
     """Represents a single HTTP request and how to parse its response.
@@ -64,9 +27,7 @@ class RequestExecutor[T]:
 
     url: str
     method: Literal["GET", "POST", "PUT"]
-    parser: Callable[..., ResponseParser[T]] = field(
-        default=lambda raw: ResponseParser(raw=raw)
-    )
+    parser: Callable[..., ResponseParser[T]]
     payload: Payloads | None = None
     identifier: Any = None
 
@@ -88,19 +49,15 @@ class RequestExecutor[T]:
         self,
         session: ClientSession,
         sem: asyncio.Semaphore,
-        cache: CacheHandler,
         logger: "OperationLogger | None" = None,
     ) -> T:
-        """Execute this request, using the cache for GETs when possible.
+        """Execute this request and parse its response.
 
-        Checks the cache first; on a miss, performs the network request,
-        parses the response, and stores it in the cache if parsing marked
-        it cacheable. Concurrency across requests is bounded by `sem`.
+        Concurrency across requests is bounded by `sem`.
 
         Args:
             session: Shared aiohttp session to issue the request on.
             sem: Semaphore limiting concurrent in-flight requests.
-            cache: Cache handler used to short-circuit repeated GETs.
             logger: Optional logger for recording request/response detail.
 
         Returns:
@@ -111,23 +68,18 @@ class RequestExecutor[T]:
             if self.payload:
                 payload_bytes = serialize_payload(self.payload)
 
-            # Cache the Response
-            cache_key = cache.get_cache_key(self.method, self.url)
-            already_cached = await cache.get_response(cache_key)
-            if already_cached is not None:
-                raw_data = await already_cached.read()
-                if logger:
-                    logger.log_cache_hit(self.method, self.url)
-                    logger.write_response_file(self.log_key, raw_data)
-                parsed_response = self.parser(raw_data)
-                return parsed_response._content  # type: ignore[return-value]
-
             async with session.request(
                 self.method,
                 self.url,
                 data=payload_bytes,
             ) as response:
-                response.raise_for_status()
+                if response.status != 200:
+                    # Cascade always answers 200 with a JSON body; anything
+                    # else is an HTML page from the Tomcat layer. Report the
+                    # status only — the body is never read, logged or shown.
+                    return CascadeError(  # type: ignore[return-value]
+                        message=f"{response.status} {response.reason}"
+                    )
                 raw_data = await response.read()
                 if logger:
                     logger.write_response_file(self.log_key, raw_data)
@@ -137,29 +89,9 @@ class RequestExecutor[T]:
                     )
                 # parse raw data
                 parsed_response = self.parser(raw_data)
-
-                if parsed_response._cacheable:
-                    await cache.save_response(
-                        response,
-                        cache_key,
-                    )
                 return parsed_response._content  # type: ignore[return-value]
 
 
-def default_cache_backend() -> SQLiteBackend:
-    """Build the default cache backend: SQLite, GET-only, 200s only.
-
-    Constructed on demand rather than at module scope so that merely
-    importing `cascade_cms` does not create a `./cache/` directory in the
-    caller's working directory.
-    """
-    return SQLiteBackend(
-        cache_name="./cache/cache.sqlite",
-        allowed_codes=(200,),
-        allowed_methods=("GET",),
-    )
-
-
 class CascadeCMSRestDriver:
     """
     URL builder and executor for Cascade CMS 8 REST API.
@@ -172,21 +104,18 @@ class CascadeCMSRestDriver:
         self,
         apiKey: str,
         cascade_url: str,
-        backendConfig: dict[str, Any] | None,
         logger: OperationLogger | None = None,
     ):
-        """Set up the aiohttp session, event loop, and cache for this driver.
+        """Set up the aiohttp session and event loop for this driver.
 
         Creates a dedicated event loop that is reused for the lifetime of
         this driver instance (rather than one per call), so all requests
-        and cache I/O run on the same loop.
+        run on the same loop.
 
         Args:
             apiKey: Cascade CMS API bearer token.
             cascade_url: Base URL of the Cascade CMS instance (without
                 the `/api/v1` suffix, which is appended automatically).
-            backendConfig: kwargs forwarded to `SQLiteBackend` to override
-                the default cache config, or None to use the default.
             logger: Optional logger for recording operations/errors.
         """
 
@@ -196,7 +125,7 @@ class CascadeCMSRestDriver:
         self.base_url = f"{cascade_url}/api/v1"
 
         # Stores response object for debugging purpose. the ClientResponse object contains request infomation as well.
-        self.request_response_info: CachedResponse | None = None
+        self.request_response_info: ClientResponse | None = None
 
         # intializing event loop, for re-use for the rest of the session.
         self.eventLoop = asyncio.new_event_loop()
@@ -208,12 +137,6 @@ class CascadeCMSRestDriver:
             "Content-Type": "application/json;charset=UTF-8",
         }
 
-        self.cache: CacheHandler
-        if backendConfig is None:
-            self.cache = CacheHandler(default_cache_backend())
-        else:
-            self.cache = CacheHandler(SQLiteBackend(**backendConfig))
-
         # Shared across every chain running on this driver, so concurrency
         # stays bounded no matter how many chains are in flight at once.
         self._semaphore = asyncio.Semaphore(self.MAX_REQUESTS)
@@ -259,7 +182,7 @@ class CascadeCMSRestDriver:
             # job (execute/execute_async), done after this returns a value.
             try:
                 return await executor.fetch(
-                    self.session, self._semaphore, self.cache, self._logger
+                    self.session, self._semaphore, self._logger
                 )
             except Exception as exc:  # noqa: BLE001 - surfaced as a value, see docstring
                 return exc
@@ -283,17 +206,12 @@ class CascadeCMSRestDriver:
         return self.eventLoop.run_until_complete(self.execute_requests(requests))
 
     def close(self):
-        """Tear down the aiohttp session, cache DB, and event loop."""
+        """Tear down the aiohttp session and event loop."""
         if getattr(self, "session", None) is not None and not getattr(
             self.session, "closed", False
         ):
             self.eventLoop.run_until_complete(self.session.close())
 
-        if (
-            getattr(self, "cache", None) is not None
-            and getattr(self.cache, "cache_db", None) is not None
-        ):
-            self.eventLoop.run_until_complete(self.cache.cache_db.close())
-
         self.eventLoop.close()
+        asyncio.set_event_loop(None)
         return True