tiferet-openapi 0.1.0__tar.gz

tiferet_openapi-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Great Strength Systems
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

tiferet_openapi-0.1.0/PKG-INFO

@@ -0,0 +1,197 @@
+Metadata-Version: 2.4
+Name: tiferet-openapi
+Version: 0.1.0
+Summary: A shared OpenAPI abstraction layer for the Tiferet Framework.
+Author-email: "Andrew Shatz, Great Strength Systems" <andrew@greatstrength.me>
+License: MIT
+Project-URL: Homepage, https://github.com/greatstrength/tiferet-openapi
+Project-URL: Repository, https://github.com/greatstrength/tiferet-openapi
+Project-URL: Download, https://github.com/greatstrength/tiferet-openapi
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: tiferet>=2.0.0b1
+Provides-Extra: test
+Requires-Dist: pytest>=8.3.3; extra == "test"
+Requires-Dist: pytest_env>=1.1.5; extra == "test"
+Dynamic: license-file
+
+# Tiferet OpenAPI — A Shared OpenAPI Abstraction Layer for the Tiferet Framework
+
+## Introduction
+
+Tiferet OpenAPI provides the shared abstraction layer that both [tiferet-flask](https://github.com/greatstrength/tiferet-flask) and [tiferet-fast](https://github.com/greatstrength/tiferet-fast) depend on for OpenAPI-style API development. It extracts the common domain objects, service interfaces, domain events, mappers, YAML-backed repository, and context classes that were previously duplicated across both framework adapters.
+
+By unifying these components into a single package, tiferet-openapi eliminates code duplication, ensures behavioral consistency between Flask and FastAPI adapters, and provides a clean foundation for building new framework adapters.
+
+## Installation
+
+### From PyPI
+
+```bash
+pip install tiferet-openapi
+```
+
+### For Development
+
+```bash
+git clone https://github.com/greatstrength/tiferet-openapi.git
+cd tiferet-openapi
+python3.10 -m venv .venv
+source .venv/bin/activate
+pip install -e ".[test]"
+```
+
+## Architecture
+
+Tiferet OpenAPI follows the Tiferet framework's layered Domain-Driven Design architecture:
+
+```
+tiferet_openapi/
+├── __init__.py          — Version and public exports
+├── domain/              — ApiRoute, ApiRouter (DomainObject, Pydantic v2)
+├── interfaces/          — OpenApiService (Service ABC)
+├── events/              — GetRouters, GetRoute, GetStatusCode (DomainEvent)
+├── mappers/             — Aggregates and TransferObjects for YAML round-trip
+├── repos/               — OpenApiYamlRepository (YamlLoader-backed OpenApiService)
+└── contexts/            — OpenApiContext (AppInterfaceContext), OpenApiRequestContext
+```
+
+### Domain Objects
+
+`ApiRoute` and `ApiRouter` are read-only Pydantic v2 domain models that represent API routing configuration:
+
+- **`ApiRoute`** — An individual route with `id`, `endpoint` (format: `router_name.route_id`), `path`, `methods`, and `status_code`.
+- **`ApiRouter`** — A named group of routes with an optional URL `prefix`.
+
+### Service Interface
+
+`OpenApiService` is the abstract contract for API configuration access:
+
+- `get_routers()` — Retrieve all configured routers.
+- `get_route(route_id, router_name=None)` — Look up a single route.
+- `get_status_code(error_code)` — Map an error code to an HTTP status code.
+
+### Domain Events
+
+Three domain events encapsulate the service operations for use in the feature workflow:
+
+- **`GetRouters`** — Retrieves all routers via the injected `OpenApiService`.
+- **`GetRoute`** — Parses a dotted endpoint string (e.g., `calc.add`) and retrieves the matching route.
+- **`GetStatusCode`** — Looks up the HTTP status code for a given error code.
+
+### Mappers
+
+Aggregates and TransferObjects bridge YAML configuration and runtime domain objects:
+
+- **`ApiRouteAggregate`**, **`ApiRouterAggregate`** — Mutable aggregates with route management methods.
+- **`ApiRouteYamlObject`**, **`ApiRouterYamlObject`** — YAML serialization with `_ROLES`-based role control, `map()` for aggregate construction, `from_model()` for reverse mapping.
+
+### Repository
+
+`OpenApiYamlRepository` is the YAML-backed implementation of `OpenApiService`. It accepts a parameterized `root_key` (defaults to `"openapi"`) enabling compatibility with multiple YAML formats:
+
+- `root_key="openapi"` — unified `openapi.yml` format
+- `root_key="flask"` — legacy `flask.yml` format
+- `root_key="fast"` — legacy `fast.yml` format
+
+### Contexts
+
+- **`OpenApiContext(AppInterfaceContext)`** — Shared API context that receives `DomainEvent` instances for route and status code lookup. Provides `parse_request`, `handle_error` (with HTTP status code resolution), and `handle_response` (returning `(response, status_code)` tuples).
+- **`OpenApiRequestContext(RequestContext)`** — Pydantic-aware request context that serializes `BaseModel` results via `model_dump()`, with support for lists, dicts, `None`, and primitives.
+
+## YAML Configuration Format
+
+The repository reads configuration from a YAML file with the following structure:
+
+```yaml
+openapi:  # root_key (can be 'flask', 'fast', or any custom key)
+  routers:
+    calc:
+      prefix: /calc
+      routes:
+        add:
+          path: /add
+          methods:
+            - POST
+          status_code: 200
+        subtract:
+          path: /subtract
+          methods:
+            - POST
+          status_code: 200
+    health:
+      routes:
+        ping:
+          path: /ping
+          methods:
+            - GET
+          status_code: 200
+  errors:
+    INVALID_INPUT: 400
+    DIVISION_BY_ZERO: 422
+    NOT_FOUND: 404
+```
+
+## Usage
+
+Tiferet OpenAPI is consumed by framework-specific adapters. Here's how the shared components integrate:
+
+### In tiferet-flask / tiferet-fast
+
+Framework adapters extend `OpenApiContext` and use `OpenApiYamlRepository` as their configuration backend:
+
+```python
+# Framework adapter context (e.g., FlaskApiContext)
+from tiferet_openapi import OpenApiContext, OpenApiRequestContext
+
+class FlaskApiContext(OpenApiContext):
+    # Inherits parse_request, handle_error, handle_response
+    # Adds Flask-specific builder logic
+    pass
+```
+
+### Direct Repository Usage
+
+```python
+from tiferet_openapi import OpenApiYamlRepository
+
+# Load configuration
+repo = OpenApiYamlRepository(
+    openapi_yaml_file='app/configs/openapi.yml',
+    root_key='openapi',
+)
+
+# Retrieve all routers
+routers = repo.get_routers()
+for router in routers:
+    print(f"{router.name}: {router.prefix}")
+    for route in router.routes:
+        print(f"  {route.endpoint} -> {route.path} [{', '.join(route.methods)}]")
+
+# Look up a specific route
+route = repo.get_route('add', router_name='calc')
+print(f"Route: {route.endpoint}, Status: {route.status_code}")
+
+# Map error code to HTTP status
+status = repo.get_status_code('INVALID_INPUT')  # Returns 400
+status = repo.get_status_code('UNKNOWN')         # Returns 500 (default)
+```
+
+## Testing
+
+Run the test suite:
+
+```bash
+pytest tiferet_openapi/ -v
+```
+
+Tests are co-located in `<package>/tests/` directories:
+- **Domain/mapper tests** use direct Pydantic constructors.
+- **Event tests** use `DomainEvent.handle()` with mocked `OpenApiService`.
+- **Repo tests** are integration tests using `tmp_path` with real YAML files.
+- **Context tests** use `mock.Mock(spec=DomainEvent)` for event dependencies.
+
+## License
+
+MIT — see [LICENSE](LICENSE) for details.

tiferet_openapi-0.1.0/README.md

@@ -0,0 +1,179 @@
+# Tiferet OpenAPI — A Shared OpenAPI Abstraction Layer for the Tiferet Framework
+
+## Introduction
+
+Tiferet OpenAPI provides the shared abstraction layer that both [tiferet-flask](https://github.com/greatstrength/tiferet-flask) and [tiferet-fast](https://github.com/greatstrength/tiferet-fast) depend on for OpenAPI-style API development. It extracts the common domain objects, service interfaces, domain events, mappers, YAML-backed repository, and context classes that were previously duplicated across both framework adapters.
+
+By unifying these components into a single package, tiferet-openapi eliminates code duplication, ensures behavioral consistency between Flask and FastAPI adapters, and provides a clean foundation for building new framework adapters.
+
+## Installation
+
+### From PyPI
+
+```bash
+pip install tiferet-openapi
+```
+
+### For Development
+
+```bash
+git clone https://github.com/greatstrength/tiferet-openapi.git
+cd tiferet-openapi
+python3.10 -m venv .venv
+source .venv/bin/activate
+pip install -e ".[test]"
+```
+
+## Architecture
+
+Tiferet OpenAPI follows the Tiferet framework's layered Domain-Driven Design architecture:
+
+```
+tiferet_openapi/
+├── __init__.py          — Version and public exports
+├── domain/              — ApiRoute, ApiRouter (DomainObject, Pydantic v2)
+├── interfaces/          — OpenApiService (Service ABC)
+├── events/              — GetRouters, GetRoute, GetStatusCode (DomainEvent)
+├── mappers/             — Aggregates and TransferObjects for YAML round-trip
+├── repos/               — OpenApiYamlRepository (YamlLoader-backed OpenApiService)
+└── contexts/            — OpenApiContext (AppInterfaceContext), OpenApiRequestContext
+```
+
+### Domain Objects
+
+`ApiRoute` and `ApiRouter` are read-only Pydantic v2 domain models that represent API routing configuration:
+
+- **`ApiRoute`** — An individual route with `id`, `endpoint` (format: `router_name.route_id`), `path`, `methods`, and `status_code`.
+- **`ApiRouter`** — A named group of routes with an optional URL `prefix`.
+
+### Service Interface
+
+`OpenApiService` is the abstract contract for API configuration access:
+
+- `get_routers()` — Retrieve all configured routers.
+- `get_route(route_id, router_name=None)` — Look up a single route.
+- `get_status_code(error_code)` — Map an error code to an HTTP status code.
+
+### Domain Events
+
+Three domain events encapsulate the service operations for use in the feature workflow:
+
+- **`GetRouters`** — Retrieves all routers via the injected `OpenApiService`.
+- **`GetRoute`** — Parses a dotted endpoint string (e.g., `calc.add`) and retrieves the matching route.
+- **`GetStatusCode`** — Looks up the HTTP status code for a given error code.
+
+### Mappers
+
+Aggregates and TransferObjects bridge YAML configuration and runtime domain objects:
+
+- **`ApiRouteAggregate`**, **`ApiRouterAggregate`** — Mutable aggregates with route management methods.
+- **`ApiRouteYamlObject`**, **`ApiRouterYamlObject`** — YAML serialization with `_ROLES`-based role control, `map()` for aggregate construction, `from_model()` for reverse mapping.
+
+### Repository
+
+`OpenApiYamlRepository` is the YAML-backed implementation of `OpenApiService`. It accepts a parameterized `root_key` (defaults to `"openapi"`) enabling compatibility with multiple YAML formats:
+
+- `root_key="openapi"` — unified `openapi.yml` format
+- `root_key="flask"` — legacy `flask.yml` format
+- `root_key="fast"` — legacy `fast.yml` format
+
+### Contexts
+
+- **`OpenApiContext(AppInterfaceContext)`** — Shared API context that receives `DomainEvent` instances for route and status code lookup. Provides `parse_request`, `handle_error` (with HTTP status code resolution), and `handle_response` (returning `(response, status_code)` tuples).
+- **`OpenApiRequestContext(RequestContext)`** — Pydantic-aware request context that serializes `BaseModel` results via `model_dump()`, with support for lists, dicts, `None`, and primitives.
+
+## YAML Configuration Format
+
+The repository reads configuration from a YAML file with the following structure:
+
+```yaml
+openapi:  # root_key (can be 'flask', 'fast', or any custom key)
+  routers:
+    calc:
+      prefix: /calc
+      routes:
+        add:
+          path: /add
+          methods:
+            - POST
+          status_code: 200
+        subtract:
+          path: /subtract
+          methods:
+            - POST
+          status_code: 200
+    health:
+      routes:
+        ping:
+          path: /ping
+          methods:
+            - GET
+          status_code: 200
+  errors:
+    INVALID_INPUT: 400
+    DIVISION_BY_ZERO: 422
+    NOT_FOUND: 404
+```
+
+## Usage
+
+Tiferet OpenAPI is consumed by framework-specific adapters. Here's how the shared components integrate:
+
+### In tiferet-flask / tiferet-fast
+
+Framework adapters extend `OpenApiContext` and use `OpenApiYamlRepository` as their configuration backend:
+
+```python
+# Framework adapter context (e.g., FlaskApiContext)
+from tiferet_openapi import OpenApiContext, OpenApiRequestContext
+
+class FlaskApiContext(OpenApiContext):
+    # Inherits parse_request, handle_error, handle_response
+    # Adds Flask-specific builder logic
+    pass
+```
+
+### Direct Repository Usage
+
+```python
+from tiferet_openapi import OpenApiYamlRepository
+
+# Load configuration
+repo = OpenApiYamlRepository(
+    openapi_yaml_file='app/configs/openapi.yml',
+    root_key='openapi',
+)
+
+# Retrieve all routers
+routers = repo.get_routers()
+for router in routers:
+    print(f"{router.name}: {router.prefix}")
+    for route in router.routes:
+        print(f"  {route.endpoint} -> {route.path} [{', '.join(route.methods)}]")
+
+# Look up a specific route
+route = repo.get_route('add', router_name='calc')
+print(f"Route: {route.endpoint}, Status: {route.status_code}")
+
+# Map error code to HTTP status
+status = repo.get_status_code('INVALID_INPUT')  # Returns 400
+status = repo.get_status_code('UNKNOWN')         # Returns 500 (default)
+```
+
+## Testing
+
+Run the test suite:
+
+```bash
+pytest tiferet_openapi/ -v
+```
+
+Tests are co-located in `<package>/tests/` directories:
+- **Domain/mapper tests** use direct Pydantic constructors.
+- **Event tests** use `DomainEvent.handle()` with mocked `OpenApiService`.
+- **Repo tests** are integration tests using `tmp_path` with real YAML files.
+- **Context tests** use `mock.Mock(spec=DomainEvent)` for event dependencies.
+
+## License
+
+MIT — see [LICENSE](LICENSE) for details.

tiferet_openapi-0.1.0/pyproject.toml

@@ -0,0 +1,43 @@
+[project]
+name = "tiferet-openapi"
+dynamic = ["version"]  # Mark version as dynamic
+description = "A shared OpenAPI abstraction layer for the Tiferet Framework."
+authors = [
+    { name = "Andrew Shatz, Great Strength Systems", email = "andrew@greatstrength.me" }
+]
+license = { text = "MIT" }
+readme = "README.md"
+requires-python = ">=3.10"
+dependencies = [
+    "tiferet>=2.0.0b1"
+]
+
+[project.urls]
+Homepage = "https://github.com/greatstrength/tiferet-openapi"
+Repository = "https://github.com/greatstrength/tiferet-openapi"
+Download = "https://github.com/greatstrength/tiferet-openapi"
+
+[project.optional-dependencies]
+test = [
+    "pytest>=8.3.3",
+    "pytest_env>=1.1.5"
+]
+
+[build-system]
+requires = ["setuptools>=61.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[tool.setuptools.packages.find]
+where = ["."]
+include = [
+    "tiferet_openapi",
+    "tiferet_openapi.contexts",
+    "tiferet_openapi.domain",
+    "tiferet_openapi.events",
+    "tiferet_openapi.interfaces",
+    "tiferet_openapi.mappers",
+    "tiferet_openapi.repos"
+]
+
+[tool.setuptools.dynamic]
+version = { attr = "tiferet_openapi.__version__" }

tiferet_openapi-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

tiferet_openapi-0.1.0/tiferet_openapi/__init__.py

@@ -0,0 +1,26 @@
+# *** exports
+
+# ** app
+# Export the main domain objects, interfaces, events, mappers, repos, and contexts.
+# Use a try-except block to avoid import errors on build systems.
+try:
+    from .domain import ApiRoute, ApiRouter
+    from .interfaces import OpenApiService
+    from .events import GetRouters, GetRoute, GetStatusCode
+    from .mappers import (
+        ApiRouteAggregate,
+        ApiRouterAggregate,
+        ApiRouteYamlObject,
+        ApiRouterYamlObject,
+    )
+    from .repos import OpenApiYamlRepository
+    from .contexts import OpenApiContext, OpenApiRequestContext
+except Exception as e:
+    import os, sys
+    # Only print warning if TIFERET_SILENT_IMPORTS is not set to a truthy value
+    if not os.getenv('TIFERET_SILENT_IMPORTS'):
+        print(f"Warning: Failed to import Tiferet OpenAPI modules: {e}", file=sys.stderr)
+    pass
+
+# *** version
+__version__ = "0.1.0"

tiferet_openapi-0.1.0/tiferet_openapi/contexts/__init__.py

@@ -0,0 +1,7 @@
+'''Tiferet OpenAPI Contexts'''
+
+# *** exports
+
+# ** app
+from .openapi import OpenApiContext
+from .request import OpenApiRequestContext

tiferet_openapi-0.1.0/tiferet_openapi/contexts/openapi.py

@@ -0,0 +1,140 @@
+'''Tiferet OpenAPI Context'''
+
+# *** imports
+
+# ** core
+from typing import Any, Callable
+
+# ** infra
+from tiferet import TiferetError
+from tiferet.assets.exceptions import TiferetAPIError
+from tiferet.contexts import (
+    AppInterfaceContext,
+    FeatureContext,
+    ErrorContext,
+    LoggingContext,
+)
+from tiferet.events import DomainEvent
+
+# ** app
+from .request import OpenApiRequestContext
+
+
+# *** contexts
+
+# ** context: open_api_context
+class OpenApiContext(AppInterfaceContext):
+    '''
+    A shared API context for managing OpenAPI interactions within the Tiferet framework.
+    '''
+
+    # * attribute: get_route_handler
+    get_route_handler: Callable
+
+    # * attribute: get_status_code_handler
+    get_status_code_handler: Callable
+
+    # * init
+    def __init__(self,
+            interface_id: str,
+            features: FeatureContext,
+            errors: ErrorContext,
+            logging: LoggingContext,
+            get_route_evt: DomainEvent,
+            get_status_code_evt: DomainEvent,
+        ):
+        '''
+        Initialize the OpenAPI context.
+
+        :param interface_id: The interface ID.
+        :type interface_id: str
+        :param features: The feature context.
+        :type features: FeatureContext
+        :param errors: The error context.
+        :type errors: ErrorContext
+        :param logging: The logging context.
+        :type logging: LoggingContext
+        :param get_route_evt: The domain event for retrieving a route.
+        :type get_route_evt: DomainEvent
+        :param get_status_code_evt: The domain event for retrieving a status code.
+        :type get_status_code_evt: DomainEvent
+        '''
+
+        # Call the parent constructor.
+        super().__init__(interface_id, features, errors, logging)
+
+        # Set the domain event handlers.
+        self.get_route_handler = get_route_evt.execute
+        self.get_status_code_handler = get_status_code_evt.execute
+
+    # * method: parse_request
+    def parse_request(self, headers: dict = {}, data: dict = {}, feature_id: str = None, **kwargs) -> OpenApiRequestContext:
+        '''
+        Parse the incoming request and return an OpenApiRequestContext instance.
+
+        :param headers: The request headers.
+        :type headers: dict
+        :param data: The request data.
+        :type data: dict
+        :param feature_id: The feature ID.
+        :type feature_id: str
+        :param kwargs: Additional keyword arguments.
+        :type kwargs: dict
+        :return: An OpenApiRequestContext instance.
+        :rtype: OpenApiRequestContext
+        '''
+
+        # Return an OpenApiRequestContext instance.
+        return OpenApiRequestContext(
+            headers=headers,
+            data=data,
+            feature_id=feature_id,
+        )
+
+    # * method: handle_error
+    def handle_error(self, error: Exception, **kwargs) -> Any:
+        '''
+        Handle the error and raise TiferetAPIError with status_code.
+
+        :param error: The error to handle.
+        :type error: Exception
+        :param kwargs: Additional keyword arguments.
+        :type kwargs: dict
+        :return: The error response.
+        :rtype: Any
+        '''
+
+        # Get the status code via event if it's a TiferetError.
+        if isinstance(error, TiferetError):
+            status_code = self.get_status_code_handler(error_code=error.error_code)
+        else:
+            status_code = 500
+
+        # Delegate formatting to parent (which raises TiferetAPIError).
+        try:
+            return super().handle_error(error, **kwargs)
+        except TiferetAPIError as api_error:
+            api_error.status_code = status_code
+            raise
+
+    # * method: handle_response
+    def handle_response(self, request: OpenApiRequestContext, **kwargs) -> Any:
+        '''
+        Handle the response from the request context.
+
+        :param request: The request context.
+        :type request: OpenApiRequestContext
+        :param kwargs: Additional keyword arguments.
+        :type kwargs: dict
+        :return: The response and status code.
+        :rtype: Any
+        '''
+
+        # Handle the response from the request context.
+        response = super().handle_response(request, **kwargs)
+
+        # Retrieve the route by the request feature id.
+        route = self.get_route_handler(endpoint=request.feature_id)
+
+        # Return the result with the specified status code.
+        return response, route.status_code if route else 200

tiferet_openapi-0.1.0/tiferet_openapi/contexts/request.py

@@ -0,0 +1,72 @@
+'''Tiferet OpenAPI Request Context'''
+
+# *** imports
+
+# ** core
+from typing import Any
+
+# ** infra
+from pydantic import BaseModel
+from tiferet.contexts.request import RequestContext
+
+
+# *** contexts
+
+# ** context: open_api_request_context
+class OpenApiRequestContext(RequestContext):
+    '''
+    A context for handling OpenAPI request data and responses with Pydantic model serialization.
+    '''
+
+    # * method: handle_response
+    def handle_response(self) -> Any:
+        '''
+        Handle the response for the OpenAPI request context.
+
+        :return: The response.
+        :rtype: Any
+        '''
+
+        # Set the result using the set_result method to ensure proper formatting.
+        self.set_result(self.result)
+
+        # Handle the response using the parent method.
+        return super().handle_response()
+
+    # * method: set_result
+    def set_result(self, result: Any, data_key: str = None):
+        '''
+        Set the result of the request context.
+
+        :param result: The result to set.
+        :type result: Any
+        :param data_key: The key in the request data to set the result to.
+            If provided, the raw result is stored for downstream commands.
+            If None, the result is serialized for the final response.
+        :type data_key: str
+        '''
+
+        # If a data key is provided, delegate to the parent to store the raw result.
+        if data_key:
+            super().set_result(result, data_key=data_key)
+            return
+
+        # If the response is None, return an empty response.
+        if result is None:
+            self.result = ''
+
+        # Convert the response to a dictionary if it's a BaseModel.
+        elif isinstance(result, BaseModel):
+            self.result = result.model_dump()
+
+        # If the response is a list containing BaseModel instances, convert each to a dictionary.
+        elif isinstance(result, list) and all(isinstance(item, BaseModel) for item in result):
+            self.result = [item.model_dump() for item in result]
+
+        # If the response is a dict containing BaseModel instances, convert each to a dictionary.
+        elif isinstance(result, dict) and all(isinstance(value, BaseModel) for value in result.values()):
+            self.result = {key: value.model_dump() for key, value in result.items()}
+
+        # Otherwise, set the result directly.
+        else:
+            self.result = result