arpakitlib 1.6.47__py3-none-any.whl → 1.7.90__py3-none-any.whl

arpakitlib/_arpakit_project_template/manage/sandbox/sandbox_4.py

@@ -0,0 +1,14 @@
+import asyncio
+
+
+def command():
+    pass
+
+
+async def async_command():
+    pass
+
+
+if __name__ == '__main__':
+    command()
+    asyncio.run(async_command())

arpakitlib/_arpakit_project_template/manage/sandbox/sandbox_5.py

@@ -0,0 +1,14 @@
+import asyncio
+
+
+def command():
+    pass
+
+
+async def async_command():
+    pass
+
+
+if __name__ == '__main__':
+    command()
+    asyncio.run(async_command())

arpakitlib/_arpakit_project_template/manage/sandbox/sandbox_6.py

@@ -0,0 +1,14 @@
+import asyncio
+
+
+def command():
+    pass
+
+
+async def async_command():
+    pass
+
+
+if __name__ == '__main__':
+    command()
+    asyncio.run(async_command())

arpakitlib/_arpakit_project_template/manage/sandbox/sandbox_7.py

@@ -0,0 +1,14 @@
+import asyncio
+
+
+def command():
+    pass
+
+
+async def async_command():
+    pass
+
+
+if __name__ == '__main__':
+    command()
+    asyncio.run(async_command())

arpakitlib/_arpakit_project_template/manage/settings_check.py

@@ -0,0 +1,10 @@
+from arpakitlib.ar_json_util import safely_transfer_obj_to_json_str
+from src.core.settings import get_cached_settings
+
+
+def command():
+    print(safely_transfer_obj_to_json_str(get_cached_settings().model_dump(mode="json")))
+
+
+if __name__ == '__main__':
+    command()

arpakitlib/_arpakit_project_template/manage/settings_generate_env_example.py

@@ -0,0 +1,13 @@
+import os.path
+
+from src.core.const import BASE_DIRPATH
+from src.core.settings import Settings
+
+
+def command():
+    print(Settings.generate_env_example())
+    Settings.save_env_example_to_file(filepath=os.path.join(BASE_DIRPATH, "example.env"))
+
+
+if __name__ == '__main__':
+    command()

arpakitlib/_arpakit_project_template/manage/sqlalchemy_db_check_conn.py

@@ -0,0 +1,11 @@
+from src.core.util import setup_logging
+from src.db.util import get_cached_sqlalchemy_db
+
+
+def command():
+    setup_logging()
+    get_cached_sqlalchemy_db().check_conn()
+
+
+if __name__ == '__main__':
+    command()

arpakitlib/_arpakit_project_template/manage/sqlalchemy_db_init.py

@@ -0,0 +1,11 @@
+from src.core.util import setup_logging
+from src.db.util import get_cached_sqlalchemy_db
+
+
+def command():
+    setup_logging()
+    get_cached_sqlalchemy_db().init()
+
+
+if __name__ == '__main__':
+    command()

arpakitlib/_arpakit_project_template/manage/sqlalchemy_db_reinit.py

@@ -0,0 +1,11 @@
+from src.core.util import setup_logging
+from src.db.util import get_cached_sqlalchemy_db
+
+
+def command():
+    setup_logging()
+    get_cached_sqlalchemy_db().reinit()
+
+
+if __name__ == '__main__':
+    command()

arpakitlib/_arpakit_project_template/resource/static/healthcheck

@@ -0,0 +1 @@
+Healthcheck

arpakitlib/_arpakit_project_template/resource/static/helloworld

@@ -0,0 +1 @@
+HELLO WORLD

arpakitlib/_arpakit_project_template/src/additional_model/additional_model.py

@@ -0,0 +1,6 @@
+from arpakitlib.ar_additional_model_util import BaseAM
+
+
+class ExampleAM(BaseAM):
+    name: str = "Name"
+    surname: str = "Surname"

arpakitlib/_arpakit_project_template/src/api/asgi.py

@@ -0,0 +1,3 @@
+from src.api.create_api_app import create_api_app
+
+app = create_api_app()

arpakitlib/_arpakit_project_template/src/api/auth.py

@@ -0,0 +1 @@
+# ...

arpakitlib/_arpakit_project_template/src/api/const.py

@@ -0,0 +1,13 @@
+from arpakitlib.ar_fastapi_util import BaseAPIErrorCodes, BaseAPIErrorSpecificationCodes
+
+
+class APIErrorCodes(BaseAPIErrorCodes):
+    pass
+
+
+class APIErrorSpecificationCodes(BaseAPIErrorSpecificationCodes):
+    pass
+
+
+if __name__ == '__main__':
+    print(APIErrorCodes.str_for_print())

arpakitlib/_arpakit_project_template/src/api/create_api_app.py

@@ -0,0 +1,117 @@
+from fastapi import FastAPI
+
+from arpakitlib.ar_base_worker_util import SafeRunInBackgroundModes
+from arpakitlib.ar_fastapi_util import create_fastapi_app, InitSqlalchemyDBStartupAPIEvent, InitFileStoragesInDir, \
+    create_handle_exception, create_story_log_before_response_in_handle_exception, DEFAULT_CONTACT, \
+    SafeRunWorkerStartupAPIEvent
+from arpakitlib.ar_operation_execution_util import OperationExecutorWorker, ScheduledOperationCreatorWorker
+from arpakitlib.ar_sqlalchemy_util import SQLAlchemyDB
+from arpakitlib.ar_type_util import raise_for_type
+from src.api.event import StartupAPIEvent, ShutdownAPIEvent
+from src.api.router.main_router import main_api_router
+from src.api.transmitted_api_data import TransmittedAPIData
+from src.core.const import STATIC_DIRPATH
+from src.core.settings import get_cached_settings
+from src.core.util import get_cached_media_file_storage_in_dir, \
+    get_cached_cache_file_storage_in_dir, get_cached_dump_file_storage_in_dir, setup_logging
+from src.db.util import get_cached_sqlalchemy_db
+from src.operation_execution.operation_executor import OperationExecutor
+from src.operation_execution.scheduled_operations import ALL_SCHEDULED_OPERATIONS
+
+
+def create_api_app() -> FastAPI:
+    setup_logging()
+
+    settings = get_cached_settings()
+
+    sqlalchemy_db = get_cached_sqlalchemy_db() if settings.sql_db_url is not None else None
+
+    transmitted_api_data = TransmittedAPIData(
+        settings=settings,
+        sqlalchemy_db=sqlalchemy_db
+    )
+
+    funcs_before_response = []
+
+    if settings.api_create_story_log_before_response_in_handle_exception:
+        raise_for_type(sqlalchemy_db, SQLAlchemyDB)
+        funcs_before_response.append(
+            create_story_log_before_response_in_handle_exception(
+                sqlalchemy_db=sqlalchemy_db,
+                ignore_api_error_code_not_found=True
+            )
+        )
+
+    handle_exception = create_handle_exception(
+        funcs_before_response=funcs_before_response,
+        async_funcs_after_response=[]
+    )
+
+    startup_api_events = []
+
+    startup_api_events.append(InitFileStoragesInDir(
+        file_storages_in_dir=[
+            get_cached_media_file_storage_in_dir() if settings.media_dirpath is not None else None,
+            get_cached_cache_file_storage_in_dir() if settings.cache_dirpath is not None else None,
+            get_cached_dump_file_storage_in_dir() if settings.dump_dirpath is not None else None
+        ]
+    ))
+
+    if settings.api_init_sql_db_at_start:
+        raise_for_type(sqlalchemy_db, SQLAlchemyDB)
+        startup_api_events.append(InitSqlalchemyDBStartupAPIEvent(sqlalchemy_db=sqlalchemy_db))
+
+    startup_api_events.append(StartupAPIEvent(transmitted_api_data=transmitted_api_data))
+
+    if settings.api_start_operation_executor_worker:
+        raise_for_type(sqlalchemy_db, SQLAlchemyDB)
+        startup_api_events.append(
+            SafeRunWorkerStartupAPIEvent(
+                workers=[
+                    OperationExecutorWorker(
+                        sqlalchemy_db=sqlalchemy_db,
+                        operation_executor=OperationExecutor(sqlalchemy_db=sqlalchemy_db),
+                        filter_operation_types=None
+                    )
+                ],
+                safe_run_in_background_mode=SafeRunInBackgroundModes.async_task
+            )
+        )
+
+    if settings.api_start_scheduled_operation_creator_worker:
+        raise_for_type(sqlalchemy_db, SQLAlchemyDB)
+        startup_api_events.append(
+            SafeRunWorkerStartupAPIEvent(
+                workers=[
+                    ScheduledOperationCreatorWorker(
+                        sqlalchemy_db=sqlalchemy_db,
+                        scheduled_operations=ALL_SCHEDULED_OPERATIONS
+                    )
+                ],
+                safe_run_in_background_mode=SafeRunInBackgroundModes.async_task
+            )
+        )
+
+    shutdown_api_events = []
+
+    shutdown_api_events.append(ShutdownAPIEvent(transmitted_api_data=transmitted_api_data))
+
+    api_app = create_fastapi_app(
+        title=settings.api_title.strip(),
+        description=settings.api_description.strip(),
+        log_filepath=settings.log_filepath,
+        handle_exception_=handle_exception,
+        startup_api_events=startup_api_events,
+        shutdown_api_events=shutdown_api_events,
+        transmitted_api_data=transmitted_api_data,
+        main_api_router=main_api_router,
+        contact=DEFAULT_CONTACT,
+        media_dirpath=settings.media_dirpath,
+        static_dirpath=STATIC_DIRPATH
+    )
+
+    return api_app
+
+
+if __name__ == '__main__':
+    create_api_app()

arpakitlib/_arpakit_project_template/src/api/event.py

@@ -0,0 +1,20 @@
+from arpakitlib.ar_fastapi_util import BaseStartupAPIEvent, BaseShutdownAPIEvent
+from src.api.transmitted_api_data import TransmittedAPIData
+
+
+class StartupAPIEvent(BaseStartupAPIEvent):
+    def __init__(self, transmitted_api_data: TransmittedAPIData):
+        super().__init__()
+        self.transmitted_api_data = transmitted_api_data
+
+    async def async_on_startup(self, *args, **kwargs):
+        self._logger.info(self.__class__.__name__)
+
+
+class ShutdownAPIEvent(BaseShutdownAPIEvent):
+    def __init__(self, transmitted_api_data: TransmittedAPIData):
+        super().__init__()
+        self.transmitted_api_data = transmitted_api_data
+
+    async def async_on_shutdown(self, *args, **kwargs):
+        self._logger.info(self.__class__.__name__)

arpakitlib/_arpakit_project_template/src/api/router/main_router.py

@@ -0,0 +1,9 @@
+from fastapi import APIRouter
+
+from src.api.router.v1.main_router import main_v1_api_router
+
+main_api_router = APIRouter()
+main_api_router.include_router(
+    router=main_v1_api_router,
+    prefix="/api/v1"
+)

arpakitlib/_arpakit_project_template/src/api/router/v1/get_api_error_info.py

@@ -0,0 +1,27 @@
+import fastapi.requests
+from fastapi import APIRouter, Depends
+from starlette import status
+
+from arpakitlib.ar_fastapi_util import ErrorSO, get_transmitted_api_data
+from src.api.const import APIErrorCodes, APIErrorSpecificationCodes
+from src.api.schema.v1.out import APIErrorInfoSO
+from src.api.transmitted_api_data import TransmittedAPIData
+
+api_router = APIRouter()
+
+
+@api_router.get(
+    "",
+    response_model=APIErrorInfoSO | ErrorSO,
+    status_code=status.HTTP_200_OK
+)
+async def _(
+        *,
+        request: fastapi.requests.Request,
+        response: fastapi.responses.Response,
+        transmitted_api_data: TransmittedAPIData = Depends(get_transmitted_api_data)
+):
+    return APIErrorInfoSO(
+        api_error_codes=APIErrorCodes.values_list(),
+        api_error_specification_codes=APIErrorSpecificationCodes.values_list()
+    )

arpakitlib/_arpakit_project_template/src/api/router/v1/main_router.py

@@ -0,0 +1,11 @@
+from fastapi import APIRouter
+
+from src.api.router.v1 import get_api_error_info
+
+main_v1_api_router = APIRouter()
+
+main_v1_api_router.include_router(
+    router=get_api_error_info.api_router,
+    prefix="/get_api_error_info",
+    tags=["API Error Info"]
+)

arpakitlib/_arpakit_project_template/src/api/schema/v1/out.py

@@ -0,0 +1,6 @@
+from arpakitlib.ar_fastapi_util import BaseSO
+
+
+class APIErrorInfoSO(BaseSO):
+    api_error_codes: list[str] = []
+    api_error_specification_codes: list[str] = []

arpakitlib/_arpakit_project_template/src/api/start_api_for_dev.py

@@ -0,0 +1,17 @@
+import uvicorn
+
+from src.core.settings import get_cached_settings
+
+
+def start_api_for_dev(*, reload: bool = False):
+    uvicorn.run(
+        "src.api.asgi:app",
+        port=get_cached_settings().api_port,
+        host="localhost",
+        workers=1,
+        reload=reload
+    )
+
+
+if __name__ == '__main__':
+    start_api_for_dev(reload=False)

arpakitlib/_arpakit_project_template/src/api/start_api_for_dev_with_reload.py

@@ -0,0 +1,9 @@
+from src.api.start_api_for_dev import start_api_for_dev
+
+
+def command():
+    start_api_for_dev(reload=True)
+
+
+if __name__ == '__main__':
+    command()

arpakitlib/_arpakit_project_template/src/api/transmitted_api_data.py

@@ -0,0 +1,9 @@
+from arpakitlib.ar_fastapi_util import BaseTransmittedAPIData
+from arpakitlib.ar_sqlalchemy_util import SQLAlchemyDB
+
+from src.core.settings import Settings
+
+
+class TransmittedAPIData(BaseTransmittedAPIData):
+    settings: Settings
+    sqlalchemy_db: SQLAlchemyDB | None = None

arpakitlib/_arpakit_project_template/src/core/const.py

@@ -0,0 +1,48 @@
+import asyncio
+import os
+import pathlib
+
+BASE_DIRPATH: str = str(pathlib.Path(__file__).parent.parent.parent)
+
+ENV_FILENAME: str = ".env"
+
+ENV_FILEPATH: str = os.path.join(BASE_DIRPATH, ENV_FILENAME)
+
+SRC_DIRNAME: str = "src"
+
+SRC_DIRPATH: str = os.path.join(BASE_DIRPATH, SRC_DIRNAME)
+
+MANAGE_DIRNAME: str = "manage"
+
+MANAGE_DIRPATH: str = os.path.join(BASE_DIRPATH, MANAGE_DIRNAME)
+
+RESOURCE_DIRNAME: str = "resource"
+
+RESOURCE_DIRPATH: str = os.path.join(BASE_DIRPATH, RESOURCE_DIRNAME)
+
+STATIC_DIRNAME: str = "static"
+
+STATIC_DIRPATH: str = os.path.join(RESOURCE_DIRPATH, STATIC_DIRNAME)
+
+
+def __example():
+    print(f"BASE_DIRPATH: {BASE_DIRPATH}")
+    print(f"ENV_FILENAME: {ENV_FILENAME}")
+    print(f"ENV_FILEPATH: {ENV_FILEPATH}")
+    print(f"SRC_DIRNAME: {SRC_DIRNAME}")
+    print(f"SRC_DIRPATH: {SRC_DIRPATH}")
+    print(f"MANAGE_DIRNAME: {MANAGE_DIRNAME}")
+    print(f"MANAGE_DIRPATH: {MANAGE_DIRPATH}")
+    print(f"RESOURCE_DIRNAME: {RESOURCE_DIRNAME}")
+    print(f"RESOURCE_DIRPATH: {RESOURCE_DIRPATH}")
+    print(f"STATIC_DIRNAME: {STATIC_DIRNAME}")
+    print(f"STATIC_DIRPATH: {STATIC_DIRPATH}")
+
+
+async def __async_example():
+    pass
+
+
+if __name__ == '__main__':
+    __example()
+    asyncio.run(__async_example())

arpakitlib/_arpakit_project_template/src/core/settings.py

@@ -0,0 +1,86 @@
+import asyncio
+import os
+from functools import lru_cache
+from typing import Any
+
+import pytz
+
+from arpakitlib.ar_json_util import safely_transfer_obj_to_json_str
+from arpakitlib.ar_settings_util import SimpleSettings
+from src.core.const import BASE_DIRPATH, ENV_FILEPATH
+
+
+class Settings(SimpleSettings):
+    project_name: str = "{PROJECT_NAME}"
+
+    sql_db_url: str | None = (
+        "postgresql://{PROJECT_NAME}:{PROJECT_NAME}@127.0.0.1:{SQL_DB_PORT}/{PROJECT_NAME}"
+    ) if (str("{PROJECT_NAME}") and str("{SQL_DB_PORT}").strip().isdigit()) else None
+
+    sql_db_echo: bool = False
+
+    api_init_sql_db_at_start: bool = True
+
+    api_title: str = "{PROJECT_NAME}"
+
+    api_description: str = "{PROJECT_NAME} (arpakitlib)"
+
+    api_create_story_log_before_response_in_handle_exception: bool = True
+
+    api_start_operation_executor_worker: bool = False
+
+    api_start_scheduled_operation_creator_worker: bool = False
+
+    api_port: int | None = int("{API_PORT}") if "{API_PORT}".strip().isdigit() else None
+
+    api_correct_api_key: str | None = "1"
+
+    api_correct_token: str | None = "1"
+
+    var_dirname: str | None = "var"
+
+    var_dirpath: str | None = os.path.join(BASE_DIRPATH, var_dirname)
+
+    log_filename: str | None = "story.log"
+
+    log_filepath: str | None = os.path.join(var_dirpath, log_filename)
+
+    cache_dirname: str | None = "cache"
+
+    cache_dirpath: str | None = os.path.join(var_dirpath, cache_dirname)
+
+    media_dirname: str | None = "media"
+
+    media_dirpath: str | None = os.path.join(var_dirpath, media_dirname)
+
+    dump_dirname: str | None = "dump"
+
+    dump_dirpath: str | None = os.path.join(var_dirpath, dump_dirname)
+
+    local_timezone: str | None = None
+
+    @property
+    def local_timezone_as_pytz(self) -> Any:
+        return pytz.timezone(self.local_timezone)
+
+    # ...
+
+
+@lru_cache()
+def get_cached_settings() -> Settings:
+    if os.path.exists(ENV_FILEPATH):
+        return Settings(_env_file=ENV_FILEPATH, _env_file_encoding="utf-8")
+    return Settings()
+
+
+def __example():
+    print(safely_transfer_obj_to_json_str(get_cached_settings().model_dump(mode="json")))
+
+
+async def __async_example():
+    pass
+
+
+if __name__ == '__main__':
+    __example()
+    asyncio.run(__async_example())

arpakitlib/_arpakit_project_template/src/core/util.py

@@ -0,0 +1,58 @@
+import asyncio
+from datetime import datetime
+from functools import lru_cache
+
+from arpakitlib.ar_datetime_util import now_dt
+from arpakitlib.ar_file_storage_in_dir_util import FileStorageInDir
+from arpakitlib.ar_logging_util import setup_normal_logging
+from arpakitlib.ar_type_util import raise_if_none
+from src.core.settings import get_cached_settings
+
+
+def setup_logging():
+    setup_normal_logging(log_filepath=get_cached_settings().log_filepath)
+
+
+def create_cache_file_storage_in_dir() -> FileStorageInDir:
+    return FileStorageInDir(dirpath=get_cached_settings().cache_dirpath)
+
+
+@lru_cache()
+def get_cached_cache_file_storage_in_dir() -> FileStorageInDir:
+    return create_cache_file_storage_in_dir()
+
+
+def create_media_file_storage_in_dir() -> FileStorageInDir:
+    return FileStorageInDir(dirpath=get_cached_settings().media_dirpath)
+
+
+@lru_cache()
+def get_cached_media_file_storage_in_dir() -> FileStorageInDir:
+    return create_media_file_storage_in_dir()
+
+
+def create_dump_file_storage_in_dir() -> FileStorageInDir:
+    return FileStorageInDir(dirpath=get_cached_settings().dump_dirpath)
+
+
+@lru_cache()
+def get_cached_dump_file_storage_in_dir() -> FileStorageInDir:
+    return create_dump_file_storage_in_dir()
+
+
+def now_local_dt() -> datetime:
+    raise_if_none(get_cached_settings().local_timezone_as_pytz)
+    return now_dt(tz=get_cached_settings().local_timezone_as_pytz)
+
+
+def __example():
+    pass
+
+
+async def __async_example():
+    pass
+
+
+if __name__ == '__main__':
+    __example()
+    asyncio.run(__async_example())

arpakitlib/_arpakit_project_template/src/db/sqlalchemy_model.py

@@ -0,0 +1,8 @@
+from arpakitlib.ar_sqlalchemy_model_util import SimpleDBM
+from arpakitlib.ar_sqlalchemy_util import get_string_info_from_declarative_base
+
+# ...
+
+
+if __name__ == '__main__':
+    print(get_string_info_from_declarative_base(SimpleDBM))

arpakitlib/_arpakit_project_template/src/db/util.py

@@ -0,0 +1,21 @@
+import importlib
+from contextlib import suppress
+from functools import lru_cache
+
+from arpakitlib.ar_sqlalchemy_util import SQLAlchemyDB
+from src.core.settings import get_cached_settings
+
+
+def create_sqlalchemy_db() -> SQLAlchemyDB:
+    with suppress(Exception):
+        importlib.import_module("src.db.sqlalchemy_model")
+
+    return SQLAlchemyDB(
+        db_url=get_cached_settings().sql_db_url,
+        db_echo=get_cached_settings().sql_db_echo
+    )
+
+
+@lru_cache()
+def get_cached_sqlalchemy_db() -> SQLAlchemyDB:
+    return create_sqlalchemy_db()