ul-api-utils 7.6.0__tar.gz → 7.7.0__tar.gz

{ul-api-utils-7.6.0 → ul-api-utils-7.7.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: ul-api-utils
-Version: 7.6.0
+Version: 7.7.0
 Summary: Python api utils
 Author: Unic-lab
 Author-email: 

{ul-api-utils-7.6.0 → ul-api-utils-7.7.0}/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(

{ul-api-utils-7.6.0 → ul-api-utils-7.7.0}/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-7.6.0 → ul-api-utils-7.7.0}/setup.py

@@ -9,7 +9,7 @@ with open(path.join(HERE, 'README.md'), encoding='utf-8') as f:
 
 setup(
     name='ul-api-utils',
-    version='7.6.0',
+    version='7.7.0',
     description='Python api utils',
     author='Unic-lab',
     long_description=long_description,
@@ -55,6 +55,7 @@ setup(
         "flask==2.1.3",
         "flask-wtf==1.0.1",
         "flask-limiter==2.5.1",
+        "flask-caching==2.1.0",
         "flask-swagger-ui==4.11.1",
         "flask-monitoringdashboard==3.1.2",
         "pycryptodome==3.15.0",
@@ -65,6 +66,7 @@ setup(
         "cryptography==38.0.1",
         "colored==1.4.3",
 
+        "ormsgpack==1.4.1",
         "msgpack==1.0.4",
         "msgpack-types==0.2.0",
         "fastavro==1.7.0",
@@ -82,7 +84,7 @@ setup(
         # "opentelemetry-instrumentation-requests==0.27b0",
         # "opentelemetry-exporter-jaeger==1.8.0",
         # "opentelemetry-instrumentation-sqlalchemy==0.27b0",
-        # "ul-db-utils==2.10.9",        # ACTUALIZE, BUT DO NOT UNCOMMENT PLEASE
-        # "ul-py-tool==1.15.20",        # ACTUALIZE, BUT DO NOT UNCOMMENT PLEASE
+        # "ul-db-utils==3.1.0",        # ACTUALIZE, BUT DO NOT UNCOMMENT PLEASE
+        # "ul-py-tool==1.15.42",        # ACTUALIZE, BUT DO NOT UNCOMMENT PLEASE
     ],
 )

{ul-api-utils-7.6.0 → ul-api-utils-7.7.0}/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-7.6.0 → ul-api-utils-7.7.0}/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,7 @@ from ul_api_utils.utils.uuid_converter import UUID4Converter
 
 if TYPE_CHECKING:
     import flask_sqlalchemy
-    from flask_pymongo import PyMongo
+    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
 
@@ -105,6 +107,7 @@ class ApiSdk:
         '_fn_registry',
         '_flask_app_cache',
         '_limiter_enabled',
+        '_cache',
         '_db',
     )
 
@@ -117,6 +120,7 @@ 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')
 
@@ -139,7 +143,7 @@ class ApiSdk:
 
         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
@@ -152,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'),
@@ -215,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,
@@ -225,6 +249,10 @@ class ApiSdk:
 
         return flask_app
 
+    @property
+    def ul_cache_factory(self) -> Optional['ULCache']:
+        return self._cache
+
     @property
     def db(self) -> Optional['flask_sqlalchemy.SQLAlchemy'] | Optional['PyMongo']:
         return self._db
@@ -247,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:
@@ -285,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,
@@ -436,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-7.6.0 → ul-api-utils-7.7.0}/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-7.7.0/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-7.6.0 → ul-api-utils-7.7.0}/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.6.0 → ul-api-utils-7.7.0}/ul_api_utils.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: ul-api-utils
-Version: 7.6.0
+Version: 7.7.0
 Summary: Python api utils
 Author: Unic-lab
 Author-email: 

{ul-api-utils-7.6.0 → ul-api-utils-7.7.0}/ul_api_utils.egg-info/SOURCES.txt

@@ -74,6 +74,7 @@ ul_api_utils/modules/worker_sdk_config.py
 ul_api_utils/modules/__tests__/__init__.py
 ul_api_utils/modules/__tests__/test_api_sdk_jwt.py
 ul_api_utils/resources/__init__.py
+ul_api_utils/resources/caching.py
 ul_api_utils/resources/debugger_scripts.py
 ul_api_utils/resources/not_implemented.py
 ul_api_utils/resources/permissions.py

{ul-api-utils-7.6.0 → ul-api-utils-7.7.0}/ul_api_utils.egg-info/requires.txt

@@ -5,6 +5,7 @@ jinja2==3.1.2
 flask==2.1.3
 flask-wtf==1.0.1
 flask-limiter==2.5.1
+flask-caching==2.1.0
 flask-swagger-ui==4.11.1
 flask-monitoringdashboard==3.1.2
 pycryptodome==3.15.0
@@ -14,6 +15,7 @@ pyyaml==6.0
 requests==2.28.1
 cryptography==38.0.1
 colored==1.4.3
+ormsgpack==1.4.1
 msgpack==1.0.4
 msgpack-types==0.2.0
 fastavro==1.7.0