From 6345686eecdd105ccff1e3305c369b8330888907 Mon Sep 17 00:00:00 2001 From: "github-actions[bot]" <41898282+github-actions[bot]@users.noreply.github.com> Date: Sun, 8 Nov 2026 15:42:22 +0000 Subject: [PATCH 1/6] docs(3.9.2): synthesize advanced-cpu-intensive.md --- .../docs/advanced/cpu-intensive.md | 22 +++++++++---------- 1 file changed, 10 insertions(+), 12 deletions(-) diff --git a/wiki/cascade-cms-wiki/docs/advanced/cpu-intensive.md b/wiki/cascade-cms-wiki/docs/advanced/cpu-intensive.md index 770cf89..6bb6533 100644 --- a/wiki/cascade-cms-wiki/docs/advanced/cpu-intensive.md +++ b/wiki/cascade-cms-wiki/docs/advanced/cpu-intensive.md @@ -6,10 +6,11 @@ By default `.then()` callbacks run on the async event loop, which is fine for I/ ## When to Use `ProcessPoolExecutor` -- Image resizing, compression, or optimization -- Parsing large XML/JSON structures or heavy data transformation -- Running intensive regular expressions across large HTML bodies -- Light callbacks like simple string replacements or metadata dictionary updates do not need it and perform better on the default thread pool or event loop. +- Image resizing, compression, or other heavy visual asset optimization. +- Parsing and manipulating very large XML/HTML bodies or files. +- Executing complex, compute-intensive data transformations on metadata. +- Running bulk regular expression operations across large text fields. +- Contrast with light callbacks (e.g., title string replacement, simple metadata dictionary updates), which execute quickly in-process and do not require `ProcessPoolExecutor`. --- @@ -18,15 +19,12 @@ By default `.then()` callbacks run on the async event loop, which is fine for I/ ```python from concurrent.futures import ProcessPoolExecutor from os import cpu_count -from cascade_cms import Cascade - -env = {"SERVER": "prod", "API_KEY": "secret", "CASCADE_URL": "https://cascade.example.com"} def optimize_image(asset): - # CPU-bound image processing work here + # Perform heavy CPU-bound image processing here return asset -with Cascade(env, {}) as cascade: +with Cascade(env_vars) as cascade: with ProcessPoolExecutor(max_workers=cpu_count()) as executor: cascade.operations.read(id).then(optimize_image) results = cascade.submit_requests(executor=executor) @@ -58,12 +56,12 @@ cascade.operations.read(id).then(transform) ## `ProcessPoolExecutor` vs `ThreadPoolExecutor` -`ProcessPoolExecutor` provides true parallelism across multiple CPU cores in separate memory spaces, but requires all callback functions and data to be picklable and incurs inter-process communication overhead. `ThreadPoolExecutor` uses shared memory with minimal overhead and no pickling restrictions, but remains limited by Python's Global Interpreter Lock (GIL) for CPU-bound tasks. Use `ProcessPoolExecutor` for heavy CPU computation, and stick with `ThreadPoolExecutor` (the default) for I/O-bound work. +`ProcessPoolExecutor` provides true parallelism by running callbacks in separate worker processes with independent memory spaces, making it ideal for CPU-bound tasks, though it incurs higher startup overhead and requires picklable functions. `ThreadPoolExecutor` runs tasks concurrently within the same process sharing memory with lower overhead, but Python's Global Interpreter Lock (GIL) prevents it from achieving true parallelism for CPU-bound work. Use `ProcessPoolExecutor` for heavy compute operations and `ThreadPoolExecutor` (the default) for standard I/O-bound tasks. --- ## Performance Considerations -Spawning and managing worker processes carries an initialization overhead, meaning extremely fast callbacks may run slower in a process pool than synchronously due to serialization costs. Additionally, offloading CPU work via the executor does not change the network concurrency rules; the driver's underlying `MAX_REQUESTS` semaphore still governs HTTP request limits. +Spawning and managing worker processes carries a startup cost, so for very fast, lightweight callbacks the inter-process serialization overhead may actually outweigh the performance benefit. Additionally, keep in mind that the driver's internal request semaphore still governs HTTP concurrency independently of whichever executor you choose for your synchronous callbacks. - + From e5c136243605b982ffd25824e158ba7bae237d4a Mon Sep 17 00:00:00 2001 From: "github-actions[bot]" <41898282+github-actions[bot]@users.noreply.github.com> Date: Sun, 8 Nov 2026 15:42:24 +0000 Subject: [PATCH 2/6] docs(3.9.2): synthesize core-concepts-index.md --- .../docs/core-concepts/index.md | 210 +++++------------- 1 file changed, 52 insertions(+), 158 deletions(-) diff --git a/wiki/cascade-cms-wiki/docs/core-concepts/index.md b/wiki/cascade-cms-wiki/docs/core-concepts/index.md index 4084a01..5b0e64b 100644 --- a/wiki/cascade-cms-wiki/docs/core-concepts/index.md +++ b/wiki/cascade-cms-wiki/docs/core-concepts/index.md @@ -1,197 +1,91 @@ # Core Concepts -## The `Cascade` class +This page unpacks the mental model behind Cascade CMS: the `Cascade` context manager ties together a REST driver, an operation logger, and an `Operations` builder that yields independent `OperationChain` instances, all executed concurrently via `submit_requests()`. -`Cascade` is the single entry point for all library interactions. Open a -session with it as a [context manager](https://docs.python.org/3/reference/datamodel.html#context-managers): - -```python -from cascade_cms.wrapper import Cascade, EnvironmentVars - -env: EnvironmentVars = { - "SERVER": "my-site", - "API_KEY": "your-api-key", - "CASCADE_URL": "https://your-cascade-instance.com", -} +--- -with Cascade(env) as cascade: - # queue operations here - ... -``` +## Basic Operation Calls -Previously known as `CascadeWrapperBase`; the alias still works but `Cascade` -is the current name. +Every script follows the same skeleton — open the wrapper as a context manager, queue operations on `cascade.operations`, chain callbacks with `.then()`, then call `submit_requests()` once to execute all chains concurrently. This design keeps network requests clean, isolates failures per asset, and eliminates boilerplate. -### Constructor +### Example ```python -Cascade( - environmentVariables: EnvironmentVars, - debug: dict[str, Any] | None = None, - *, - exit_on_failure: bool = True, - log_dir: str | os.PathLike | None = None, -) +with Cascade(env_vars) as cascade: + # Queue a read operation for a specific asset identifier + cascade.operations.read(identifier) + + # Execute all queued chains concurrently + results = cascade.submit_requests() + + # Check results for API-level errors + for result in results: + if isinstance(result, CascadeError): + print(f"Error: {result.message}") ``` -`EnvironmentVars` is a `TypedDict` with three required keys: - -| Key | Description | -|---|---| -| `SERVER` | Label used in log output (not a network address) | -| `API_KEY` | Cascade REST API bearer token | -| `CASCADE_URL` | Base URL of your Cascade CMS instance | - -`exit_on_failure=True` (default) ends the script non-zero on any failure. -Pass `False` for long-lived processes like the MCP server. - ---- - -## Operations - -`cascade.operations` is the entry point for all CMS operations. It returns -an `Operations` builder that accepts the first call in a chain: +### Expected Output ```python -with Cascade(env) as cascade: - chain = cascade.operations.read("abc123") +Asset(_asset_type='page', _data={...}) ``` -Available operations mirror the Cascade REST API: - -| Operation | Description | -|---|---| -| `.read(id)` | Read one asset | -| `.edit(payload)` | Edit an asset via callback or direct payload | -| `.publish(id)` | Publish an asset | -| `.delete(id)` | Delete an asset | -| `.copy(id, dest)` | Copy an asset | -| `.move(id, dest)` | Move an asset | -| `.checkIn(id)` | Check in an asset | -| `.checkOut(id)` | Check out an asset | -| `.search(query)` | Search assets | -| `.create(asset)` | Create a new asset | - -See the [API Reference](../operations/operations.md) for full signatures. - --- -## Operation chains - -Each operation call returns an `OperationChain`, not a result. Nothing -executes until you call `.submit_requests()`. This design lets you compose -multi-step workflows before any network requests are made: - -```python -from cascade_cms.cmstypes import Asset - -def set_searchable(asset: Asset) -> Asset: - asset.searchable = True - return asset - -with Cascade(env) as cascade: - results = ( - cascade.operations - .read("abc123") - .edit(set_searchable) - .publish("abc123") - .submit_requests(Asset) - ) -``` - -The type argument to `.submit_requests()` is for the type checker. `Asset` -covers most cases; use a more specific type when the operation returns one. - ---- +## Payload Models -## `edit()` and callbacks +Payload models are strongly typed Pydantic objects (inheriting from `SimplePayload`) that pair with specific REST operations to ensure the API endpoint receives the expected fields. They provide type safety, autocomplete, and proper serialization aliases (like converting Python snake_case to Cascade camelCase) without requiring raw dictionaries. -`edit()` accepts a callable, a single asset, or a list of assets. The -callable form is the most common in practice: +### Example: `SearchInformation` paired with `search` ```python -def update_keywords(asset: Asset) -> Asset: - asset.keywords = "updated" - return asset - -cascade.operations.edit(update_keywords) -``` - -The callback receives the current asset and must return the modified asset. -The identifier is derived from the asset's own `id`/`path`/`siteName` fields -— there is no separate identifier argument on `edit()` in 3.9.1. - ---- - -## Batch execution and `ChainGroup` - -Passing a list to operations that accept identifiers — `read`, `delete`, -`publish`, etc. — creates one independent `OperationChain` per identifier, -returned as a `ChainGroup`: +from cascade_cms.cmstypes import SearchInformation + +# Construct the payload with search criteria +payload = SearchInformation( + siteName="Default", + searchTerms="article", + searchFields=["name"], + searchTypes=["page"] +) -```python -with Cascade(env) as cascade: - results = ( - cascade.operations - .read(["id1", "id2", "id3"]) - .submit_requests(Asset) - ) +with Cascade(env_vars) as cascade: + # Pass the typed payload to the search operation + cascade.operations.search(payload) + results = cascade.submit_requests() ``` -Failures in one chain do not cancel others. The returned `ChainResults` -covers all chains in the group. +These models enforce required arguments at validation time, preventing malformed requests from ever hitting the wire. Other operations follow the exact same pattern using models like `deleteParameters`, `auditParameters`, and `publishInformation`. --- -## Result handling +## CPU-Intensive Operations -`.submit_requests()` returns `ChainResults[T]` — a list subclass with -`.success` and `.failed` properties. See [Result Handling](../getting-started/result-handling.md) -for full details. +For operations involving heavy computation in `.then()` callbacks — image processing, data transformation, bulk string manipulation — offload work to a `ProcessPoolExecutor` rather than running it on the async event loop. ```python -results = cascade.operations.read("abc123").submit_requests(Asset) +from concurrent.futures import ProcessPoolExecutor +from os import cpu_count -for asset in results.success: - print(asset.path) +def optimize_image(asset): + # Heavy CPU-bound image processing + return asset -for failure in results.failed: - print(f"[{failure.category}] {failure.message}") +with ProcessPoolExecutor(max_workers=cpu_count()) as executor: + with Cascade(env_vars) as cascade: + cascade.operations.read(id).then(optimize_image) + results = cascade.submit_requests(executor=executor) ``` ---- - -## Script logging - -`script_log.note()` writes annotated log lines from within a script: - -```python -from cascade_cms.utils import script_log - -with Cascade(env) as cascade: - script_log.note("Starting run") - results = cascade.operations.read("abc123").submit_requests(Asset) - script_log.note(f"Done — {len(results.success)} succeeded") -``` +!!! note "Module-level functions only" + Callbacks passed to `ProcessPoolExecutor` must be defined at module level — lambdas and nested functions are not picklable and will raise at runtime. -Calls outside the `with` block drop silently with a `RuntimeWarning`. -API keys are automatically redacted from log output. +See [Advanced: CPU-Intensive Tasks](../advanced/cpu-intensive.md) for full configuration details, performance trade-offs, and `ThreadPoolExecutor` comparison. --- -## Identifiers - -The `utils.identifiers` module (added in 3.8.3) coerces raw Cascade -identifier dicts to `IdentifierType`: - -```python -from cascade_cms.utils.identifiers import to_identifier, to_identifiers - -identifier = to_identifier({"id": "abc123", "type": "page", "path": None}) -identifiers = to_identifiers([{"id": "a"}, {"id": "b"}]) -``` +## Next Steps -Use these when processing raw API responses before passing identifiers to -operations. +Ready to go deeper? The [Advanced](../advanced/index.md) section covers configuration topics for power users: debug logging and CPU-intensive workload patterns. - + From b39b15c3ec675e1d6255214e42396380f8a8036c Mon Sep 17 00:00:00 2001 From: "github-actions[bot]" <41898282+github-actions[bot]@users.noreply.github.com> Date: Sun, 8 Nov 2026 15:42:26 +0000 Subject: [PATCH 3/6] docs(3.9.2): synthesize examples-administrative.md --- .../docs/examples/administrative-ops.md | 72 ++++++++++--------- 1 file changed, 40 insertions(+), 32 deletions(-) diff --git a/wiki/cascade-cms-wiki/docs/examples/administrative-ops.md b/wiki/cascade-cms-wiki/docs/examples/administrative-ops.md index fc148e5..0bd62e6 100644 --- a/wiki/cascade-cms-wiki/docs/examples/administrative-ops.md +++ b/wiki/cascade-cms-wiki/docs/examples/administrative-ops.md @@ -13,26 +13,31 @@ skeleton as the main patterns, just applied to two unrelated features. ## Messages: list, mark, delete ```python -from cascade_cms.wrapper import Cascade -from cascade_cms.cmstypes import CascadeSuccess, ListElements +from cascade_cms import CascadeCMS +from cascade_cms.cmstypes import CascadeError, Message -with Cascade(env) as cascade: +async with CascadeCMS() as cascade: # Phase 1: List inbox messages - listed = cascade.operations.listMessages().submit_requests(ListElements) - - # Pick a message from the list elements - message = listed.success[0].flat[0] - - # Phase 2: Mark as read and then delete - results = ( - cascade.operations - .markMessage(message) - .deleteMessage(message) - .submit_requests(CascadeSuccess) - ) - -for failure in results.failed: - print(f"[{failure.category}] {failure.step_name}: {failure.message}") + cascade.operations.listMessages() + results = await cascade.submit_requests() + messages_result = results[0] + + if isinstance(messages_result, CascadeError): + raise RuntimeError(messages_result.message) + + # Assume we find a message to mark and another to delete + inbox = messages_result.flat + if inbox: + target_msg = inbox[0] + + # Phase 2: Mark message read state and delete a message + cascade.operations.markMessage(target_msg) + cascade.operations.deleteMessage(target_msg) + action_results = await cascade.submit_requests() + + for res in action_results: + if isinstance(res, CascadeError): + raise RuntimeError(res.message) ``` !!! note @@ -44,22 +49,25 @@ for failure in results.failed: ## Preferences: read, edit ```python -from cascade_cms.wrapper import Cascade -from cascade_cms.cmstypes import CascadeSuccess, SimplePayload, preference +from cascade_cms import CascadeCMS +from cascade_cms.cmstypes import CascadeError, preference -with Cascade(env) as cascade: - # Read current preferences - prefs = cascade.operations.readPreferences().submit_requests(SimplePayload) +async with CascadeCMS() as cascade: + # Read current user preferences + cascade.operations.readPreferences() + results = await cascade.submit_requests() + prefs_result = results[0] + + if isinstance(prefs_result, CascadeError): + raise RuntimeError(prefs_result.message) # Update a user preference - results = ( - cascade.operations - .editPreference(preference(name="pref_name", value="new_value")) - .submit_requests(CascadeSuccess) - ) - -for failure in results.failed: - print(f"[{failure.category}] {failure.step_name}: {failure.message}") + cascade.operations.editPreference(preference(name="theme", value="dark")) + edit_results = await cascade.submit_requests() + edit_result = edit_results[0] + + if isinstance(edit_result, CascadeError): + raise RuntimeError(edit_result.message) ``` !!! note @@ -71,4 +79,4 @@ for failure in results.failed: See [Core Patterns](main-patterns.md) for `read`, `delete`, and `search` — the primary asset-management workflow and response-shape conventions. - + From bb353e3d02c1f2f5c1f9bbb1c8b1210bc4af0c26 Mon Sep 17 00:00:00 2001 From: "github-actions[bot]" <41898282+github-actions[bot]@users.noreply.github.com> Date: Sun, 8 Nov 2026 15:42:28 +0000 Subject: [PATCH 4/6] docs(3.9.2): synthesize examples-main-patterns.md --- .../docs/examples/main-patterns.md | 255 +++++++----------- 1 file changed, 100 insertions(+), 155 deletions(-) diff --git a/wiki/cascade-cms-wiki/docs/examples/main-patterns.md b/wiki/cascade-cms-wiki/docs/examples/main-patterns.md index b354156..0cde13e 100644 --- a/wiki/cascade-cms-wiki/docs/examples/main-patterns.md +++ b/wiki/cascade-cms-wiki/docs/examples/main-patterns.md @@ -1,191 +1,136 @@ -# Main Patterns +# Core Patterns: `read`, `delete`, `search` -Common usage patterns for `cascade-cms-rest` 3.9.1. +Every script that uses `cascade_cms` follows the same shape: open the wrapper as +a context manager, queue up one or more operations on `cascade.operations`, then +call `submit_requests()` once to run them all concurrently. -```python -from cascade_cms.wrapper import Cascade, EnvironmentVars -from cascade_cms.cmstypes import Asset - -env: EnvironmentVars = { - "SERVER": "my-site", - "API_KEY": "your-api-key", - "CASCADE_URL": "https://your-cascade-instance.com", -} -``` - ---- - -## Read a single asset +The three examples below use the same skeleton but highlight the **three +distinct response shapes** you'll see across the library: -```python -with Cascade(env) as cascade: - results = cascade.operations.read("abc123").submit_requests(Asset) +| Operation | Returns | Why it's shown | +|-----------|---------|----------------| +| `read` | A large, structured `Asset` object | Most operations that touch an existing asset return this shape | +| `delete` | A simple success object (`CascadeSuccess`) | Mutating operations that don't return data use this minimal shape | +| `search` | A list result, driven by a required `SearchInformation` payload | Shows the "operation needs a payload object" pattern | -if results.success: - asset = results.success[0] - print(asset.path) - print(asset.siteName) -``` +All three also demonstrate the same failure-handling rule: **failures are +returned as values, not raised.** Always check `isinstance(result, CascadeError)` +before using a result. --- -## Edit and save - -Use a callback that receives the current asset and returns the modified one: +## Pattern 1 — `read`: fetching a structured asset ```python -def update_metadata(asset: Asset) -> Asset: - asset.keywords = "cascade, cms, updated" - asset.metaDescription = "Updated via py-cascade-cms" - return asset - -with Cascade(env) as cascade: - results = ( - cascade.operations - .read("abc123") - .edit(update_metadata) - .submit_requests(Asset) - ) - -if results.failed: - for failure in results.failed: - print(f"[{failure.category}] {failure.step_name}: {failure.message}") +with CascadeWrapperBase("https://cascade.example.com", "api-key") as cascade: + # 1. Define a Path identifier pointing to the asset + path = Path(asset_type="page", site_name="Default", path="/index") + + # 2. Queue the read operation + cascade.operations.read(path) + + # 3. Submit all queued requests concurrently + results = cascade.submit_requests() + result = results[0] + + # 4. Handle failures as returned values, not raised exceptions + if isinstance(result, CascadeError): + print(f"Error: {result.message}") + else: + # Access structured asset fields + print(result.displayName) + print(result.metadata) ``` -The callback receives the asset after `.read()` completes. The identifier -is derived from the asset's own `id`/`path`/`siteName` fields — no separate -argument on `edit()`. +The `read` operation represents the response shape that most other "fetch" operations follow — such as `readAudits`, `readAccessRights`, and `readWorkflowSettings`. Each of these operations returns a structured object specific to what was requested, wrapping the server's response. --- -## Publish - -Chain `.publish()` after editing to write and publish in one batch: +## Pattern 2 — `delete`: a simple success response ```python -with Cascade(env) as cascade: - results = ( - cascade.operations - .read("abc123") - .edit(update_metadata) - .publish("abc123") - .submit_requests(Asset) +with CascadeWrapperBase("https://cascade.example.com", "api-key") as cascade: + # 1. Define a Path identifier for the target asset + path = Path(asset_type="page", site_name="Default", path="/old-page") + + # 2. Configure delete parameters payload + payload = deleteParameters( + doWorkflow=False, + destinations=[], + unpublish=True ) + + # 3. Queue the delete operation with parameters + cascade.operations.delete(path, payload=payload) + + # 4. Execute the queued requests + results = cascade.submit_requests() + result = results[0] + + # 5. Check for API-level failures + if isinstance(result, CascadeError): + print(f"Delete failed: {result.message}") + else: + print("Delete succeeded successfully.") ``` -Or publish without editing: - -```python -with Cascade(env) as cascade: - results = cascade.operations.publish("abc123").submit_requests(Asset) -``` +Mutating operations like `delete`, `copy`, `move`, `publish`, `checkIn`, and `editAccessRights` return confirmation status only rather than the modified asset data itself. Callers should not expect asset content back from these calls, relying instead on `CascadeSuccess` or error responses. --- -## Search +## Pattern 3 — `search`: payload-driven, list response ```python -from cascade_cms.cmstypes import SearchInformation, ListElements - -payload = SearchInformation( - searchTerms="annual report", - siteName="site123", -) - -with Cascade(env) as cascade: - results = ( - cascade.operations - .search(payload) - .submit_requests(ListElements) +with CascadeWrapperBase("https://cascade.example.com", "api-key") as cascade: + # 1. Build the required SearchInformation payload + payload = SearchInformation( + siteName="Default", + searchTerms="news", + searchFields=["name"], + searchTypes=["page"] ) - -if results.success: - for item in results.success: - print(item) + + # 2. Queue the search operation + cascade.operations.search(payload) + + # 3. Execute the search + results = cascade.submit_requests() + result = results[0] + + # 4. Handle errors before inspecting list elements + if isinstance(result, CascadeError): + print(f"Search failed: {result.message}") + else: + # Iterate over flat list elements + for item in result.flat: + print(item.get_id, item.get_type) ``` -`SearchInformation` is the typed payload; `ListElements` is the return type -from `.search()`. Both are in `cascade_cms.cmstypes`. - ---- - -## Bulk operations - -Pass a list of identifiers. Each gets its own independent chain — failures -in one do not cancel others: - -```python -asset_ids = ["id1", "id2", "id3"] - -def tag_asset(asset: Asset) -> Asset: - asset.tags = [{"name": "bulk-update"}] - return asset - -with Cascade(env) as cascade: - results = ( - cascade.operations - .read(asset_ids) - .edit(tag_asset) - .publish(asset_ids) - .submit_requests(Asset) - ) - -print(f"{len(results.success)} updated, {len(results.failed)} failed") - -for failure in results.failed: - print(f" {failure.identifier}: [{failure.category}] {failure.message}") -``` +The `search` method requires a strongly-typed payload object (no bare identifier shortcut is available), following the same design pattern used by operations like `readAudits` with `auditParameters`. The resulting `ListElements` container provides convenient access to matching items through its `flat` property. --- -## Handling failures by category - -`ChainFailure.category` holds the `FailureCategory` value — use it directly: - -```python -from cascade_cms.utils.failures import FailureCategory - -with Cascade(env, exit_on_failure=False) as cascade: - results = cascade.operations.read(asset_ids).submit_requests(Asset) - -network_errors = [] -cascade_errors = [] +## Chaining and Batching -for failure in results.failed: - if failure.category == FailureCategory.NETWORK: - network_errors.append(failure.identifier) - elif failure.category == FailureCategory.CASCADE: - cascade_errors.append(failure.identifier) - -if network_errors: - print(f"Network failures (retry candidates): {network_errors}") -if cascade_errors: - print(f"Cascade errors (check identifiers): {cascade_errors}") -``` - -`exit_on_failure=False` keeps the process alive to inspect failures -programmatically. - ---- - -## Script logging +All three patterns above run a single operation per script. In practice you can +queue multiple chains — even mixing operation types — before calling +`submit_requests()` once: ```python -from cascade_cms.utils import script_log - -with Cascade(env) as cascade: - script_log.note("Starting bulk keyword update") - - results = ( - cascade.operations - .read(asset_ids) - .edit(tag_asset) - .submit_requests(Asset) - ) - - script_log.note(f"Complete: {len(results.success)} updated") +with CascadeWrapperBase("https://cascade.example.com", "api-key") as cascade: + path = Path(asset_type="page", site_name="Default", path="/index") + delete_payload = deleteParameters(doWorkflow=False, destinations=[], unpublish=True) + search_payload = SearchInformation(siteName="Default", searchTerms="test") + + # Queue multiple independent chains + cascade.operations.read(path) + cascade.operations.delete(path, payload=delete_payload) + cascade.operations.search(search_payload) + + # All three run concurrently, returning results in creation order + results = cascade.submit_requests() ``` -`script_log.note()` only works inside the `with` block. +See [Administrative Operations](administrative-ops.md) for the `messages` and `preferences` operations. - + From 8d5ec44c5b9f44af739e73f1a34a15513a96845f Mon Sep 17 00:00:00 2001 From: "github-actions[bot]" <41898282+github-actions[bot]@users.noreply.github.com> Date: Sun, 8 Nov 2026 15:42:30 +0000 Subject: [PATCH 5/6] docs(3.9.2): mark advanced-index.md outdated --- wiki/cascade-cms-wiki/docs/advanced/index.md | 9 +++++++++ 1 file changed, 9 insertions(+) diff --git a/wiki/cascade-cms-wiki/docs/advanced/index.md b/wiki/cascade-cms-wiki/docs/advanced/index.md index 36d9ed5..d55d5d6 100644 --- a/wiki/cascade-cms-wiki/docs/advanced/index.md +++ b/wiki/cascade-cms-wiki/docs/advanced/index.md @@ -1,3 +1,12 @@ +!!! warning "Documentation may be out of date" + This page was not successfully updated in the latest synthesis run. If you notice inaccuracies, please open an issue. + + + # Advanced Welcome to the advanced power user guide for tuning and scaling your application. This section covers configuration and performance topics that go beyond the defaults, including caching behavior, debug logging, and CPU-intensive callback patterns. From 4128e941e49007629a2e7eaf160f6acebc34e123 Mon Sep 17 00:00:00 2001 From: "github-actions[bot]" <41898282+github-actions[bot]@users.noreply.github.com> Date: Sun, 8 Nov 2026 15:42:32 +0000 Subject: [PATCH 6/6] docs(3.9.2): mark advanced-logging.md outdated --- wiki/cascade-cms-wiki/docs/advanced/logging.md | 7 +++++++ 1 file changed, 7 insertions(+) diff --git a/wiki/cascade-cms-wiki/docs/advanced/logging.md b/wiki/cascade-cms-wiki/docs/advanced/logging.md index b93a28f..af1c06f 100644 --- a/wiki/cascade-cms-wiki/docs/advanced/logging.md +++ b/wiki/cascade-cms-wiki/docs/advanced/logging.md @@ -1,3 +1,10 @@ +!!! warning "Documentation may be out of date" + This page was not successfully updated in the latest synthesis run. If you notice inaccuracies, please open an issue. + + + # Logging & Debugging Operation logger owns all console, logfile, and (verbose mode) request/response file output for the cascade_cms library. Two output modes exist: normal mode for everyday use and debug mode for diagnosing failures, controlled solely by whether `debug_config` is `None`. Both produce logfiles; debug mode adds a verbose nested call-chain log alongside a quieter console output.