ul-api-utils 8.0.1a0__tar.gz → 8.0.3__tar.gz

{ul-api-utils-8.0.1a0 → ul-api-utils-8.0.3}/PKG-INFO

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

{ul-api-utils-8.0.1a0 → ul-api-utils-8.0.3}/example/routes/api_some.py

@@ -51,7 +51,7 @@ class Eeenum(IntEnum):
 
 class SomeBody(BaseModel):
     seconds: float
-    eenum: Optional[Eeenum]
+    eenum: Optional[Eeenum] = None
 
 
 class Some2Query(ApiRequestQuery):

{ul-api-utils-8.0.1a0 → ul-api-utils-8.0.3}/setup.py

@@ -9,7 +9,7 @@ with open(path.join(HERE, 'README.md'), encoding='utf-8') as f:
 
 setup(
     name='ul-api-utils',
-    version='8.0.1-alpha',
+    version='8.0.3',
     description='Python api utils',
     author='Unic-lab',
     long_description=long_description,
@@ -49,13 +49,11 @@ setup(
     platforms='any',
     install_requires=[
         "unipipeline==1.9.4",
-        "pydantic[mypy]==2.10.6",
-        "pydantic-i18n==0.2.3",
-        "jinja2==3.1.5",
-        "flask==3.1.0",
-        "flask-wtf==1.2.2",
-        "flask-limiter==3.10.1",
-        "flask-caching==2.3.0",
+        "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",
@@ -78,7 +76,7 @@ setup(
         "types-requests==2.28.8",
         "types-jinja2==2.11.9",
         "xlsxwriter==3.2.0",
-        "werkzeug==3.1.3",
+        "werkzeug==2.3.7",
         "frozendict==2.4.4",
         "wtforms==3.0.1",
         "wtforms-alchemy==0.18.0",
@@ -90,7 +88,7 @@ setup(
         # "opentelemetry-instrumentation-requests==0.27b0",
         # "opentelemetry-exporter-jaeger==1.8.0",
         # "opentelemetry-instrumentation-sqlalchemy==0.27b0",
-        # "ul-db-utils==3.3.2",        # ACTUALIZE, BUT DO NOT UNCOMMENT PLEASE
-        # "ul-py-tool==1.15.42",        # ACTUALIZE, BUT DO NOT UNCOMMENT PLEASE
+        # "ul-db-utils==3.3.7",        # ACTUALIZE, BUT DO NOT UNCOMMENT PLEASE
+        # "ul-py-tool==2.1.2",        # ACTUALIZE, BUT DO NOT UNCOMMENT PLEASE
     ],
 )

{ul-api-utils-8.0.1a0 → ul-api-utils-8.0.3}/ul_api_utils/access/__init__.py

@@ -1,7 +1,7 @@
 import re
 from typing import Dict, List, Union, Any, Iterable
 
-from pydantic import BaseModel
+from pydantic import ConfigDict, BaseModel
 
 from ul_api_utils.conf import APPLICATION_F
 
@@ -13,8 +13,7 @@ class PermissionDefinition(BaseModel):
     category: str
     flags: str = ''
 
-    class Config:
-        allow_mutation: bool = False
+    model_config = ConfigDict(frozen=True)
 
 
 class PermissionRegistry:

{ul-api-utils-8.0.1a0 → ul-api-utils-8.0.3}/ul_api_utils/api_resource/api_request.py

@@ -1,7 +1,7 @@
 import json
 from typing import NamedTuple, Iterable, Any, List, Tuple, Dict, Optional
 
-from pydantic import BaseModel, root_validator
+from pydantic import model_validator, BaseModel
 
 from ul_api_utils.errors import SimpleValidateApiError
 from ul_api_utils.utils.api_pagination import ApiPagination
@@ -42,7 +42,8 @@ class ApiRequestQuery(BaseModel):
     offset: Optional[int] = None
     page: Optional[int] = None
 
-    @root_validator(pre=True)
+    @model_validator(mode="before")
+    @classmethod
     def validate_empty_values(cls, values: Dict[str, Any]) -> Dict[str, Any]:
         vals = dict()
         for k, v in values.items():

{ul-api-utils-8.0.1a0 → ul-api-utils-8.0.3}/ul_api_utils/api_resource/api_resource.py

@@ -7,7 +7,7 @@ from tempfile import NamedTemporaryFile
 from typing import List, Dict, Any, Optional, Tuple, Union, BinaryIO, Mapping, TypeVar, Callable, Set, TYPE_CHECKING
 
 from flask import render_template, request
-from pydantic.errors import PydanticValueError
+from pydantic_core import PydanticCustomError
 from werkzeug.datastructures import FileStorage
 
 from ul_api_utils.access import GLOBAL_PERMISSION__PUBLIC, PermissionDefinition, GLOBAL_PERMISSION__PRIVATE_RT, GLOBAL_PERMISSION__PRIVATE
@@ -170,12 +170,13 @@ class ApiResource:
             return JsonApiResponse._internal_use_response_error(self._fn_typing.response_payload_many, 401, [self._mk_error("access-error", str(err), False)])
         if isinstance(err, SimpleValidateApiError):
             return JsonApiResponse._internal_use_response_error(self._fn_typing.response_payload_many, 400, [self._mk_error("validation-error", str(err), False)])
-        if isinstance(err, (PydanticValueError, ValidateApiError)):
+        if isinstance(err, (PydanticCustomError, ValidateApiError)):
             return JsonApiResponse._internal_use_response_error(self._fn_typing.response_payload_many, 400, [{
-                "error_kind": f"value_error.{err.code}",
+                "error_kind": f"value_error.{err.code}",  # type: ignore
                 "error_location": err.location,  # type: ignore
                 "error_type": "body-validation-error",
-                "error_message": f"{err.msg_template}",
+                "error_message": f"{err.msg_template}",  # type: ignore
+                "error_input": err.input,  # type: ignore
             }])
         if isinstance(err, NoResultFoundApiError):
             return JsonApiResponse._internal_use_response_error(self._fn_typing.response_payload_many, 404, [
@@ -222,7 +223,7 @@ class ApiResource:
         apply_auth_headers: bool = False,
     ) -> HtmlApiResponse:
         if hasattr(happened_exception, "status_code"):
-            default_status_code = happened_exception.status_code  # type: ignore
+            default_status_code = happened_exception.status_code
         assert self._config.web_error_template is not None  # only for mypy
         response = HtmlApiResponse(
             content=self.render_template(

{ul-api-utils-8.0.1a0 → ul-api-utils-8.0.3}/ul_api_utils/api_resource/api_resource_config.py

@@ -1,6 +1,6 @@
 from typing import Optional, Callable, Tuple
 
-from pydantic import BaseModel, Extra
+from pydantic import ConfigDict, BaseModel
 
 from ul_api_utils.api_resource.api_response import ApiResponse
 from werkzeug import Response as BaseResponse
@@ -14,6 +14,7 @@ class ApiResourceConfig(BaseModel):
     exc_handler_endpoint: Optional[Callable[[Exception], Optional[ApiResponse]]] = None
     override_flask_response: Optional[Callable[[Tuple[BaseResponse, int]], Tuple[BaseResponse, int]]] = None
 
-    class Config:
-        extra = Extra.forbid
-        allow_mutation = False
+    model_config = ConfigDict(
+        extra="forbid",
+        frozen=True,
+    )

{ul-api-utils-8.0.1a0 → ul-api-utils-8.0.3}/ul_api_utils/api_resource/api_resource_fn_typing.py

@@ -2,8 +2,9 @@ import inspect
 from typing import NamedTuple, Any, Callable, Optional, List, Dict, Type, Tuple, TYPE_CHECKING
 
 from flask import request
-from pydantic import BaseModel, ValidationError, parse_obj_as, validate_arguments
+from pydantic import BaseModel, ValidationError, validate_call, TypeAdapter
 from pydantic.utils import deep_update
+from pydantic_core import ErrorDetails
 
 from ul_api_utils.api_resource.api_request import ApiRequestQuery
 from ul_api_utils.api_resource.api_resource_type import ApiResourceType
@@ -19,23 +20,23 @@ from ul_api_utils.utils.unwrap_typing import UnwrappedOptionalObjOrListOfObj
 
 if TYPE_CHECKING:
     from ul_api_utils.api_resource.api_resource import ApiResource
-    from pydantic.error_wrappers import ErrorDict
 
 FN_SYSTEM_PROPS = {"api_resource", "query", "body", "return", "body_validation_error", "query_validation_error"}
 
 
-def _patch_errors(dest_errors: List[Dict[str, str]], errors: List['ErrorDict'], kind: str) -> List[Dict[str, str]]:
+def _patch_errors(dest_errors: List[Dict[str, str]], errors: List[ErrorDetails], kind: str) -> List[Dict[str, str]]:
     for error in errors:
         dest_errors.append({
             "error_type": kind,
             "error_message": error['msg'],
             "error_location": error["loc"],  # type: ignore
             "error_kind": error["type"],
+            "error_input": error["input"],
         })
     return dest_errors
 
 
-@validate_arguments
+@validate_call()
 def _body_list(root: List[Dict[str, Any]]) -> List[Any]:  # only for pydantic validation
     return root
 
@@ -72,12 +73,12 @@ class ApiResourceFnTyping(NamedTuple):
         if self.request_body_optional:
             if self.request_body_many:
                 class BodyTypingOptList(BaseModel):
-                    __root__: Optional[List[body_typing]]  # type: ignore
+                    __root__: Optional[List[body_typing]] = None  # type: ignore
 
                 return BodyTypingOptList
 
             class BodyTypingOpt(BaseModel):
-                __root__: Optional[body_typing]  # type: ignore
+                __root__: Optional[body_typing] = None  # type: ignore
             return BodyTypingOpt
 
         if self.request_body_many:
@@ -154,8 +155,7 @@ class ApiResourceFnTyping(NamedTuple):
             return kwargs, errors
         body = self._get_body()
         try:
-            expected_typing: Type[BaseModel | List[BaseModel]] = List[self.body_typing] if self.request_body_many else self.body_typing      # type: ignore
-            kwargs['body'] = parse_obj_as(expected_typing, body)
+            kwargs['body'] = TypeAdapter(Type[BaseModel | List[BaseModel]]).validate_python(body)
         except ValidationError as ve:
             if self.has_body_validation_error:
                 kwargs['body_validation_error'] = ve
@@ -167,9 +167,11 @@ class ApiResourceFnTyping(NamedTuple):
         if self.query_typing is None:
             return kwargs, errors
         try:
+            is_complex_field = lambda field: field.annotation and not isinstance(field.annotation, (str, int, float, bool, type(None)))  # noqa: E731
             kwargs["query"] = set_model(self.query_typing, {
                 **request.args.to_dict(),
-                **{key: value for key, value in request.args.to_dict(flat=False).items() if key in self.query_typing.__fields__ and self.query_typing.__fields__[key].is_complex()},
+                **{key: value for key, value in request.args.to_dict(flat=False).items()
+                if key in self.query_typing.model_fields and is_complex_field(self.query_typing.model_fields[key])},
             })
         except ValidationError as ve:
             if self.has_query_validation_error:
@@ -182,7 +184,7 @@ class ApiResourceFnTyping(NamedTuple):
         loc_err = []
         for name, type_ in self.signatures_typing:
             try:
-                kwargs[name] = parse_obj_as(type_, kwargs.get(name))
+                kwargs[name] = TypeAdapter(type_).validate_python(kwargs.get(name))
             except ValidationError as e:
                 err = e.errors()[0]
                 err["loc"] = [name]  # type: ignore
@@ -246,7 +248,7 @@ class ApiResourceFnTyping(NamedTuple):
                     ret_payload_res = get_typing(return_payload_typing)
                     if len(ret_payload_res) > 1:
                         return_payload_typing = ret_payload_res[1]
-                        if ret_payload_res[0] != list:
+                        if ret_payload_res[0] != list:  # noqa: E721
                             raise TypeError(f'{fn.__name__} :: invalid response payload type wrapper. only List is supported')
                         response_many = True
 

{ul-api-utils-8.0.1a0 → ul-api-utils-8.0.3}/ul_api_utils/api_resource/api_response.py

@@ -4,8 +4,8 @@ from types import NoneType
 from typing import TypeVar, Generic, List, Optional, Dict, Any, Callable, Union, BinaryIO, Tuple, Type
 import msgpack
 from flask import jsonify, send_file, redirect, Response, request
-from pydantic import Extra
-from pydantic.main import BaseModel
+from pydantic import ConfigDict, RootModel
+from pydantic import BaseModel
 from werkzeug import Response as BaseResponse
 
 from ul_api_utils.api_resource.db_types import TPayloadInputUnion
@@ -28,9 +28,10 @@ class ApiResponse(BaseModel):
     status_code: int
     headers: Dict[str, str] = {}
 
-    class Config:
-        extra = Extra.forbid
-        arbitrary_types_allowed = True
+    model_config = ConfigDict(
+        extra="forbid",
+        arbitrary_types_allowed=True
+    )
 
     @classmethod
     def _internal_use__mk_schema(cls, inner_type: Optional[Type[BaseModel]]) -> Type[BaseModel]:
@@ -87,7 +88,7 @@ class HtmlApiResponse(ApiResponse):
 
 class FileApiResponse(ApiResponse):
     file_path: Union[str, BinaryIO, io.BytesIO]
-    mimetype: Optional[str]  # it will be auto-detected by extension if mimetype==None
+    mimetype: Optional[str] = None  # it will be auto-detected by extension if mimetype==None
     as_attachment: bool = False
     download_name: Optional[str] = None
     attachment_filename: Optional[str] = None
@@ -139,8 +140,7 @@ class EmptyJsonApiResponse(ApiResponse):
 
 
 class JsonApiResponsePayload(BaseModel):
-    class Config:
-        extra = Extra.ignore
+    model_config = ConfigDict(extra="ignore")
 
 
 TResultPayloadUnion = Union[None, Dict[str, Any], JsonApiResponsePayload, List[JsonApiResponsePayload], List[Dict[str, Any]]]
@@ -153,8 +153,8 @@ TPayloadTotalUnion = Union[
 ]
 
 
-class DictJsonApiResponsePayload(JsonApiResponsePayload):
-    __root__: Dict[str, Any]
+class DictJsonApiResponsePayload(RootModel[Dict[str, Any]]):
+    pass
 
 
 TProxyPayload = TypeVar('TProxyPayload', bound=Union[JsonApiResponsePayload, List[JsonApiResponsePayload], None])
@@ -208,7 +208,7 @@ class AnyJsonApiResponse(ApiResponse):
     def _internal_use__mk_schema(cls, inner_type: Optional[Type[BaseModel]]) -> Type[BaseModel]:
         class _ResponseStd(BaseModel):
             ok: bool
-            payload: Any
+            payload: Any = None
             errors: List[Dict[str, Any]]
             total_count: Optional[int] = None
             count: Optional[int] = None

{ul-api-utils-8.0.1a0 → ul-api-utils-8.0.3}/ul_api_utils/api_resource/signature_check.py

@@ -1,7 +1,7 @@
 from typing import Any, Dict, Optional, Union, Type, TypeVar, Tuple, TYPE_CHECKING
 from typing import _GenericAlias  # type: ignore
 
-from pydantic import BaseModel
+from pydantic import BaseModel, RootModel
 
 from ul_api_utils.utils.json_encoder import to_dict
 
@@ -14,8 +14,8 @@ TPydanticModel = TypeVar('TPydanticModel', bound=BaseModel)
 def set_model(model: Type[TPydanticModel], data: Union[Dict[str, Any], TPydanticModel]) -> TPydanticModel:
     if isinstance(data, model):
         return data
-    if "__root__" in model.__fields__:
-        return model(__root__=data).__root__  # type: ignore
+    if issubclass(model, RootModel):
+        return model(data).root
     assert isinstance(data, dict), f'data must be dict. "{type(data).__name__}" was given'
     return model(**data)
 
@@ -26,13 +26,13 @@ def set_model_dictable(model: Type[TPydanticModel], data: 'TDictable') -> Option
     res: Optional[Dict[str, Any]] = to_dict(data)
     if res is None:
         return None
-    if "__root__" in model.__fields__:
-        return model(__root__=res).__root__  # type: ignore
+    if issubclass(model, RootModel):
+        return model(data).root
     return model(**res)
 
 
 def get_typing(t: Type[Any]) -> Tuple[Type[Any], ...]:
-    if type(t) == _GenericAlias:
+    if type(t) == _GenericAlias:  # noqa: E721
         src_t = t
         return src_t.__origin__, *(it for it in src_t.__args__)
     return t,  # noqa: C818

{ul-api-utils-8.0.1a0 → ul-api-utils-8.0.3}/ul_api_utils/commands/cmd_enc_keys.py

@@ -27,11 +27,11 @@ class CmdEncKeys(Cmd):
     name: str
     services: List[str]
     dir: str
-    permissions_module: Optional[str]
-    permissions_uri: Optional[str]
-    env: Optional[str]
-    org_id: Optional[UUID]
-    user_id: Optional[UUID]
+    permissions_module: Optional[str] = None
+    permissions_uri: Optional[str] = None
+    env: Optional[str] = None
+    org_id: Optional[UUID] = None
+    user_id: Optional[UUID] = None
 
     @staticmethod
     def add_parser_args(parser: argparse.ArgumentParser) -> None:

{ul-api-utils-8.0.1a0 → ul-api-utils-8.0.3}/ul_api_utils/commands/cmd_gen_new_api_user.py

@@ -29,7 +29,7 @@ class CmdGenerateNewApiUser(Cmd):
     uri_auth_api: str
     internal_access_key: str
     permissions_list: List[int]
-    permissions_uri: Optional[str]
+    permissions_uri: Optional[str] = None
     api_user_name: str
     api_user_note: str
     api_user_date_exp: datetime

{ul-api-utils-8.0.1a0 → ul-api-utils-8.0.3}/ul_api_utils/commands/cmd_generate_api_docs.py

@@ -85,7 +85,7 @@ class CmdGenApiFunctionDocumentation(Cmd):
 
     @staticmethod
     def load_functions(directory: str) -> Dict[str, Callable[..., Any]]:
-        function_name_object__map = {}
+        function_name_object__map: dict[str, Callable[..., Any]] = {}
         for root, _dirs, files in os.walk(directory):
             for file in files:
                 py_postfix = '.py'

{ul-api-utils-8.0.1a0 → ul-api-utils-8.0.3}/ul_api_utils/commands/cmd_start.py

@@ -29,8 +29,8 @@ class CmdStart(Cmd):
     max_requests_jitter: int
     worker_class: str
     freeze_gc: bool
-    statsd_endpoint: Optional[str]
-    statsd_prefix: Optional[str]
+    statsd_endpoint: Optional[str] = None
+    statsd_prefix: Optional[str] = None
 
     @property
     def app_rel_dir(self) -> str:

{ul-api-utils-8.0.1a0 → ul-api-utils-8.0.3}/ul_api_utils/debug/debugger.py

@@ -22,7 +22,7 @@ class DebuggerJSONEncoder(JSONEncoder):
         if isinstance(obj, set):
             return list(obj)
         if hasattr(obj, "__html__"):  # it needs for Flask ?
-            return str(obj.__html__())  # type: ignore
+            return str(obj.__html__())
         return super().default(obj)
 
 

{ul-api-utils-8.0.1a0 → ul-api-utils-8.0.3}/ul_api_utils/errors.py

@@ -1,6 +1,4 @@
-from typing import Dict, List
-
-from pydantic import PydanticValueError
+from typing import Dict, List, Any
 
 from ul_api_utils.internal_api.internal_api_error import InternalApiResponseErrorObj
 
@@ -94,7 +92,7 @@ class ResponseStatusAbstractInternalApiError(ResponseAbstractInternalApiError):
     def __init__(self, status_code: int, errors: List[InternalApiResponseErrorObj]) -> None:
         assert isinstance(status_code, int), f'status_code must be int. "{type(status_code).__name__}" was given'
         assert status_code >= 400
-        super(ResponseStatusAbstractInternalApiError, self).__init__(f'status code error :: {status_code} :: {[e.dict() for e in errors]}')
+        super(ResponseStatusAbstractInternalApiError, self).__init__(f'status code error :: {status_code} :: {[e.model_dump() for e in errors]}')
         self.status_code = status_code
         self.errors = errors
 
@@ -137,10 +135,18 @@ class ValidationListApiError(UserAbstractApiError):
         self.errors = errors
 
 
-class ValidateApiError(PydanticValueError, UserAbstractApiError):
-    code = "{code}"
-    location = ["{location}"]
-    msg_template = "{msg_template}"
+class ValidateApiError(UserAbstractApiError):
+    def __init__(self, code: str, location: list[Any], msg_template: str, input: Any = None):
+        self.code = code
+        self.location = location
+        self.msg_template = msg_template
+        self.input = input
+
+    def __str__(self):  # type: ignore
+        return (
+            f"{self.msg_template} (code={self.code}, location={self.location}, "
+            f"input={self.input})"
+        )
 
 
 class SimpleValidateApiError(UserAbstractApiError):

{ul-api-utils-8.0.1a0 → ul-api-utils-8.0.3}/ul_api_utils/internal_api/internal_api_error.py

@@ -1,6 +1,6 @@
 from typing import Optional, Any, Dict, List, Tuple, Union
 
-from pydantic import BaseModel, Extra
+from pydantic import ConfigDict, BaseModel
 
 
 class InternalApiResponseErrorObj(BaseModel):
@@ -8,8 +8,10 @@ class InternalApiResponseErrorObj(BaseModel):
     error_message: str
     error_location: Optional[Union[List[str], str, Tuple[str, ...]]] = None
     error_kind: Optional[str] = None
+    error_input: Optional[Any] = None
     other: Optional[Dict[str, Any]] = None
 
-    class Config:
-        extra = Extra.ignore
-        allow_mutation = False
+    model_config = ConfigDict(
+        extra="ignore",
+        frozen=True,
+    )

{ul-api-utils-8.0.1a0 → ul-api-utils-8.0.3}/ul_api_utils/modules/api_sdk.py

@@ -150,7 +150,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.postgres_modules.db import db       # type: ignore # yes, db already defined, but can not use two conigs
+            from ul_db_utils.modules.postgres_modules.db import db       # 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
@@ -490,7 +490,7 @@ class ApiSdk:
                         elif api_resource._type == ApiResourceType.FILE:
                             result = api_resource.response_api_error(e)
                         else:
-                            result = api_resource.response_web_error(
+                            result = api_resource.response_web_error(  # type: ignore
                                 ResourceRuntimeApiError(f'unsupported type "{api_resource._type.value}" of error response'),
                             )
                         res = result.to_flask_response(d), result.status_code

{ul-api-utils-8.0.1a0 → ul-api-utils-8.0.3}/ul_api_utils/modules/api_sdk_config.py

@@ -1,7 +1,7 @@
 from enum import Enum
 from typing import List, Optional, Callable, Union
 
-from pydantic import BaseModel, Extra
+from pydantic import ConfigDict, BaseModel
 
 from ul_api_utils.access import PermissionRegistry, PermissionDefinition
 from ul_api_utils.modules.api_sdk_jwt import ApiSdkJwt
@@ -56,8 +56,8 @@ class ApiSdkConfig(BaseModel):
 
     api_route_path_prefix: str = '/api'
 
-    class Config:
-        extra = Extra.forbid
-        allow_mutation = False
-        frozen = True
-        arbitrary_types_allowed = True
+    model_config = ConfigDict(
+        extra="forbid",
+        frozen=True,
+        arbitrary_types_allowed=True,
+    )

ul-api-utils-8.0.3/ul_api_utils/modules/worker_sdk_config.py

@@ -0,0 +1,13 @@
+from pydantic import ConfigDict, BaseModel
+
+from ul_api_utils.resources.socketio import SocketIOConfig
+
+
+class WorkerSdkConfig(BaseModel):
+    socket_config: SocketIOConfig | None = None
+
+    model_config = ConfigDict(
+        extra="forbid",
+        frozen=True,
+        arbitrary_types_allowed=True,
+    )

{ul-api-utils-8.0.1a0 → ul-api-utils-8.0.3}/ul_api_utils/resources/caching.py

@@ -3,7 +3,7 @@ import hashlib
 import inspect
 import itertools
 import logging
-from _hashlib import HASH   # type: ignore
+from _hashlib import HASH
 from collections import defaultdict
 from enum import Enum
 from typing import Optional, Callable, Dict, Tuple, List, Union, Literal, cast, TypeVar, Any, Set, TypedDict
@@ -65,7 +65,7 @@ class ULCache(Cache):
 
     @staticmethod
     def _has_common_elements(seq: Set[Tuple[str, ...]]) -> bool:
-        return bool(functools.reduce(set.intersection, map(set, seq)))      # type: ignore
+        return bool(functools.reduce(set.intersection, map(set, seq)))
 
     @staticmethod
     def _format_cache_key(parts: List[Any]) -> str:
@@ -77,8 +77,8 @@ class ULCache(Cache):
         source_check: bool,
         hash_method: Callable[[bytes], HASH],
     ) -> str:
-        cache_key_parts = [request.path]
-        cache_hash = None
+        cache_key_parts: List[str] = [request.path]
+        cache_hash: HASH | None = None
         if request.args:
             args_as_sorted_tuple = tuple(sorted(pair for pair in request.args.items(multi=True)))
 
@@ -93,8 +93,8 @@ class ULCache(Cache):
                 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)
+        cache_hash_str = str(cache_hash.hexdigest()) if cache_hash is not None else ''
+        cache_key_parts.append(cache_hash_str)
 
         return self._format_cache_key(cache_key_parts)
 

{ul-api-utils-8.0.1a0 → ul-api-utils-8.0.3}/ul_api_utils/resources/debugger_scripts.py

@@ -78,7 +78,7 @@ def load_debugger_static_scripts(sdk: 'ApiSdk') -> None:
         for req_url in reversed(body.requests_hierarchy):
             for k, api in internal_api_registry.items():
                 if req_url.startswith(k):
-                    api_body = body.dict()
+                    api_body = body.model_dump()
                     api_body['requests_hierarchy'] = []
                     api_result = api.request_post('/debugger-explain', v=ApiPathVersion.NO_VERSION, json=api_body).check().typed(DebuggerExplainResponse)
                     return api_resource.response_ok(api_result.payload)

{ul-api-utils-8.0.1a0 → ul-api-utils-8.0.3}/ul_api_utils/resources/health_check/health_check.py

@@ -2,7 +2,7 @@ import time
 from enum import Enum, IntEnum
 from typing import List, Callable, Any, Optional, Dict, TYPE_CHECKING, Tuple, NamedTuple, Set, Union
 
-from pydantic import Field, BaseModel, parse_obj_as, PositiveInt, root_validator
+from pydantic import model_validator, ConfigDict, Field, BaseModel, PositiveInt, TypeAdapter
 from sqlalchemy.sql import text
 from unipipeline.errors import UniError
 from unipipeline.modules.uni import Uni
@@ -64,7 +64,7 @@ class HealthCheckStepType(Enum):
                 executed_result.check()
             except (Client4XXInternalApiError, Server5XXInternalApiError) as e:
                 error = e
-            payload = parse_obj_as(HealthCheckApiResponse, executed_result.payload_raw).checks
+            payload = TypeAdapter(HealthCheckApiResponse).validate_python(executed_result.payload_raw).checks
             if error:
                 if isinstance(error, Client4XXInternalApiError):
                     return HealthCheckResultStatus.WARN, '', payload
@@ -144,7 +144,7 @@ class HealthCheckStep(NamedTuple):
     type: HealthCheckStepType
     executable: Callable[..., Any]
     executable_args: Tuple[Any, ...] = tuple()
-    executable_kwargs: Any = Field(default_factory=dict)
+    executable_kwargs: Any = Field(default_factory=lambda: dict())
 
     def run(self) -> Tuple[HealthCheckResultStatus, float, str, List[HealthCheckResult]]:
         start_time = time.perf_counter()
@@ -380,8 +380,7 @@ class HealthCheckApiResponse(JsonApiResponsePayload):
     service_name: str
     checks: List[HealthCheckResult] = Field(default_factory=list)
 
-    class Config:
-        use_enum_values = True
+    model_config = ConfigDict(use_enum_values=True)
 
 
 class HealthCheckMessageQueueRange(BaseModel):
@@ -407,13 +406,13 @@ class HealthCheckMessageQueueRange(BaseModel):
         description="Maximum number of messages for queue to have in order to be classified with status WARN (400).",
     )
 
-    @root_validator()
-    def root_validate(cls, values: Dict[str, Any]) -> Dict[str, Any]:
-        ok, warn = values.get('ok'), values.get('warn')
+    @model_validator(mode='after')
+    def root_validate(self) -> 'HealthCheckMessageQueueRange':
+        ok, warn = self.ok, self.warn
         if ok is not None and warn is not None:
             if ok >= warn:
                 raise ValueError(f"OK attribute should be less than WARN attribute, but you provided {ok=}, {warn=}")
-        return values
+        return self
 
     def get_status(self, message_count: int) -> HealthCheckResultStatus:
         if message_count <= self.ok:
@@ -437,5 +436,4 @@ class HealthCheckQueueMessageCountStatus(BaseModel):
     queue_name: str
     message_count_status_map: Dict[range, HealthCheckResultStatus]
 
-    class Config:
-        arbitrary_types_allowed = True
+    model_config = ConfigDict(arbitrary_types_allowed=True)