arpakitlib 1.7.250__py3-none-any.whl → 1.7.252__py3-none-any.whl

arpakitlib/ar_fastapi_util.py

@@ -4,6 +4,7 @@ from __future__ import annotations
 
 import asyncio
 import datetime as dt
+import inspect
 import logging
 import os.path
 import pathlib
@@ -24,12 +25,14 @@ from starlette import status
 from starlette.middleware.cors import CORSMiddleware
 from starlette.staticfiles import StaticFiles
 
+from arpakitlib.ar_datetime_util import now_utc_dt
 from arpakitlib.ar_dict_util import combine_dicts
 from arpakitlib.ar_enumeration_util import Enumeration
 from arpakitlib.ar_exception_util import exception_to_traceback_str
+from arpakitlib.ar_file_storage_in_dir_util import FileStorageInDir
 from arpakitlib.ar_func_util import raise_if_not_async_func, is_async_object
 from arpakitlib.ar_json_util import safely_transfer_obj_to_json_str_to_json_obj, safely_transfer_obj_to_json_str
-from arpakitlib.ar_logging_util import setup_normal_logging
+from arpakitlib.ar_settings_util import SimpleSettings
 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_none
@@ -212,19 +215,20 @@ class APIException(fastapi.exceptions.HTTPException):
 
 def create_handle_exception(
         *,
-        funcs_before_response: list[Callable | None] | None = None,
-        async_funcs_after_response: list[Callable | None] | None = None,
+        funcs_before: list[Callable | None] | None = None,
+        async_funcs_after: list[Callable | None] | None = None,
 ) -> Callable:
-    if funcs_before_response is None:
-        funcs_before_response = []
-    funcs_before_response = [v for v in funcs_before_response if v is not None]
+    if funcs_before is None:
+        funcs_before = []
+    funcs_before = [v for v in funcs_before if v is not None]
 
-    if async_funcs_after_response is None:
-        async_funcs_after_response = []
-    async_funcs_after_response = [v for v in async_funcs_after_response if v is not None]
+    if async_funcs_after is None:
+        async_funcs_after = []
+    async_funcs_after = [v for v in async_funcs_after if v is not None]
 
-    async def handle_exception(
-            request: starlette.requests.Request, exception: Exception
+    async def func(
+            request: starlette.requests.Request,
+            exception: Exception
     ) -> APIJSONResponse:
         status_code = starlette.status.HTTP_500_INTERNAL_SERVER_ERROR
 
@@ -266,10 +270,10 @@ def create_handle_exception(
             status_code = starlette.status.HTTP_500_INTERNAL_SERVER_ERROR
             error_so.error_code = BaseAPIErrorCodes.unknown_error
 
-        if error_so.error_code:
+        if error_so.error_code is not None:
             error_so.error_code = error_so.error_code.upper().replace(" ", "_").strip()
 
-        if error_so.error_specification_code:
+        if error_so.error_specification_code is not None:
             error_so.error_specification_code = (
                 error_so.error_specification_code.upper().replace(" ", "_").strip()
             )
@@ -280,23 +284,29 @@ def create_handle_exception(
         if error_so.error_code == BaseAPIErrorCodes.cannot_authorize:
             status_code = status.HTTP_401_UNAUTHORIZED
 
-        _kwargs = {}
-        for func in funcs_before_response:
-            _func_data = func(
-                status_code=status_code, error_so=error_so, request=request, exception=exception, **_kwargs
+        error_so.error_data["status_code"] = status_code
+
+        # funcs_before
+
+        _transmitted_kwargs = {}
+        for func_before in funcs_before:
+            _func_data = func_before(
+                request=request, status_code=status_code, error_so=error_so, exception=exception,
+                transmitted_kwargs=_transmitted_kwargs
             )
             if is_async_object(_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]
-                raise_for_type(status_code, int)
+                error_so, _transmitted_kwargs = _func_data[0], _func_data[1]
                 raise_for_type(error_so, ErrorSO)
-                raise_for_type(_kwargs, dict)
+                raise_for_type(_transmitted_kwargs, dict)
+
+        # async_funcs_after
 
-        for async_func_after_response in async_funcs_after_response:
-            raise_if_not_async_func(async_func_after_response)
-            _ = asyncio.create_task(async_func_after_response(
-                error_so=error_so, status_code=status_code, request=request, exception=exception
+        for async_func_after in async_funcs_after:
+            raise_if_not_async_func(async_func_after)
+            _ = asyncio.create_task(async_func_after(
+                request=request, status_code=status_code, error_so=error_so, exception=exception
             ))
 
         return APIJSONResponse(
@@ -304,43 +314,46 @@ def create_handle_exception(
             status_code=status_code
         )
 
-    return handle_exception
+    return func
 
 
-def logging_func_before_response(
+def logging__api_func_before_in_handle_exception(
         *,
         ignore_api_error_codes: list[str] | None = None,
         ignore_status_codes: list[int] | None = None,
         ignore_exception_types: list[type[Exception]] | None = None,
         need_exc_info: bool = False
-):
+) -> Callable:
+    current_func_name = inspect.currentframe().f_code.co_name
+
     def func(
             *,
+            request: starlette.requests.Request,
             status_code: int,
             error_so: ErrorSO,
-            request: starlette.requests.Request,
             exception: Exception,
+            transmitted_kwargs: dict[str, Any],
             **kwargs
-    ) -> (int, ErrorSO, dict[str, Any]):
-        kwargs["logging_before_response_in_handle_exception"] = True
+    ) -> (ErrorSO, dict[str, Any]):
+        transmitted_kwargs[current_func_name] = now_utc_dt()
 
         if ignore_api_error_codes and error_so.error_code in ignore_api_error_codes:
-            return status_code, error_so, kwargs
+            return error_so, transmitted_kwargs
 
         if ignore_status_codes and status_code in ignore_status_codes:
-            return status_code, error_so, kwargs
+            return error_so, transmitted_kwargs
 
         if ignore_exception_types and (
                 exception in ignore_exception_types or type(exception) in ignore_exception_types
         ):
-            return status_code, error_so, kwargs
+            return error_so, transmitted_kwargs
 
         _logger.error(safely_transfer_obj_to_json_str(error_so.model_dump()), exc_info=need_exc_info)
 
     return func
 
 
-def story_log_func_before_response(
+def story_log__api_func_before_in_handle_exception(
         *,
         sqlalchemy_db: SQLAlchemyDB,
         ignore_api_error_codes: list[str] | None = None,
@@ -349,26 +362,29 @@ def story_log_func_before_response(
 ) -> Callable:
     raise_for_type(sqlalchemy_db, SQLAlchemyDB)
 
+    current_func_name = inspect.currentframe().f_code.co_name
+
     async def async_func(
             *,
+            request: starlette.requests.Request,
             status_code: int,
             error_so: ErrorSO,
-            request: starlette.requests.Request,
             exception: Exception,
+            transmitted_kwargs: dict[str, Any],
             **kwargs
-    ) -> (int, ErrorSO, dict[str, Any]):
-        kwargs["create_story_log_before_response_in_handle_exception"] = True
+    ) -> (ErrorSO, dict[str, Any]):
+        transmitted_kwargs[current_func_name] = now_utc_dt()
 
         if ignore_api_error_codes and error_so.error_code in ignore_api_error_codes:
-            return status_code, error_so, kwargs
+            return error_so, transmitted_kwargs
 
         if ignore_status_codes and status_code in ignore_status_codes:
-            return status_code, error_so, kwargs
+            return error_so, transmitted_kwargs
 
         if ignore_exception_types and (
                 exception in ignore_exception_types or type(exception) in ignore_exception_types
         ):
-            return status_code, error_so, kwargs
+            return error_so, transmitted_kwargs
 
         async with sqlalchemy_db.new_async_session() as session:
             story_log_dbm = StoryLogDBM(
@@ -384,9 +400,9 @@ def story_log_func_before_response(
             await session.refresh(story_log_dbm)
 
         error_so.error_data.update({"story_log_long_id": story_log_dbm.long_id})
-        kwargs["story_log_id"] = story_log_dbm.id
+        transmitted_kwargs["story_log_id"] = story_log_dbm.id
 
-        return status_code, error_so, kwargs
+        return error_so, transmitted_kwargs
 
     return async_func
 
@@ -463,7 +479,7 @@ class ARPAKITLibSO(BaseSO):
     arpakitlib: bool = True
 
 
-def add_needed_api_router_to_app(*, app: FastAPI):
+def create_needed_api_router():
     api_router = APIRouter()
 
     @api_router.get(
@@ -490,9 +506,7 @@ def add_needed_api_router_to_app(*, app: FastAPI):
             content=ARPAKITLibSO(arpakitlib=True)
         )
 
-    app.include_router(router=api_router, prefix="")
-
-    return app
+    return api_router
 
 
 class BaseStartupAPIEvent:
@@ -517,6 +531,17 @@ class BaseTransmittedAPIData(BaseModel):
     model_config = ConfigDict(extra="ignore", arbitrary_types_allowed=True, from_attributes=True)
 
 
+class SimpleTransmittedAPIData(BaseTransmittedAPIData):
+    settings: SimpleSettings | None = None
+
+
+class AdvancedTransmittedAPIData(SimpleTransmittedAPIData):
+    sqlalchemy_db: SQLAlchemyDB | None = None
+    media_file_storage_in_dir: FileStorageInDir | None = None
+    cache_file_storage_in_dir: FileStorageInDir | None = None
+    dump_file_storage_in_dir: FileStorageInDir | None = None
+
+
 def get_transmitted_api_data(request: starlette.requests.Request) -> BaseTransmittedAPIData:
     return request.app.state.transmitted_api_data
 
@@ -574,7 +599,9 @@ def base_api_auth(
             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)),
+            api_key_string: str | None = Security(
+                APIKeyHeader(name="apikey", auto_error=False)
+            ),
             request: starlette.requests.Request,
             transmitted_api_data: BaseTransmittedAPIData = Depends(get_transmitted_api_data)
     ) -> BaseAPIAuthData:
@@ -586,7 +613,7 @@ def base_api_auth(
             require_correct_token=require_correct_token
         )
 
-        # api_key
+        # parse api_key
 
         api_auth_data.api_key_string = api_key_string
 
@@ -604,7 +631,7 @@ def base_api_auth(
         if not api_auth_data.api_key_string and "apikey" in request.query_params.keys():
             api_auth_data.api_key_string = request.query_params["apikey"]
 
-        # token
+        # parse token
 
         api_auth_data.token_string = ac.credentials if ac and ac.credentials and ac.credentials.strip() else None
 
@@ -633,7 +660,7 @@ def base_api_auth(
         if not api_auth_data.token_string:
             api_auth_data.token_string = None
 
-        # api_key
+        # require_api_key_string
 
         if require_api_key_string and not api_auth_data.api_key_string:
             raise APIException(
@@ -642,7 +669,7 @@ def base_api_auth(
                 error_data=safely_transfer_obj_to_json_str_to_json_obj(api_auth_data.model_dump())
             )
 
-        # token
+        # require_token_string
 
         if require_token_string and not api_auth_data.token_string:
             raise APIException(
@@ -651,10 +678,10 @@ def base_api_auth(
                 error_data=safely_transfer_obj_to_json_str_to_json_obj(api_auth_data.model_dump())
             )
 
-        # api_key
+        # validate_api_key_func
 
         if validate_api_key_func is not None:
-            validate_api_key_func_data = validate_api_key_func(
+            validate_api_key_func_res = 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,
@@ -662,14 +689,14 @@ def base_api_auth(
                 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_correct = validate_api_key_func_data
+            if is_async_object(validate_api_key_func_res):
+                validate_api_key_func_res = await validate_api_key_func_res
+            api_auth_data.is_api_key_correct = validate_api_key_func_res
 
-        # token
+        # validate_token_func
 
         if validate_token_func is not None:
-            validate_token_func_data = validate_token_func(
+            validate_token_func_res = 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,
@@ -677,11 +704,11 @@ def base_api_auth(
                 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_correct = validate_token_func_data_data
+            if is_async_object(validate_token_func_res):
+                validate_token_func_res = await validate_token_func_res
+            api_auth_data.is_token_correct = validate_token_func_res
 
-        # api_key
+        # require_correct_api_key
 
         if require_correct_api_key:
             if not api_auth_data.is_api_key_correct:
@@ -692,7 +719,7 @@ def base_api_auth(
                     error_data=safely_transfer_obj_to_json_str_to_json_obj(api_auth_data.model_dump()),
                 )
 
-        # token
+        # require_correct_token
 
         if require_correct_token:
             if not api_auth_data.is_token_correct:
@@ -750,7 +777,6 @@ def create_fastapi_app(
         *,
         title: str = "arpakitlib FastAPI",
         description: str | None = "arpakitlib FastAPI",
-        log_filepath: str | None = "./story.log",
         handle_exception_: Callable | None = None,
         startup_api_events: list[BaseStartupAPIEvent | None] | None = None,
         shutdown_api_events: list[BaseShutdownAPIEvent | None] | None = None,
@@ -760,12 +786,14 @@ def create_fastapi_app(
         media_dirpath: str | None = None,
         static_dirpath: str | None = None
 ):
-    _logger.info("start create_fastapi_app")
-
-    setup_normal_logging(log_filepath=log_filepath)
+    _logger.info("start")
 
     if handle_exception_ is None:
-        handle_exception_ = create_handle_exception()
+        handle_exception_ = create_handle_exception(
+            funcs_before=[
+                logging__api_func_before_in_handle_exception()
+            ]
+        )
 
     if not startup_api_events:
         startup_api_events = [BaseStartupAPIEvent()]
@@ -807,11 +835,14 @@ def create_fastapi_app(
         handle_exception=handle_exception_
     )
 
-    add_needed_api_router_to_app(app=app)
+    app.include_router(
+        router=create_needed_api_router(),
+        prefix=""
+    )
 
     app.include_router(router=main_api_router)
 
-    _logger.info("finish create_fastapi_app")
+    _logger.info("finish")
 
     return app
 

arpakitlib/ar_schedule_uust_api_client_util.py

@@ -43,6 +43,30 @@ class ScheduleUUSTAPIClient:
             )
         }
 
+    async def _async_make_http_request(
+            self,
+            *,
+            method: str = "GET",
+            url: str,
+            params: dict[str, Any] | None = None,
+            **kwargs
+    ) -> ClientResponse:
+        response = await async_make_http_request(
+            method=method,
+            url=url,
+            headers=self.headers,
+            params=combine_dicts(params, self.auth_params()),
+            max_tries_=9,
+            proxy_url_=self.api_proxy_url,
+            raise_for_status_=True,
+            timeout_=timedelta(seconds=15),
+            **kwargs
+        )
+        json_data = await response.json()
+        if "error" in json_data.keys():
+            raise Exception(f"error in json_data, {json_data}")
+        return response
+
     def auth_params(self) -> dict[str, Any]:
         if self.api_password:
             return {
@@ -72,30 +96,6 @@ class ScheduleUUSTAPIClient:
     def generate_v2_token(self) -> str:
         return self.generate_new_v2_token(password_first_part=self.api_password_first_part)
 
-    async def _async_make_http_request(
-            self,
-            *,
-            method: str = "GET",
-            url: str,
-            params: dict[str, Any] | None = None,
-            **kwargs
-    ) -> ClientResponse:
-        response = await async_make_http_request(
-            method=method,
-            url=url,
-            headers=self.headers,
-            params=combine_dicts(params, self.auth_params()),
-            max_tries_=9,
-            proxy_url_=self.api_proxy_url,
-            raise_for_status_=True,
-            timeout_=timedelta(seconds=15),
-            **kwargs
-        )
-        json_data = await response.json()
-        if "error" in json_data.keys():
-            raise Exception(f"error in json_data, {json_data}")
-        return response
-
     async def get_current_week(self) -> int:
         """
         response.json example

arpakitlib/ar_settings_util.py

@@ -1,12 +1,16 @@
 # arpakit
-
+import os
 from typing import Union, Any
 
+import pytz
 from pydantic import ConfigDict, field_validator, model_validator
 from pydantic_core import PydanticUndefined
+from pydantic_core.core_schema import ValidationInfo
 from pydantic_settings import BaseSettings
 
 from arpakitlib.ar_enumeration_util import Enumeration
+from arpakitlib.ar_json_util import safely_transfer_obj_to_json_str
+from arpakitlib.ar_sqlalchemy_util import generate_sqlalchemy_url
 
 _ARPAKIT_LIB_MODULE_VERSION = "3.0"
 
@@ -26,11 +30,9 @@ class ModeTypes(Enumeration):
     prod: str = "prod"
 
 
-class SimpleSettings(BaseSettings):
+class BaseSettings2(BaseSettings):
     model_config = ConfigDict(extra="ignore")
 
-    mode_type: str = ModeTypes.not_prod
-
     @model_validator(mode="before")
     @classmethod
     def validate_all_fields(cls, values: dict[str, Any]) -> dict[str, Any]:
@@ -39,6 +41,21 @@ class SimpleSettings(BaseSettings):
                 values[key] = None
         return values
 
+    @classmethod
+    def generate_env_example(cls) -> str:
+        return generate_env_example(settings_class=cls)
+
+    @classmethod
+    def save_env_example_to_file(cls, filepath: str) -> str:
+        env_example = cls.generate_env_example()
+        with open(filepath, mode="w") as f:
+            f.write(env_example)
+        return env_example
+
+
+class SimpleSettings(BaseSettings2):
+    mode_type: str = ModeTypes.not_prod
+
     @field_validator("mode_type")
     @classmethod
     def validate_mode_type(cls, v: str):
@@ -61,20 +78,155 @@ class SimpleSettings(BaseSettings):
         if self.is_mode_type_prod:
             raise ValueError(f"mode type = {self.mode_type}")
 
-    @classmethod
-    def generate_env_example(cls) -> str:
-        return generate_env_example(settings_class=cls)
 
-    @classmethod
-    def save_env_example_to_file(cls, filepath: str) -> str:
-        env_example = cls.generate_env_example()
-        with open(filepath, mode="w") as f:
-            f.write(env_example)
-        return env_example
+class AdvancedSettings(SimpleSettings):
+    project_name: str | None = None
+
+    sql_db_user: str | None = None
+
+    @field_validator("sql_db_user", mode="after")
+    def validate_sql_db_user(cls, v: Any, validation_info: ValidationInfo, **kwargs) -> str | None:
+        if v is not None:
+            return v
+        res = validation_info.data.get("project_name")
+        if res is not None:
+            return res
+        return res
+
+    sql_db_password: str | None = None
+
+    @field_validator("sql_db_password", mode="after")
+    def validate_sql_db_password(cls, v: Any, validation_info: ValidationInfo, **kwargs) -> str | None:
+        if v is not None:
+            return v
+        res = validation_info.data.get("project_name")
+        if res is not None:
+            return res
+        return res
+
+    sql_db_port: int | None = int("50506") if "50506".strip().isdigit() else None
+
+    sql_db_database: str | None = None
+
+    @field_validator("sql_db_database", mode="after")
+    def validate_sql_db_database(cls, v: Any, validation_info: ValidationInfo, **kwargs) -> str | None:
+        if v is not None:
+            return v
+        res = validation_info.data.get("project_name")
+        if res is not None:
+            return res
+        return res
+
+    sync_sql_db_url: str | None = None
+
+    @field_validator("sync_sql_db_url", mode="after")
+    def validate_sync_sql_db_url(cls, v: Any, validation_info: ValidationInfo, **kwargs) -> str | None:
+        if v is not None:
+            return v
+
+        return generate_sqlalchemy_url(
+            base="postgresql+asyncpg",
+            user=validation_info.data.get("sql_db_user"),
+            password=validation_info.data.get("sql_db_password"),
+            port=validation_info.data.get("sql_db_port"),
+            database=validation_info.data.get("sql_db_database")
+        )
+
+    async_sql_db_url: str | None = None
+
+    @field_validator("async_sql_db_url", mode="after")
+    def validate_async_sql_db_url(cls, v: Any, validation_info: ValidationInfo, **kwargs) -> str | None:
+        if v is not None:
+            return v
+
+        return generate_sqlalchemy_url(
+            base="postgresql+asyncpg",
+            user=validation_info.data.get("sql_db_user"),
+            password=validation_info.data.get("sql_db_password"),
+            port=validation_info.data.get("sql_db_port"),
+            database=validation_info.data.get("sql_db_database")
+        )
+
+    sql_db_echo: bool = False
+
+    api_port: int | None = None
+
+    @field_validator("api_port", mode="before")
+    def validate_api_port(cls, v: Any, validation_info: ValidationInfo, **kwargs) -> int | None:
+        if isinstance(v, str):
+            if v.isdigit():
+                return int(v)
+        return None
+
+    api_init_sql_db_at_start: bool = True
+
+    api_logging__api_func_before_in_handle_exception: bool = True
+
+    api_story_log__api_func_before_in_handle_exception: bool = True
+
+    api_correct_api_key: str | None = "1"
+
+    api_correct_token: str | None = "1"
+
+    api_enable_admin1: bool = True
+
+    admin1_secret_key: str | None = "85a9583cb91c4de7a78d7eb1e5306a04418c9c43014c447ea8ec8dd5deb4cf71"
+
+    var_dirpath: str | None = "./var"
+
+    log_filepath: str | None = None
+
+    @field_validator("log_filepath", mode="after")
+    def validate_log_filepath(cls, v: Any, validation_info: ValidationInfo, **kwargs) -> str | None:
+        if v is not None:
+            return v
+        var_dirpath = validation_info.data.get("var_dirpath")
+        if var_dirpath is None:
+            return None
+        return os.path.join(var_dirpath, "story.log")
+
+    cache_dirpath: str | None = None
+
+    @field_validator("cache_dirpath", mode="after")
+    def validate_cache_dirpath(cls, v: Any, validation_info: ValidationInfo, **kwargs) -> str | None:
+        if v is not None:
+            return v
+        var_dirpath = validation_info.data.get("var_dirpath")
+        if var_dirpath is None:
+            return None
+        return os.path.join(var_dirpath, "cache")
+
+    media_dirpath: str | None = None
+
+    @field_validator("media_dirpath", mode="after")
+    def validate_media_dirpath(cls, v: Any, validation_info: ValidationInfo, **kwargs) -> str | None:
+        if v is not None:
+            return v
+        var_dirpath = validation_info.data.get("var_dirpath")
+        if var_dirpath is None:
+            return None
+        return os.path.join(var_dirpath, "media")
+
+    dump_dirpath: str | None = None
+
+    @field_validator("dump_dirpath", mode="after")
+    def validate_dump_dirpath(cls, v: Any, validation_info: ValidationInfo, **kwargs) -> str | None:
+        if v is not None:
+            return v
+        var_dirpath = validation_info.data.get("var_dirpath")
+        if var_dirpath is None:
+            return None
+        return os.path.join(var_dirpath, "dump")
+
+    local_timezone: str | None = None
+
+    @property
+    def local_timezone_as_pytz(self) -> Any:
+        return pytz.timezone(self.local_timezone)
 
 
 def __example():
-    pass
+    print(safely_transfer_obj_to_json_str(AdvancedSettings(var_dirpath="./var").model_dump(mode="json")))
 
 
 if __name__ == '__main__':

arpakitlib/ar_sqlalchemy_model_util.py

@@ -67,7 +67,7 @@ class BaseDBM(DeclarativeBase):
 
         return res
 
-    def simple_dict_with_sd_properties(self) -> dict[str ,Any]:
+    def simple_dict_with_sd_properties(self) -> dict[str, Any]:
         return self.simple_dict(include_sd_properties=True)
 
     def simple_json(self, *, include_sd_properties: bool = True) -> str: