ul-api-utils 7.5.1__py3-none-any.whl → 7.7.0__py3-none-any.whl

example/conf.py

@@ -9,6 +9,8 @@ from example.permissions import permissions
 sdk = ApiSdk(ApiSdkConfig(
     service_name='example_service',
     permissions=permissions,
+    cache_storage_uri='redis://localhost:16379',
+    cache_default_ttl=60,
     rate_limit_storage_uri='redis://localhost:16379',
     rate_limit_identify=ApiSdkIdentifyTypeEnum.JWT_USER_ID,
     flask_debugging_plugins=ApiSdkFlaskDebuggingPluginsEnabled(

example/routes/api_some.py

@@ -1,12 +1,14 @@
-from datetime import datetime, timedelta
 from time import sleep
+from datetime import datetime, timedelta
 from typing import List, Optional, Tuple
 
-from ul_db_utils.modules.db import db
 from flask import jsonify
 from pydantic import BaseModel
-
+from ul_db_utils.modules.db import db
 from werkzeug import Response as BaseResponse
+
+from example.conf import sdk
+from example.permissions import SOME_PERMISSION, SOME_PERMISSION2
 from ul_api_utils.api_resource.api_request import ApiRequestQuery
 from ul_api_utils.api_resource.api_resource import ApiResource
 from ul_api_utils.api_resource.api_resource_config import ApiResourceConfig
@@ -16,8 +18,6 @@ from ul_api_utils.internal_api.internal_api import InternalApi
 from ul_api_utils.utils.api_encoding import ApiEncoding
 from ul_api_utils.resources.health_check.health_check import HealthCheckContext
 from ul_api_utils.validators.custom_fields import QueryParamsSeparatedList
-from example.conf import sdk
-from example.permissions import SOME_PERMISSION, SOME_PERMISSION2
 
 internal_api = InternalApi(
     entry_point='http://localhost:5000',
@@ -47,10 +47,11 @@ class SomeBody(BaseModel):
 
 class Some2Query(ApiRequestQuery):
     sleep: float = 0.4
-    some: QueryParamsSeparatedList[str]
+    some: QueryParamsSeparatedList[str] = ''        # type: ignore
 
 
 @sdk.rest_api('POST', '/example-resource-simple', access=sdk.ACCESS_PUBLIC)
+@sdk.cache_api('REFRESH', 'example')
 def some5(api_resource: ApiResource, body: SomeBody) -> JsonApiResponse[List[RespObject]]:
     return api_resource.response_ok([
         RespObject(now=datetime.now() + timedelta(seconds=body.seconds)),
@@ -62,6 +63,7 @@ class Some7Query(ApiRequestQuery):
     need_redirect: int
 
 
+@sdk.cache_api('READ', 'example')
 @sdk.rest_api('POST', '/example-resource-simple-any', access=sdk.ACCESS_PUBLIC)
 def some9(api_resource: ApiResource) -> AnyJsonApiResponse:
     return api_resource.response_ok([RespObject(now=datetime.now(), notes="some9")], 1)
@@ -91,7 +93,7 @@ def some7(api_resource: ApiResource, query: Some7Query) -> JsonApiResponse[List[
 
 @sdk.rest_api('GET', '/example-resource-simple-proxy', access=sdk.ACCESS_PUBLIC)
 def some6(api_resource: ApiResource) -> ProxyJsonApiResponse[List[RespObject]]:  # type: ignore
-    res = internal_api.request_post('/example-resource-simple', json={'seconds': 123}).typed(List[RespObject]).check()
+    res = internal_api.request_post('/example-resource-simple-any', json={'seconds': 123}).typed(List[RespObject]).check()
     assert res.payload[0].now is not None
 
     return api_resource.response_proxy(res)
@@ -151,6 +153,7 @@ def health_check(context: HealthCheckContext) -> None:
 
 
 @sdk.rest_api('GET', '/example-resource', access=sdk.ACCESS_PUBLIC)
+@sdk.cache_api('READ', ('example', 'resource', 'simple'))
 def some3(api_resource: ApiResource) -> JsonApiResponse[RespObject]:
     api_resource.logger.info('some 1')
     sleep(0.1)
@@ -182,6 +185,7 @@ def some2html(api_resource: ApiResource, query: Some2Query) -> HtmlApiResponse:
 
 
 @sdk.rest_api('GET', '/example-resource-for-loong-sleep', access=sdk.ACCESS_PUBLIC)
+@sdk.cache_api('READ', ('example', 'resource', 'simple'))
 def some2(api_resource: ApiResource, query: Some2Query) -> JsonApiResponse[RespObject]:
     sess = db.session()
     sess.execute('SELECT * FROM information_schema.tables LIMIT 3;')
@@ -191,6 +195,7 @@ def some2(api_resource: ApiResource, query: Some2Query) -> JsonApiResponse[RespO
 
 
 @sdk.rest_api('GET', '/example-resource-empty', access=sdk.ACCESS_PUBLIC)
+@sdk.cache_api('READ', ('example', 'resource'))
 def some1(api_resource: ApiResource) -> JsonApiResponse[RespObject]:
     return api_resource.response_ok(RespObject(now=datetime.now()))
 
@@ -213,6 +218,7 @@ def some12(api_resource: ApiResource, body: List[SomeBody]) -> JsonApiResponse[R
 
 
 @sdk.html_view(('GET', 'POST'), '/', access=sdk.ACCESS_PUBLIC)
+@sdk.cache_api('READ', 'some')
 def view_home(api_resource: ApiResource, body: Optional[List[SomeBody]]) -> HtmlApiResponse:
     sleep(0.02)
     sess = db.session()

ul_api_utils/const.py

@@ -41,10 +41,10 @@ MIME__MSGPCK = 'application/x-msgpack'
 
 ENCODING_MIME__GZIP = 'gzip'
 
-
 REQUEST_METHOD__PUT = 'PUT'
 REQUEST_METHOD__GET = 'GET'
 REQUEST_METHOD__POST = 'POST'
+REQUEST_METHOD__QUERY = 'QUERY'
 REQUEST_METHOD__PATCH = 'PATCH'
 REQUEST_METHOD__DELETE = 'DELETE'
 REQUEST_METHOD__OPTIONS = 'OPTIONS'

ul_api_utils/modules/api_sdk.py

@@ -11,6 +11,7 @@ from typing import List, Union, Callable, Tuple, Any, Optional, TypeVar, cast, S
 
 from flask import Response, request, Flask, url_for as flask_url_for, _app_ctx_stack
 from pydantic import BaseModel
+from redis.connection import parse_url
 from ul_py_tool.utils.arg_files_glob import arg_files_print
 from werkzeug import Response as BaseResponse
 
@@ -29,6 +30,7 @@ from ul_api_utils.errors import UserAbstractApiError, ResourceRuntimeApiError, R
 from ul_api_utils.internal_api.internal_api_check_context import internal_api_check_context
 from ul_api_utils.modules.api_sdk_config import ApiSdkConfig
 from ul_api_utils.modules.intermediate_state import try_init, try_configure
+from ul_api_utils.resources.caching import ULCache, TCacheMode, ULCacheMode, ULCacheConfig
 from ul_api_utils.resources.debugger_scripts import load_debugger_static_scripts
 from ul_api_utils.resources.health_check.health_check import HealthCheckContext
 from ul_api_utils.resources.health_check.resource import init_health_check_resource
@@ -50,7 +52,9 @@ from ul_api_utils.utils.uuid_converter import UUID4Converter
 
 if TYPE_CHECKING:
     import flask_sqlalchemy
+    from flask_pymongo import PyMongo       # type: ignore # lib without mypy stubs
     from ul_db_utils.modules.db import DbConfig
+    from ul_db_utils.modules.mongo_db_modules.db import MongoDbConfig
 
 TFn = TypeVar("TFn", bound=Callable[..., ApiResponse])
 
@@ -103,6 +107,7 @@ class ApiSdk:
         '_fn_registry',
         '_flask_app_cache',
         '_limiter_enabled',
+        '_cache',
         '_db',
     )
 
@@ -115,22 +120,30 @@ class ApiSdk:
         self._initialized_flask_name: Optional[str] = None
         self._flask_app_cache: Optional[Flask] = None
         self._limiter_enabled = False
+        self._cache = None
 
         self._templates_dir = os.path.join(APPLICATION_DIR, 'templates')
 
         self._fn_registry: List[ApiSdkResource] = []
-        self._db: Optional['flask_sqlalchemy.SQLAlchemy'] = None
+        self._db: Optional['flask_sqlalchemy.SQLAlchemy'] | Optional['PyMongo'] = None
 
     @property
     def config(self) -> ApiSdkConfig:
         return self._config
 
-    def init_with_flask(self, app_name: str, *, db_config: Optional['DbConfig'] = None) -> Flask:
+    def init_with_flask(self, app_name: str, *, db_config: Optional['MongoDbConfig'] | Optional['DbConfig'] = None) -> Flask:
         self._initialized_flask_name = try_init(self, app_name)
 
-        if db_config is not None:
+        if db_config is not None and type(db_config).__name__ == 'MongoDbConfig':
+            from ul_db_utils.utils.waiting_for_mongo import waiting_for_mongo
+            from ul_db_utils.modules.mongo_db_modules.db import db
+            db_config._init_from_sdk_with_flask(self)
+            waiting_for_mongo(db_config.uri)
+            self._db = db
+
+        if db_config is not None and type(db_config).__name__ == 'DbConfig':
             from ul_db_utils.utils.waiting_for_postgres import waiting_for_postgres
-            from ul_db_utils.modules.db import db
+            from ul_db_utils.modules.db import db       # type: ignore # yes, db already defined, but can not use two conigs
             db_config._init_from_sdk_with_flask(self)
             waiting_for_postgres(db_config.uri)
             self._db = db
@@ -143,6 +156,26 @@ class ApiSdk:
             rate_limit=self._config.rate_limit,
             storage_uri=self._config.rate_limit_storage_uri,
         )
+        if self._config.cache_storage_uri:
+            cache_config: ULCacheConfig = {
+                'CACHE_TYPE': "RedisCache",
+                'CACHE_REDIS_HOST': '',
+                'CACHE_REDIS_PORT': '',
+                'CACHE_REDIS_PASSWORD': '',
+                'CACHE_DEFAULT_TIMEOUT': self._config.cache_default_ttl,
+                'CACHE_KEY_PREFIX': f'CACHE__{self._config.service_name}',
+                'CACHE_SOURCE_CHECK': True,
+            }
+            try:
+                redis_url = parse_url(self._config.cache_storage_uri)
+            except ValueError as e:
+                logger.error(f'broken redis uri :: {e}')
+            else:
+                assert all(('host' in redis_url, 'port' in redis_url)), 'missing part of redis uri'
+                cache_config['CACHE_REDIS_HOST'] = redis_url['host']
+                cache_config['CACHE_REDIS_PORT'] = redis_url['port']
+                cache_config['CACHE_REDIS_PASSWORD'] = redis_url.get('password', '')
+            self._cache = ULCache(self._flask_app, config=cache_config)     # type: ignore
 
         route_files, ignored_route_files = load_modules_by_template([
             os.path.join(APPLICATION_DIR, 'routes', 'api_*.py'),
@@ -206,7 +239,7 @@ class ApiSdk:
 
         flask_app.before_request(self._before_request)
         flask_app.after_request(self._after_request)
-        flask_app.teardown_request(self._teardown)
+        flask_app.teardown_request(self._teardown_request)
 
         flask_app.errorhandler(404)(functools.partial(
             not_implemented_handler,
@@ -217,7 +250,11 @@ class ApiSdk:
         return flask_app
 
     @property
-    def db(self) -> Optional['flask_sqlalchemy.SQLAlchemy']:
+    def ul_cache_factory(self) -> Optional['ULCache']:
+        return self._cache
+
+    @property
+    def db(self) -> Optional['flask_sqlalchemy.SQLAlchemy'] | Optional['PyMongo']:
         return self._db
 
     def _before_request(self) -> None:
@@ -238,7 +275,7 @@ class ApiSdk:
     def _debugger_enabled_with_pin(self) -> bool:
         return request.headers.get(REQUEST_HEADER__DEBUGGER) == APPLICATION_DEBUGGER_PIN or request.cookies.get(REQUEST_HEADER__DEBUGGER, "") == APPLICATION_DEBUGGER_PIN
 
-    def _teardown(self, err: Optional[BaseException]) -> None:
+    def _teardown_request(self, err: Optional[BaseException]) -> None:
         clean_files()
 
     def _debug_internal_request(self) -> bool:
@@ -276,6 +313,18 @@ class ApiSdk:
     def health_check(self) -> Callable[[Callable[[HealthCheckContext], None]], None]:
         return functools.partial(init_health_check_resource, api_sdk=self)
 
+    def cache_api(
+        self,
+        mode: TCacheMode,
+        tags: Tuple[str, ...] | str,
+        timeout: Optional[int] = None,
+        source_check: Optional[bool] = True,
+    ) -> Callable[[TFn], TFn]:
+        assert self.ul_cache_factory is not None, 'cache not configured !'
+        if ULCacheMode.compile_mode(mode) == ULCacheMode.READ.value:
+            return self.ul_cache_factory.cache_read_wrap(tags, timeout, source_check)
+        return self.ul_cache_factory.cache_refresh_wrap(tags)
+
     def rest_api(
         self,
         method: TMethodShort,
@@ -427,6 +476,7 @@ class ApiSdk:
                     res = api_resource_config.override_flask_response(res)
 
                 ri = api_resource.request_info
+                # TODO: add cache hit flag
                 logger.info('AUDIT ' + json.dumps({
                     'user_id': str(scope_user_id) if scope_user_id else None,
                     'token_id': str(scope_token_id) if scope_token_id else None,

ul_api_utils/modules/api_sdk_config.py

@@ -48,6 +48,9 @@ class ApiSdkConfig(BaseModel):
     rate_limit_storage_uri: str = ''  # supports url of redis, memcached, mongodb
     rate_limit_identify: Union[ApiSdkIdentifyTypeEnum, Callable[[], str]] = ApiSdkIdentifyTypeEnum.DISABLED  # must be None if disabled
 
+    cache_storage_uri: str = ''  # supports only redis
+    cache_default_ttl: int = 60  # seconds
+
     flask_debugging_plugins: Optional[ApiSdkFlaskDebuggingPluginsEnabled] = None
 
     api_route_path_prefix: str = '/api'

ul_api_utils/resources/caching.py

@@ -0,0 +1,187 @@
+import functools
+import hashlib
+import inspect
+import itertools
+import logging
+from _hashlib import HASH   # type: ignore
+from collections import defaultdict
+from enum import Enum
+from typing import Optional, Callable, Dict, Tuple, List, Union, Literal, cast, TypeVar, Any, Set, TypedDict
+
+import ormsgpack
+from pydantic import ValidationError
+from werkzeug import Response as BaseResponse
+
+from flask import request
+from flask_caching import Cache, CachedResponse
+
+from ul_api_utils.api_resource.api_response import ApiResponse, JsonApiResponse
+from ul_api_utils.conf import APPLICATION_DEBUG
+from ul_api_utils.utils.constants import TKwargs
+from ul_api_utils.utils.json_encoder import CustomJSONEncoder
+
+TCacheModeStr = Union[Literal['READ'], Literal['REFRESH']]
+TFn = TypeVar("TFn", bound=Callable[..., ApiResponse])
+
+
+class ULCacheMode(Enum):
+    READ = 'READ'
+    REFRESH = 'REFRESH'
+
+    @staticmethod
+    def compile_mode(mode: Union[TCacheModeStr, 'ULCacheMode']) -> str:
+        if isinstance(mode, ULCacheMode):
+            return mode.value
+        assert isinstance(mode, str)
+        m = mode.strip().upper()
+        return ULCacheMode(m).value
+
+
+TCacheMode = Union[TCacheModeStr, 'ULCacheMode']
+
+
+class ULCacheConfig(TypedDict):     # https://flask-caching.readthedocs.io/en/latest/#configuring-flask-caching
+    CACHE_TYPE: str
+    CACHE_REDIS_HOST: str
+    CACHE_REDIS_PORT: str
+    CACHE_REDIS_PASSWORD: str
+    CACHE_KEY_PREFIX: str
+    CACHE_DEFAULT_TIMEOUT: int
+    CACHE_SOURCE_CHECK: bool
+
+
+class ULCache(Cache):
+
+    @property
+    def tags_map(self) -> Dict[Tuple[str, ...], Set[str]]:
+        if self.cache.has(':tags_map'):
+            return self.cache.get(':tags_map')
+        else:
+            return defaultdict(set)
+
+    @tags_map.setter
+    def tags_map(self, value: Dict[Tuple[str], Set[str]]) -> None:
+        self.cache.set(':tags_map', value, -1)
+
+    @staticmethod
+    def _has_common_elements(seq: Set[Tuple[str, ...]]) -> bool:
+        return bool(functools.reduce(set.intersection, map(set, seq)))      # type: ignore
+
+    @staticmethod
+    def _format_cache_key(parts: List[Any]) -> str:
+        return ':' + ':'.join([p for p in parts if p])
+
+    def make_cache_key(
+        self,
+        fn: TFn,
+        source_check: bool,
+        hash_method: Callable[[bytes], HASH],
+    ) -> str:
+        cache_key_parts = [request.path]
+        cache_hash = None
+        if request.args:
+            args_as_sorted_tuple = tuple(sorted(pair for pair in request.args.items(multi=True)))
+
+            args_as_bytes = str(args_as_sorted_tuple).encode()
+            cache_hash = hash_method(args_as_bytes)
+
+        # Use the source code if source_check is True and update the
+        # cache_hash before generating the hashing and using it in cache_key
+        if source_check and callable(fn):
+            func_source_code = inspect.getsource(fn)
+            if cache_hash is not None:
+                cache_hash.update(func_source_code.encode("utf-8"))
+            else:
+                cache_hash = hash_method(func_source_code.encode("utf-8"))
+        cache_hash = str(cache_hash.hexdigest()) if cache_hash is not None else ''
+        cache_key_parts.append(cache_hash)
+
+        return self._format_cache_key(cache_key_parts)
+
+    def cache_refresh_wrap(
+        self,
+        tags: Tuple[str, ...] | str,
+    ) -> Callable[[TFn], TFn]:
+        def wrap(fn: TFn) -> TFn:
+            assert fn.__module__, 'empty __module__ of function'
+            func_tags = tags if isinstance(tags, tuple) else (tags,)
+
+            @functools.wraps(fn)
+            def wrapper(*args: Any, **kwargs: TKwargs) -> Tuple[BaseResponse, int]:
+                dependent_keys = []
+                tags_map = self.tags_map.copy()
+
+                for t in tags_map.keys():
+                    stored_tags = t if isinstance(t, tuple) else (t,)
+                    if self._has_common_elements({stored_tags, func_tags}):
+                        dependent_keys.append(tags_map[stored_tags].copy())
+                        tags_map[stored_tags] = set()
+                cache_list_to_reset: List[str] = list(itertools.chain.from_iterable(dependent_keys))
+                self.delete_many(*cache_list_to_reset)
+                tags_map[func_tags] = set()
+                self.tags_map = tags_map
+                return self._call_fn(fn, *args, **kwargs)
+
+            return cast(TFn, wrapper)
+        return wrap
+
+    def cache_read_wrap(
+        self,
+        tags: Tuple[str, ...] | str,
+        timeout: Optional[int] = None,
+        source_check: Optional[bool] = None,
+        hash_method: Callable[[bytes], HASH] = hashlib.md5,
+    ) -> Callable[[TFn], TFn]:
+        def cache_wrap(fn: TFn) -> TFn:
+            assert fn.__module__, 'empty __module__ of function'
+
+            nonlocal source_check
+            if source_check is None:
+                source_check = self.source_check or False
+
+            func_tags = tags if isinstance(tags, tuple) else (tags,)
+            if self.tags_map.get(func_tags) is None:
+                self.tags_map[func_tags] = set()
+
+            logger = logging.getLogger(fn.__module__)
+
+            @functools.wraps(fn)
+            def cache_wrapper(*args: Any, **kwargs: TKwargs) -> Tuple[BaseResponse | CachedResponse, int]:
+                try:
+                    assert source_check is not None  # just for mypy
+                    cache_key = self.make_cache_key(fn, source_check, hash_method)
+                    if resp := self.cache.get(cache_key):
+                        try:
+                            resp = JsonApiResponse(**ormsgpack.unpackb(resp))
+                        except ValidationError:
+                            logger.error(f'cache read error of {fn.__name__} :: response not type of {JsonApiResponse.__name__}')
+                            raise
+
+                    found = True
+                    # If the value returned by cache.get() is None
+                    # it might be because the key is not found in the cache
+                    # or because the cached value is actually None
+                    if resp is None:
+                        found = self.cache.has(cache_key)
+                except Exception as e:  # noqa: B902 # cuz lot of variations of cache factory impementaions
+                    logger.error(f'error due cache check :: {e}')
+                    return self._call_fn(fn, *args, **kwargs)
+                if not found:
+                    tags_map = self.tags_map.copy()
+                    tags_map[func_tags].add(cache_key)
+                    resp = self._call_fn(fn, *args, **kwargs)
+                    try:
+                        self.cache.set(
+                            key=cache_key,
+                            value=ormsgpack.packb(resp, default=CustomJSONEncoder().default),
+                            timeout=timeout,
+                        )
+                    except Exception as e:  # noqa: B902 # cuz lot of variations of cache factory impementaions
+                        if APPLICATION_DEBUG:
+                            raise
+                        logger.error(f'exception possibly due to cache response :: {e}')
+                    self.tags_map = self.tags_map | tags_map
+                return resp
+
+            return cast(TFn, cache_wrapper)
+        return cache_wrap

ul_api_utils/utils/api_method.py

@@ -1,7 +1,8 @@
 from enum import Enum, unique
 from typing import Union, List, Tuple, Any, Literal
 
-from ul_api_utils.const import REQUEST_METHOD__PUT, REQUEST_METHOD__GET, REQUEST_METHOD__POST, REQUEST_METHOD__PATCH, REQUEST_METHOD__DELETE, REQUEST_METHOD__OPTIONS
+from ul_api_utils.const import REQUEST_METHOD__PUT, REQUEST_METHOD__GET, REQUEST_METHOD__POST, \
+    REQUEST_METHOD__PATCH, REQUEST_METHOD__DELETE, REQUEST_METHOD__OPTIONS, REQUEST_METHOD__QUERY
 
 TMethodStr = Union[Literal['GET'], Literal['POST'], Literal['PUT'], Literal['PATCH'], Literal['DELETE'], Literal['OPTIONS']]
 TMethod = Union[TMethodStr, 'ApiMethod', List[TMethodStr], Tuple[TMethodStr, ...], List['ApiMethod'], Tuple['ApiMethod', ...]]
@@ -13,6 +14,7 @@ class ApiMethod(Enum):
     PUT = REQUEST_METHOD__PUT
     GET = REQUEST_METHOD__GET
     POST = REQUEST_METHOD__POST
+    QUERY = REQUEST_METHOD__QUERY
     PATCH = REQUEST_METHOD__PATCH
     DELETE = REQUEST_METHOD__DELETE
     OPTIONS = REQUEST_METHOD__OPTIONS

{ul_api_utils-7.5.1.dist-info → ul_api_utils-7.7.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: ul-api-utils
-Version: 7.5.1
+Version: 7.7.0
 Summary: Python api utils
 Author: Unic-lab
 Author-email: 
@@ -23,6 +23,7 @@ Requires-Dist: jinja2 (==3.1.2)
 Requires-Dist: flask (==2.1.3)
 Requires-Dist: flask-wtf (==1.0.1)
 Requires-Dist: flask-limiter (==2.5.1)
+Requires-Dist: flask-caching (==2.1.0)
 Requires-Dist: flask-swagger-ui (==4.11.1)
 Requires-Dist: flask-monitoringdashboard (==3.1.2)
 Requires-Dist: pycryptodome (==3.15.0)
@@ -32,6 +33,7 @@ Requires-Dist: pyyaml (==6.0)
 Requires-Dist: requests (==2.28.1)
 Requires-Dist: cryptography (==38.0.1)
 Requires-Dist: colored (==1.4.3)
+Requires-Dist: ormsgpack (==1.4.1)
 Requires-Dist: msgpack (==1.0.4)
 Requires-Dist: msgpack-types (==0.2.0)
 Requires-Dist: fastavro (==1.7.0)

{ul_api_utils-7.5.1.dist-info → ul_api_utils-7.7.0.dist-info}/RECORD

@@ -1,17 +1,17 @@
 example/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-example/conf.py,sha256=Be8GhNk3jj5mRGQp4XscwOQx-8moZqt_JVvNGkZCj1k,769
+example/conf.py,sha256=WPMSjEdxkxp7Vnwc-zBJrX3dE2KfbSMegsIiHktbY-M,844
 example/main.py,sha256=uTHooRO8ovcQkS3ejR_T5eVB7hQhUCwAjCxqbcn9a9k,405
 example/permissions.py,sha256=i8_zOOPdra3oMXZfyTspewRYNdn21PCqOD1ATG69Itk,277
 example/pure_flask_example.py,sha256=A7cbcjTr28FS1sVNAsQbj1N9EgEFIXDB4aRwOV6_tbU,1329
 example/rate_limit_load.py,sha256=U2Bgp8UztT4TNKdv9NVioxWfE68aCsC7uKz7xPCy6XM,225
 example/models/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 example/routes/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-example/routes/api_some.py,sha256=uRY79chGIQRUSpStCmr_-drvMLd4P3EQANsATYGBEQM,11562
+example/routes/api_some.py,sha256=omsHmHyzT_DfYqzZRakmyI7uDldn2S6Nrjqdv8te_Rk,11859
 example/workers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 example/workers/worker.py,sha256=flMYq50OhLtNSaA2qyDJSMeXSNXIqhdBIsaxcmO5-xQ,681
 ul_api_utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 ul_api_utils/conf.py,sha256=JfT8g2MlxDR2iTkvlW13o7-2NZJORsG1MYx86OjOzPQ,3232
-ul_api_utils/const.py,sha256=vtJNAldaB6WdhW_Klq83SEsrl50_HDZYtD_X3lMUXdM,2532
+ul_api_utils/const.py,sha256=pzY-zRznCJjZ0mFlte6XEsQQCU7EydN2WweEsVHSE7k,2563
 ul_api_utils/errors.py,sha256=kmmgNXJtgVczOskVG8Ye1WSHbqSSAWC2OzUjPUGCkGo,8137
 ul_api_utils/main.py,sha256=-32Qbz3ZeDUg7P2Xu67OIjIDUddPoHH6ibIa11xPl_k,779
 ul_api_utils/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -55,8 +55,8 @@ ul_api_utils/internal_api/__tests__/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQ
 ul_api_utils/internal_api/__tests__/internal_api.py,sha256=X2iopeso6vryszeeA__lcqXQVtz3Nwt3ngH7M4OuN1U,1116
 ul_api_utils/internal_api/__tests__/internal_api_content_type.py,sha256=mfiYPkzKtfZKFpi4RSnWAoCd6mRijr6sFsa2TF-s5t8,749
 ul_api_utils/modules/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-ul_api_utils/modules/api_sdk.py,sha256=B3uP23hRAhsXwbQAzgiL52NbMVpg9MqwNz0NUThr2vQ,22454
-ul_api_utils/modules/api_sdk_config.py,sha256=SwaVA67kxE95v9IXY6OEAzhSJdmnq4KzZQWkMo2sYhw,1943
+ul_api_utils/modules/api_sdk.py,sha256=xnU4qN16uJ5rbKYTbfT7gfQ0S9-P0P2mTCcRlmeoFo4,25059
+ul_api_utils/modules/api_sdk_config.py,sha256=cKQhIuEaLp4o9UVA4fmnR4QuEZPO9pqEjs_Xqgk8Mlw,2042
 ul_api_utils/modules/api_sdk_jwt.py,sha256=2XRfb0LxHUnldSL67S60v1uyoDpVPNaq4zofUtkeg88,15112
 ul_api_utils/modules/intermediate_state.py,sha256=7ZZ3Sypbb8LaSfrVhaXaWRDnj8oyy26NUbmFK7vr-y4,1270
 ul_api_utils/modules/worker_context.py,sha256=jGjopeuYuTtIDmsrqK7TcbTD-E81t8OWvWS1JpTC6b0,802
@@ -65,6 +65,7 @@ ul_api_utils/modules/worker_sdk_config.py,sha256=GL64FYYFZHBqqux_cygkSlJL-i6GgO2
 ul_api_utils/modules/__tests__/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 ul_api_utils/modules/__tests__/test_api_sdk_jwt.py,sha256=9JJTtva2z4pjvTWQqo_0EOvzf4wBgvq0G77jM0SC3Bg,10719
 ul_api_utils/resources/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+ul_api_utils/resources/caching.py,sha256=FBxcRa0KZBGoq-IIBgYZTlTPXMXAaQavqO9Q31BIQIQ,7308
 ul_api_utils/resources/debugger_scripts.py,sha256=FnZ9UfAzi7WokEi6bRkrUAEH8lbR3oo1eWr2BXZO4Pc,5077
 ul_api_utils/resources/not_implemented.py,sha256=OQE5LGA4KqZDwP5Wtub3Aw-icwzbqCSKcEFoFp4w7_k,973
 ul_api_utils/resources/permissions.py,sha256=8c8cEPkm69zxgXbDiwUkW6Mi_496-MZXbPOxHITetKs,1436
@@ -78,7 +79,7 @@ ul_api_utils/resources/health_check/resource.py,sha256=SPd9kMzBOVhFZgMVfV26bDpZy
 ul_api_utils/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 ul_api_utils/utils/api_encoding.py,sha256=dqXknOKgc3HBOk48zDoVOLLwc1vRFATkBY8JW_RVLCo,1450
 ul_api_utils/utils/api_format.py,sha256=wGuk5QP6b7oyl9SJ1ebNVirzCipmyTxqjoEPh2cJzAY,2025
-ul_api_utils/utils/api_method.py,sha256=CsR8QmQ9LIsFzdq6JY7TNIFlhjxOE2jLY-oyerbNIwo,1957
+ul_api_utils/utils/api_method.py,sha256=fGFlvS_S65CLTbjW4qvWlwi_woAUzPBQzEMkFJ9-K34,2020
 ul_api_utils/utils/api_pagination.py,sha256=dXCrDcZ3dNu3gKP2XExp7EUoOKaOgzO-6JOdKcFDylU,1827
 ul_api_utils/utils/api_path_version.py,sha256=gOwe0bcKs9ovwgh0XsSzih5rq5coL9rNZy8iyeB-xJc,1965
 ul_api_utils/utils/api_request_info.py,sha256=vxfqs_6-HSd-0o_k8e9KFKWhLNXL0KUHvGB0_9g9bgE,100
@@ -124,9 +125,9 @@ ul_api_utils/validators/validate_empty_object.py,sha256=3Ck_iwyJE_M5e7l6s1i88aqb
 ul_api_utils/validators/validate_uuid.py,sha256=EfvlRirv2EW0Z6w3s8E8rUa9GaI8qXZkBWhnPs8NFrA,257
 ul_api_utils/validators/__tests__/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 ul_api_utils/validators/__tests__/test_custom_fields.py,sha256=QLZ7DFta01Z7DOK9Z5Iq4uf_CmvDkVReis-GAl_QN48,1447
-ul_api_utils-7.5.1.dist-info/LICENSE,sha256=6Qo8OdcqI8aGrswJKJYhST-bYqxVQBQ3ujKdTSdq-80,1062
-ul_api_utils-7.5.1.dist-info/METADATA,sha256=gd8zAplZsQ9cBv4zcN9lmkDs2eDCkW3gsyvY7yiz6Ac,14380
-ul_api_utils-7.5.1.dist-info/WHEEL,sha256=G16H4A3IeoQmnOrYV4ueZGKSjhipXx8zc8nu9FGlvMA,92
-ul_api_utils-7.5.1.dist-info/entry_points.txt,sha256=8tL3ySHWTyJMuV1hx1fHfN8zumDVOCOm63w3StphkXg,53
-ul_api_utils-7.5.1.dist-info/top_level.txt,sha256=1XsW8iOSFaH4LOzDcnNyxHpHrbKU3fSn-aIAxe04jmw,21
-ul_api_utils-7.5.1.dist-info/RECORD,,
+ul_api_utils-7.7.0.dist-info/LICENSE,sha256=6Qo8OdcqI8aGrswJKJYhST-bYqxVQBQ3ujKdTSdq-80,1062
+ul_api_utils-7.7.0.dist-info/METADATA,sha256=3a01IY_kSPT6jR0YTy9WF1OPtIyss5qdCmTjgAPnckU,14454
+ul_api_utils-7.7.0.dist-info/WHEEL,sha256=G16H4A3IeoQmnOrYV4ueZGKSjhipXx8zc8nu9FGlvMA,92
+ul_api_utils-7.7.0.dist-info/entry_points.txt,sha256=8tL3ySHWTyJMuV1hx1fHfN8zumDVOCOm63w3StphkXg,53
+ul_api_utils-7.7.0.dist-info/top_level.txt,sha256=1XsW8iOSFaH4LOzDcnNyxHpHrbKU3fSn-aIAxe04jmw,21
+ul_api_utils-7.7.0.dist-info/RECORD,,