arpakitlib 1.7.66__py3-none-any.whl → 1.7.124__py3-none-any.whl

arpakitlib/ar_fastapi_util.py

@@ -21,18 +21,18 @@ from fastapi import FastAPI, APIRouter, Query, Security, Depends
 from fastapi.openapi.docs import get_swagger_ui_html, get_redoc_html
 from fastapi.security import APIKeyHeader
 from pydantic import BaseModel, ConfigDict
+from starlette import status
 from starlette.middleware.cors import CORSMiddleware
 from starlette.staticfiles import StaticFiles
 
-from arpakitlib.ar_base_worker_util import BaseWorker
 from arpakitlib.ar_dict_util import combine_dicts
 from arpakitlib.ar_enumeration_util import Enumeration
-from arpakitlib.ar_file_storage_in_dir_util import FileStorageInDir
-from arpakitlib.ar_json_util import safely_transfer_to_json_str_to_json_obj
+from arpakitlib.ar_func_util import raise_if_not_async_func, is_async_function, is_async_object
+from arpakitlib.ar_json_util import safely_transfer_obj_to_json_str_to_json_obj
 from arpakitlib.ar_logging_util import setup_normal_logging
-from arpakitlib.ar_sqlalchemy_model_util import StoryLogDBM
+from arpakitlib.ar_sqlalchemy_model_util import StoryLogDBM, OperationDBM
 from arpakitlib.ar_sqlalchemy_util import SQLAlchemyDB
-from arpakitlib.ar_type_util import raise_for_type, raise_if_not_async_func, raise_if_none
+from arpakitlib.ar_type_util import raise_for_type, raise_if_none
 
 _ARPAKIT_LIB_MODULE_VERSION = "3.0"
 
@@ -96,6 +96,10 @@ class StoryLogSO(SimpleSO):
     title: str | None
     data: dict[str, Any]
 
+    @classmethod
+    def from_story_log_dbm(cls, *, story_log_dbm: StoryLogDBM) -> StoryLogSO:
+        return cls.model_validate(story_log_dbm.simple_dict(include_sd_properties=True))
+
 
 class OperationSO(SimpleSO):
     execution_start_dt: datetime | None
@@ -107,13 +111,29 @@ class OperationSO(SimpleSO):
     error_data: dict[str, Any]
     duration_total_seconds: float | None
 
+    @classmethod
+    def from_operation_dbm(cls, *, operation_dbm: OperationDBM) -> OperationSO:
+        return cls.model_validate(operation_dbm.simple_dict(include_sd_properties=True))
+
 
 class APIJSONResponse(fastapi.responses.JSONResponse):
-    def __init__(self, *, content: BaseSO, status_code: int = starlette.status.HTTP_200_OK):
+    def __init__(self, *, content: dict | list | BaseSO | None, status_code: int = starlette.status.HTTP_200_OK):
+        if isinstance(content, dict):
+            content = safely_transfer_obj_to_json_str_to_json_obj(content)
+        elif isinstance(content, list):
+            content = safely_transfer_obj_to_json_str_to_json_obj(content)
+        elif isinstance(content, BaseSO):
+            content = safely_transfer_obj_to_json_str_to_json_obj(content.model_dump())
+        elif content is None:
+            content = None
+        else:
+            raise ValueError(f"unknown content type, type(content)={type(content)}")
+
         self.content_ = content
         self.status_code_ = status_code
+
         super().__init__(
-            content=safely_transfer_to_json_str_to_json_obj(content.model_dump()),
+            content=content,
             status_code=status_code
         )
 
@@ -221,6 +241,12 @@ def create_handle_exception(
                 error_so.error_specification_code.upper().replace(" ", "_").strip()
             )
 
+        if error_so.error_code == BaseAPIErrorCodes.not_found:
+            status_code = status.HTTP_404_NOT_FOUND
+
+        if error_so.error_code == BaseAPIErrorCodes.cannot_authorize:
+            status_code = status.HTTP_401_UNAUTHORIZED
+
         if _need_exc_info:
             _logger.error(str(exception), exc_info=exception)
         else:
@@ -231,7 +257,7 @@ def create_handle_exception(
             _func_data = func(
                 status_code=status_code, error_so=error_so, request=request, exception=exception, **_kwargs
             )
-            if asyncio.iscoroutine(_func_data):
+            if is_async_function(_func_data):
                 _func_data = await _func_data
             if _func_data is not None:
                 status_code, error_so, _kwargs = _func_data[0], _func_data[1], _func_data[2]
@@ -403,37 +429,6 @@ class BaseShutdownAPIEvent:
         self._logger.info("on_shutdown ends")
 
 
-class InitSqlalchemyDBStartupAPIEvent(BaseStartupAPIEvent):
-    def __init__(self, sqlalchemy_db: SQLAlchemyDB):
-        super().__init__()
-        self.sqlalchemy_db = sqlalchemy_db
-
-    async def async_on_startup(self, *args, **kwargs):
-        self.sqlalchemy_db.init()
-
-
-class SafeRunWorkerStartupAPIEvent(BaseStartupAPIEvent):
-    def __init__(self, workers: list[BaseWorker], safe_run_in_background_mode: str):
-        super().__init__()
-        self.workers = workers
-        self.safe_run_in_background_mode = safe_run_in_background_mode
-
-    async def async_on_startup(self, *args, **kwargs):
-        for worker in self.workers:
-            _ = worker.safe_run_in_background(safe_run_in_background_mode=self.safe_run_in_background_mode)
-
-
-class InitFileStoragesInDir(BaseStartupAPIEvent):
-    def __init__(self, file_storages_in_dir: list[FileStorageInDir | None]):
-        super().__init__()
-        file_storages_in_dir = [v for v in file_storages_in_dir if v is not None]
-        self.file_storages_in_dir = file_storages_in_dir
-
-    async def async_on_startup(self, *args, **kwargs):
-        for file_storage_in_dir in self.file_storages_in_dir:
-            file_storage_in_dir.init()
-
-
 class BaseTransmittedAPIData(BaseModel):
     model_config = ConfigDict(extra="ignore", arbitrary_types_allowed=True, from_attributes=True)
 
@@ -448,27 +443,63 @@ class BaseAPIAuthData(BaseModel):
     require_api_key_string: bool = False
     require_token_string: bool = False
 
+    require_correct_api_key: bool = False
+    require_correct_token: bool = False
+
     token_string: str | None = None
     api_key_string: str | None = None
 
+    is_token_string_correct: bool | None = None
+    is_api_key_string_correct: bool | None = None
+
 
 def base_api_auth(
         *,
         require_api_key_string: bool = False,
-        require_token_string: bool = False
+        require_token_string: bool = False,
+        validate_api_key_func: Callable | None = None,
+        validate_token_func: Callable | None = None,
+        correct_api_keys: str | list[str] | None = None,
+        correct_tokens: str | list[str] | None = None,
+        require_correct_api_key: bool = False,
+        require_correct_token: bool = False,
+        **kwargs
 ) -> Callable:
+    if isinstance(correct_api_keys, str):
+        correct_api_keys = [correct_api_keys]
+    if correct_api_keys is not None:
+        raise_for_type(correct_api_keys, list)
+        validate_api_key_func = lambda *args, **kwargs_: kwargs_["api_key_string"] in correct_api_keys
+
+    if isinstance(correct_tokens, str):
+        correct_tokens = [correct_tokens]
+    if correct_tokens is not None:
+        raise_for_type(correct_tokens, list)
+        validate_token_func = lambda *args, **kwargs_: kwargs_["token_string"] in correct_tokens
+
+    if require_correct_api_key:
+        raise_if_none(validate_api_key_func)
+        require_api_key_string = True
+
+    if require_correct_token:
+        raise_if_none(validate_token_func)
+        require_token_string = True
+
     async def func(
             *,
             ac: fastapi.security.HTTPAuthorizationCredentials | None = fastapi.Security(
                 fastapi.security.HTTPBearer(auto_error=False)
             ),
             api_key_string: str | None = Security(APIKeyHeader(name="apikey", auto_error=False)),
-            request: starlette.requests.Request
+            request: starlette.requests.Request,
+            transmitted_api_data: BaseTransmittedAPIData = Depends(get_transmitted_api_data)
     ) -> BaseAPIAuthData:
 
         api_auth_data = BaseAPIAuthData(
             require_api_key_string=require_api_key_string,
-            require_token_string=require_token_string
+            require_token_string=require_token_string,
+            require_correct_api_key=require_correct_api_key,
+            require_correct_token=require_correct_token
         )
 
         # api_key
@@ -518,63 +549,75 @@ def base_api_auth(
         if not api_auth_data.token_string:
             api_auth_data.token_string = None
 
+        # api_key
+
         if require_api_key_string and not api_auth_data.api_key_string:
             raise APIException(
                 status_code=starlette.status.HTTP_401_UNAUTHORIZED,
                 error_code=BaseAPIErrorCodes.cannot_authorize,
-                error_data=safely_transfer_to_json_str_to_json_obj(api_auth_data.model_dump())
+                error_data=safely_transfer_obj_to_json_str_to_json_obj(api_auth_data.model_dump())
             )
 
+        # token
+
         if require_token_string and not api_auth_data.token_string:
             raise APIException(
                 status_code=starlette.status.HTTP_401_UNAUTHORIZED,
                 error_code=BaseAPIErrorCodes.cannot_authorize,
-                error_data=safely_transfer_to_json_str_to_json_obj(api_auth_data.model_dump())
+                error_data=safely_transfer_obj_to_json_str_to_json_obj(api_auth_data.model_dump())
             )
 
-        return api_auth_data
+        # api_key
 
-    return func
+        if validate_api_key_func is not None:
+            validate_api_key_func_data = validate_api_key_func(
+                api_key_string=api_auth_data.api_key_string,
+                token_string=api_auth_data.token_string,
+                base_api_auth_data=api_auth_data,
+                transmitted_api_data=transmitted_api_data,
+                request=request,
+                **kwargs
+            )
+            if is_async_object(validate_api_key_func_data):
+                validate_api_key_func_data = await validate_api_key_func_data
+            api_auth_data.is_api_key_string_correct = validate_api_key_func_data
 
+        # token
 
-class CheckAPIKeyAPIAuthData(BaseAPIAuthData):
-    is_api_key_correct: bool | None = None
+        if validate_token_func is not None:
+            validate_token_func_data = validate_token_func(
+                api_key_string=api_auth_data.api_key_string,
+                token_string=api_auth_data.token_string,
+                base_api_auth_data=api_auth_data,
+                transmitted_api_data=transmitted_api_data,
+                request=request,
+                **kwargs
+            )
+            if is_async_object(validate_token_func_data):
+                validate_token_func_data_data = await validate_token_func_data
+            api_auth_data.is_token_string_correct = validate_token_func_data_data
 
+        # api_key
 
-def is_api_key_correct_api_auth(
-        *,
-        validate_api_key_func: Callable | None = None,
-        correct_api_key: str | None = None
-):
-    if correct_api_key is not None:
-        validate_api_key_func = lambda *args, **kwargs: kwargs["api_key_string"] == correct_api_key
-    raise_if_none(validate_api_key_func)
+        if require_correct_api_key:
+            if not api_auth_data.is_api_key_string_correct:
+                raise APIException(
+                    status_code=starlette.status.HTTP_401_UNAUTHORIZED,
+                    error_code=BaseAPIErrorCodes.cannot_authorize,
+                    error_data=safely_transfer_obj_to_json_str_to_json_obj(api_auth_data.model_dump())
+                )
 
-    async def func(
-            *,
-            base_api_auth_data: BaseAPIAuthData = Depends(base_api_auth(
-                require_api_key_string=True,
-                require_token_string=False
-            )),
-            transmitted_api_data: BaseTransmittedAPIData = Depends(get_transmitted_api_data),
-            request: starlette.requests.Request
-    ) -> CheckAPIKeyAPIAuthData:
-        check_api_key_api_auth_data = CheckAPIKeyAPIAuthData.model_validate(base_api_auth_data)
-        check_api_key_api_auth_data.is_api_key_correct = validate_api_key_func(
-            api_key_string=base_api_auth_data.api_key_string,
-            base_api_auth_data=base_api_auth_data,
-            transmitted_api_data=transmitted_api_data,
-            request=request
-        )
+        # token
 
-        if not check_api_key_api_auth_data.is_api_key_correct:
-            raise APIException(
-                status_code=starlette.status.HTTP_401_UNAUTHORIZED,
-                error_code=BaseAPIErrorCodes.cannot_authorize,
-                error_data=safely_transfer_to_json_str_to_json_obj(check_api_key_api_auth_data.model_dump())
-            )
+        if require_correct_token:
+            if not api_auth_data.is_token_string_correct:
+                raise APIException(
+                    status_code=starlette.status.HTTP_401_UNAUTHORIZED,
+                    error_code=BaseAPIErrorCodes.cannot_authorize,
+                    error_data=safely_transfer_obj_to_json_str_to_json_obj(api_auth_data.model_dump())
+                )
 
-        return check_api_key_api_auth_data
+        return api_auth_data
 
     return func
 
@@ -617,18 +660,12 @@ def simple_api_router_for_testing():
     return router
 
 
-DEFAULT_CONTACT = {
-    "name": "ARPAKIT Company",
-    "email": "support@arpakit.com"
-}
-
-
 def create_fastapi_app(
         *,
         title: str = "arpakitlib FastAPI",
         description: str | None = "arpakitlib FastAPI",
         log_filepath: str | None = "./story.log",
-        handle_exception_: Callable | None = create_handle_exception(),
+        handle_exception_: Callable | None = None,
         startup_api_events: list[BaseStartupAPIEvent | None] | None = None,
         shutdown_api_events: list[BaseShutdownAPIEvent | None] | None = None,
         transmitted_api_data: BaseTransmittedAPIData = BaseTransmittedAPIData(),
@@ -641,8 +678,8 @@ def create_fastapi_app(
 
     setup_normal_logging(log_filepath=log_filepath)
 
-    if contact is None:
-        contact = DEFAULT_CONTACT
+    if handle_exception_ is None:
+        handle_exception_ = create_handle_exception()
 
     if not startup_api_events:
         startup_api_events = [BaseStartupAPIEvent()]
@@ -679,16 +716,10 @@ def create_fastapi_app(
 
     add_swagger_to_app(app=app)
 
-    if handle_exception_:
-        add_exception_handler_to_app(
-            app=app,
-            handle_exception=handle_exception_
-        )
-    else:
-        add_exception_handler_to_app(
-            app=app,
-            handle_exception=create_handle_exception()
-        )
+    add_exception_handler_to_app(
+        app=app,
+        handle_exception=handle_exception_
+    )
 
     add_needed_api_router_to_app(app=app)
 

arpakitlib/ar_file_util.py

@@ -1,5 +1,7 @@
 import os
 
+_ARPAKIT_LIB_MODULE_VERSION = "3.0"
+
 
 def raise_if_path_not_exists(path: str):
     if not os.path.exists(path):

arpakitlib/ar_func_util.py

@@ -0,0 +1,55 @@
+import asyncio
+import inspect
+from typing import Callable
+
+_ARPAKIT_LIB_MODULE_VERSION = "3.0"
+
+
+def is_async_function(func: Callable) -> bool:
+    return asyncio.iscoroutinefunction(func)
+
+
+def is_async_object(obj: object) -> bool:
+    return asyncio.iscoroutine(obj)
+
+
+def is_sync_function(func: Callable) -> bool:
+    return inspect.isfunction(func) and not is_async_function(func)
+
+
+def raise_if_not_async_func(func: Callable):
+    if not is_async_function(func):
+        raise TypeError(f"The provided function '{func.__name__}' is not an async function")
+
+
+def raise_if_not_sync_func(func: Callable):
+    if not is_sync_function(func):
+        raise TypeError(f"The provided function '{func.__name__}' is not a sync function")
+
+
+def raise_if_async_func(func: Callable):
+    if is_async_function(func):
+        raise TypeError(f"The provided function '{func.__name__}' should not be async")
+
+
+def raise_if_sync_func(func: Callable):
+    if is_sync_function(func):
+        raise TypeError(f"The provided function '{func.__name__}' should not be sync")
+
+
+def __example():
+    def one():
+        pass
+
+    async def two():
+        pass
+
+    print(is_sync_function(one))
+    print(is_sync_function(two))
+
+    print(is_async_function(one))
+    print(is_async_function(two))
+
+
+if __name__ == '__main__':
+    __example()

arpakitlib/ar_json_util.py

@@ -1,29 +1,31 @@
 # arpakit
 
 import json
-from typing import Union, Any
+from typing import Any
 
 _ARPAKIT_LIB_MODULE_VERSION = "3.0"
 
 
-def safely_transfer_to_json_obj(data: str) -> Union[dict, list]:
+def safely_transfer_str_to_json_obj(data: str) -> dict[Any, Any] | list[Any] | None:
     if not isinstance(data, str):
         raise ValueError("not isinstance(data, str)")
     return json.loads(data)
 
 
-def safely_transfer_to_json_str(data: Union[dict[str, Any], list[Any]]) -> str:
-    if not isinstance(data, dict) and not isinstance(data, list):
-        raise ValueError("not isinstance(data, dict) and not isinstance(data, list)")
+def safely_transfer_obj_to_json_str(data: dict[Any, Any] | list[Any] | None) -> str:
+    if not isinstance(data, dict) and not isinstance(data, list) and data is not None:
+        raise ValueError("not isinstance(data, dict) and not isinstance(data, list) and data is not None")
     return json.dumps(data, ensure_ascii=False, indent=2, default=str)
 
 
-def safely_transfer_to_json_str_to_json_obj(data: Union[dict[str, Any], list[Any]]) -> Union[dict, list]:
-    return safely_transfer_to_json_obj(safely_transfer_to_json_str(data))
+def safely_transfer_obj_to_json_str_to_json_obj(
+        data: dict[Any, Any] | list[Any] | None
+) -> dict[Any, Any] | list[Any] | None:
+    return safely_transfer_str_to_json_obj(safely_transfer_obj_to_json_str(data))
 
 
-def safely_transfer_to_json_obj_to_json_str(data: str) -> str:
-    return safely_transfer_to_json_str(safely_transfer_to_json_obj(data))
+def safely_transfer_str_to_json_obj_to_json_str(data: str) -> str:
+    return safely_transfer_obj_to_json_str(safely_transfer_str_to_json_obj(data))
 
 
 def __example():

arpakitlib/ar_need_type_util.py

@@ -56,7 +56,14 @@ def parse_need_type(value: Any, need_type: str, allow_none: bool = False) -> Any
 
 
 def __example():
-    pass
+    print(parse_need_type(value=123, need_type="int"))
+    print(parse_need_type(value="True", need_type="bool"))
+    print(parse_need_type(value=123.456, need_type="float"))
+    print(parse_need_type(value='[1, 2, 3]', need_type="list_of_int"))
+    print(parse_need_type(value='["a", "b", "c"]', need_type="list_of_str"))
+    print(parse_need_type(value='[1.1, 2.2, 3.3]', need_type="list_of_float"))
+    print(parse_need_type(value='{"key": "value"}', need_type="json"))
+    print(parse_need_type(value="hello world", need_type="str"))
 
 
 if __name__ == '__main__':

arpakitlib/ar_openai_api_client_util.py

@@ -49,11 +49,25 @@ class OpenAIAPIClient:
 
 
 def __example():
-    pass
+    open_ai = OpenAI(api_key="your-api-key")
+    client = OpenAIAPIClient(open_ai=open_ai)
+
+    print("Checking OpenAI API connection...")
+    if client.is_conn_good():
+        print("Connection to OpenAI API is good")
+    else:
+        print("Failed to connect to OpenAI API")
 
 
 async def __async_example():
-    pass
+    async_open_ai = AsyncOpenAI(api_key="your-api-key")
+    client = OpenAIAPIClient(async_open_ai=async_open_ai)
+
+    print("Checking OpenAI API async connection...")
+    if await client.async_is_conn_good():
+        print("Async connection to OpenAI API is good")
+    else:
+        print("Failed to async connect to OpenAI API")
 
 
 if __name__ == '__main__':