arpakitlib 1.4.0__py3-none-any.whl

arpakitlib/ar_fastapi_util.py

@@ -0,0 +1,294 @@
+import asyncio
+import logging
+import os.path
+import pathlib
+from typing import Any, Callable
+
+import fastapi.exceptions
+import fastapi.responses
+import starlette.exceptions
+import starlette.requests
+import starlette.status
+from fastapi import FastAPI
+from fastapi.openapi.docs import get_swagger_ui_html, get_redoc_html
+from pydantic import BaseModel, ConfigDict
+from starlette.middleware.cors import CORSMiddleware
+from starlette.staticfiles import StaticFiles
+
+from arpakitlib.ar_enumeration import EasyEnumeration
+
+_ARPAKIT_LIB_MODULE_VERSION = "3.0"
+
+_logger = logging.getLogger(__name__)
+
+
+class BaseAPISchema(BaseModel):
+    model_config = ConfigDict(extra="ignore", arbitrary_types_allowed=True, from_attributes=True)
+    _bus_data: dict[str, Any] = {}
+
+    @classmethod
+    def __pydantic_init_subclass__(cls, **kwargs: Any) -> None:
+        if not (
+                cls.__name__.endswith("SO")
+                or cls.__name__.endswith("SI")
+                or cls.__name__.endswith("SchemaIn")
+                or cls.__name__.endswith("SchemaOut")
+        ):
+            raise ValueError("APISchema class should ends with SO | SI | SchemaIn | SchemaOut")
+        super().__init_subclass__(**kwargs)
+
+
+class BaseAPISI(BaseAPISchema):
+    pass
+
+
+class BaseAPISO(BaseAPISchema):
+    pass
+
+
+class APIJSONResponse(fastapi.responses.JSONResponse):
+    def __init__(self, *, content: BaseAPISO, status_code: int = starlette.status.HTTP_200_OK):
+        super().__init__(
+            content=content.model_dump(mode="json"),
+            status_code=status_code
+        )
+
+
+class APIErrorSO(BaseAPISO):
+    class ErrorCodes(EasyEnumeration):
+        cannot_authorize = "CANNOT_AUTHORIZE"
+        unknown_error = "UNKNOWN_ERROR"
+        error_in_request = "ERROR_IN_REQUEST"
+        not_found = "NOT_FOUND"
+
+    has_error: bool = True
+    error_code: str | None = None
+    error_code_specification: str | None = None
+    error_description: str | None = None
+    error_data: dict[str, Any] = {}
+
+
+class APIException(fastapi.exceptions.HTTPException):
+    def __init__(
+            self,
+            *,
+            status_code: int = starlette.status.HTTP_400_BAD_REQUEST,
+            error_code: str | None = APIErrorSO.ErrorCodes.unknown_error,
+            error_code_specification: str | None = None,
+            error_description: str | None = None,
+            error_data: dict[str, Any] | None = None
+    ):
+        self.status_code = status_code
+        self.error_code = error_code
+        self.error_code_specification = error_code_specification
+        self.error_description = error_description
+        if error_data is None:
+            error_data = {}
+        self.error_data = error_data
+
+        self.easy_api_error_so = APIErrorSO(
+            has_error=True,
+            error_code=self.error_code,
+            error_specification=self.error_code_specification,
+            error_description=self.error_description,
+            error_data=self.error_data
+        )
+
+        super().__init__(
+            status_code=self.status_code,
+            detail=self.easy_api_error_so.model_dump(mode="json")
+        )
+
+
+def simple_api_handle_exception(request: starlette.requests.Request, exception: Exception) -> APIJSONResponse:
+    return from_exception_to_api_json_response(request=request, exception=exception)
+
+
+def from_exception_to_api_json_response(
+        request: starlette.requests.Request, exception: Exception
+) -> APIJSONResponse:
+    easy_api_error_so = APIErrorSO(
+        has_error=True,
+        error_code=APIErrorSO.ErrorCodes.unknown_error
+    )
+
+    status_code = starlette.status.HTTP_500_INTERNAL_SERVER_ERROR
+
+    if isinstance(exception, APIException):
+        easy_api_error_so = exception.easy_api_error_so
+
+    elif isinstance(exception, starlette.exceptions.HTTPException):
+        status_code = exception.status_code
+        if status_code in (starlette.status.HTTP_403_FORBIDDEN, starlette.status.HTTP_401_UNAUTHORIZED):
+            easy_api_error_so.error_code = APIErrorSO.ErrorCodes.cannot_authorize
+        elif status_code == starlette.status.HTTP_404_NOT_FOUND:
+            easy_api_error_so.error_code = APIErrorSO.ErrorCodes.not_found
+        else:
+            easy_api_error_so.error_code = APIErrorSO.ErrorCodes.unknown_error
+        if (
+                isinstance(exception.detail, dict)
+                or isinstance(exception.detail, list)
+                or isinstance(exception.detail, str)
+                or isinstance(exception.detail, int)
+                or isinstance(exception.detail, float)
+                or isinstance(exception.detail, bool)
+        ):
+            easy_api_error_so.error_data["raw"] = exception.detail
+
+    elif isinstance(exception, fastapi.exceptions.RequestValidationError):
+        status_code = starlette.status.HTTP_422_UNPROCESSABLE_ENTITY
+        easy_api_error_so.error_code = APIErrorSO.ErrorCodes.error_in_request
+        easy_api_error_so.error_data["raw"] = str(exception.errors()) if exception.errors() else {}
+
+    else:
+        status_code = starlette.status.HTTP_500_INTERNAL_SERVER_ERROR
+        easy_api_error_so.error_code = APIErrorSO.ErrorCodes.unknown_error
+        easy_api_error_so.error_data["raw"] = str(exception)
+        _logger.exception(exception)
+
+    if easy_api_error_so.error_code:
+        easy_api_error_so.error_code = easy_api_error_so.error_code.upper().replace(" ", "_").strip()
+
+    if easy_api_error_so.error_code_specification:
+        easy_api_error_so.error_code_specification = (
+            easy_api_error_so.error_code_specification.upper().replace(" ", "_").strip()
+        )
+
+    return APIJSONResponse(
+        content=easy_api_error_so,
+        status_code=status_code
+    )
+
+
+def add_exception_handler_to_fastapi_app(*, fastapi_app: FastAPI, api_handle_exception_: Callable) -> FastAPI:
+    fastapi_app.add_exception_handler(
+        exc_class_or_status_code=Exception,
+        handler=api_handle_exception_
+    )
+    fastapi_app.add_exception_handler(
+        exc_class_or_status_code=ValueError,
+        handler=api_handle_exception_
+    )
+    fastapi_app.add_exception_handler(
+        exc_class_or_status_code=fastapi.exceptions.RequestValidationError,
+        handler=api_handle_exception_
+    )
+    fastapi_app.add_exception_handler(
+        exc_class_or_status_code=starlette.exceptions.HTTPException,
+        handler=api_handle_exception_
+    )
+    return fastapi_app
+
+
+def add_middleware_cors_to_fastapi_app(*, fastapi_app: FastAPI) -> FastAPI:
+    fastapi_app.add_middleware(
+        CORSMiddleware,
+        allow_origins=["*"],
+        allow_credentials=True,
+        allow_methods=["*"],
+        allow_headers=["*"],
+    )
+    return fastapi_app
+
+
+def add_ar_fastapi_static_to_fastapi_app(*, fastapi_app: FastAPI):
+    ar_fastapi_static_dirpath = os.path.join(str(pathlib.Path(__file__).parent), "ar_fastapi_static")
+    fastapi_app.mount(
+        "/ar_fastapi_static",
+        StaticFiles(directory=ar_fastapi_static_dirpath),
+        name="ar_fastapi_static"
+    )
+
+
+def add_ar_fastapi_static_docs_and_redoc_handlers_to_fastapi_app(
+        *,
+        fastapi_app: FastAPI,
+        favicon_url: str | None = None
+):
+    add_ar_fastapi_static_to_fastapi_app(fastapi_app=fastapi_app)
+
+    @fastapi_app.get("/docs", include_in_schema=False)
+    async def custom_swagger_ui_html():
+        return get_swagger_ui_html(
+            openapi_url=fastapi_app.openapi_url,
+            title=fastapi_app.title,
+            swagger_js_url="/ar_fastapi_static/swagger-ui/swagger-ui-bundle.js",
+            swagger_css_url="/ar_fastapi_static/swagger-ui/swagger-ui.css",
+            swagger_favicon_url=favicon_url
+        )
+
+    @fastapi_app.get("/redoc", include_in_schema=False)
+    async def custom_redoc_html():
+        return get_redoc_html(
+            openapi_url=fastapi_app.openapi_url,
+            title=fastapi_app.title,
+            redoc_js_url="/ar_fastapi_static/redoc/redoc.standalone.js",
+            redoc_favicon_url=favicon_url
+        )
+
+    return fastapi_app
+
+
+class BaseAPIStartupEvent:
+    def __init__(self, *args, **kwargs):
+        self._logger = logging.getLogger(self.__class__.__name__)
+
+    async def on_startup(self, *args, **kwargs):
+        self._logger.info("on_startup")
+
+
+class BaseAPIShutdownEvent:
+    def __init__(self, *args, **kwargs):
+        self._logger = logging.getLogger(self.__class__.__name__)
+
+    async def on_startup(self, *args, **kwargs):
+        self._logger.info("on_startup")
+
+
+def create_fastapi_app(
+        *,
+        title: str,
+        description: str | None = None,
+        api_startup_event: BaseAPIStartupEvent | None = None,
+        api_shutdown_event: BaseAPIShutdownEvent | None = None,
+        api_handle_exception_: Callable | None = simple_api_handle_exception
+):
+    app = FastAPI(
+        title=title,
+        description=description,
+        docs_url=None,
+        redoc_url=None,
+        openapi_url="/openapi",
+        on_startup=[api_startup_event.on_startup] if api_startup_event else [],
+        on_shutdown=[api_shutdown_event.on_startup] if api_shutdown_event else []
+    )
+
+    add_middleware_cors_to_fastapi_app(fastapi_app=app)
+
+    add_ar_fastapi_static_docs_and_redoc_handlers_to_fastapi_app(fastapi_app=app)
+
+    if api_handle_exception_:
+        add_exception_handler_to_fastapi_app(
+            fastapi_app=app,
+            api_handle_exception_=api_handle_exception_
+        )
+    else:
+        add_exception_handler_to_fastapi_app(
+            fastapi_app=app,
+            api_handle_exception_=simple_api_handle_exception
+        )
+
+    return app
+
+
+def __example():
+    pass
+
+
+async def __async_example():
+    pass
+
+
+if __name__ == '__main__':
+    __example()
+    asyncio.run(__async_example())

arpakitlib/ar_file_storage_in_dir.py

@@ -0,0 +1,127 @@
+import logging
+import os
+import shutil
+import uuid
+from typing import Optional, Union, Iterator
+
+_ARPAKIT_LIB_MODULE_VERSION = "3.0"
+
+
+class FileStorageInDir:
+
+    def __init__(self, dirpath: str):
+        if not isinstance(dirpath, str):
+            raise TypeError("not isinstance(dirpath, str)")
+        self.dirpath = os.path.abspath(dirpath)
+        self._logger = logging.getLogger(self.__class__.__name__)
+
+    def __str__(self) -> str:
+        return self.dirpath
+
+    def __repr__(self) -> str:
+        return self.dirpath
+
+    def __len__(self) -> int:
+        return len(os.listdir(self.dirpath))
+
+    def __iter__(self) -> Iterator[str]:
+        self.init()
+        for path in self.get_paths():
+            yield path
+
+    def init(self):
+        if not os.path.exists(self.dirpath):
+            os.makedirs(self.dirpath, exist_ok=True)
+
+    def reinit(self):
+        if os.path.exists(self.dirpath):
+            shutil.rmtree(self.dirpath)
+        self.init()
+
+    def get_paths(self) -> list[str]:
+        return [os.path.join(self.dirpath, path) for path in os.listdir(self.dirpath)]
+
+    def generate_filepath(
+            self,
+            *,
+            filename: Optional[str] = None,
+            file_extension: Optional[str] = None,
+            content_to_write: Optional[Union[str, bytes]] = None,
+            create: bool = False,
+            raise_if_exists: bool = True
+    ) -> str:
+        self.init()
+
+        if filename is not None:
+            if file_extension is not None:
+                filename += f".{file_extension}"
+        else:
+            filename = str(uuid.uuid4())
+            if file_extension is not None:
+                filename += f".{file_extension}"
+            while filename in os.listdir(self.dirpath):
+                filename = str(uuid.uuid4())
+                if file_extension is not None:
+                    filename += f".{file_extension}"
+
+        if raise_if_exists and filename in os.listdir(self.dirpath):
+            raise ValueError(f"file ({filename}) already exists")
+
+        filepath = os.path.join(self.dirpath, filename)
+
+        if create is True:
+            content_to_write = ""
+
+        if isinstance(content_to_write, str):
+            content_to_write = content_to_write.encode()
+        if isinstance(content_to_write, bytes):
+            with open(filepath, mode="wb") as f:
+                f.write(content_to_write)
+
+        return filepath
+
+    def generate_dirpath(
+            self, *, dirname: Optional[str] = None, create: bool = True, raise_if_exists: bool = True
+    ) -> str:
+        self.init()
+
+        if dirname is None:
+            dirname = str(uuid.uuid4())
+            while dirname in os.listdir(self.dirpath):
+                dirname = str(uuid.uuid4())
+
+        if raise_if_exists and dirname in os.listdir(self.dirpath):
+            raise ValueError(f"dir ({dirname}) already exists")
+
+        dirpath = os.path.join(self.dirpath, dirname)
+
+        if create:
+            os.mkdir(dirpath)
+
+        return dirpath
+
+    def rm_by_filepath(self, filepath: str):
+        if os.path.exists(filepath):
+            os.remove(filepath)
+
+    def rm_by_filename(self, filename: str):
+        filepath = os.path.join(self.dirpath, filename)
+        if os.path.exists(filepath):
+            os.remove(filepath)
+
+    def rm_by_dirpath(self, dirpath: str):
+        if os.path.exists(dirpath):
+            shutil.rmtree(dirpath)
+
+    def rm_by_dirname(self, dirname: str):
+        dirpath = os.path.join(self.dirpath, dirname)
+        if os.path.exists(dirpath):
+            shutil.rmtree(dirpath)
+
+
+def __example():
+    pass
+
+
+if __name__ == '__main__':
+    __example()

arpakitlib/ar_generate_env_example.py

@@ -0,0 +1,16 @@
+from typing import Union
+
+from pydantic_settings import BaseSettings
+
+_ARPAKIT_LIB_MODULE_VERSION = "3.0"
+
+
+def generate_env_example(settings_class: Union[BaseSettings, type[BaseSettings]]):
+    res = ""
+    for k in settings_class.model_fields:
+        res += f"{k}=\n"
+    return res
+
+
+def __example():
+    pass

arpakitlib/ar_hash_util.py

@@ -0,0 +1,19 @@
+import hashlib
+
+_ARPAKIT_LIB_MODULE_VERSION = "3.0"
+
+
+def hash_string(string: str) -> str:
+    return hashlib.sha256(string.encode()).hexdigest()
+
+
+def check_string_hash(string: str, string_hash: str) -> bool:
+    return hash_string(string) == string_hash
+
+
+def __example():
+    pass
+
+
+if __name__ == '__main__':
+    __example()

arpakitlib/ar_http_request_util.py

@@ -0,0 +1,75 @@
+import asyncio
+import inspect
+import logging
+from datetime import timedelta
+
+import aiohttp
+import requests
+
+from arpakitlib.ar_safe_sleep import safe_sleep
+
+_ARPAKIT_LIB_MODULE_VERSION = "3.0"
+
+
+def sync_make_request(*, method: str, url: str, **kwargs) -> requests.Response:
+    _logger = logging.getLogger(inspect.currentframe().f_code.co_name)
+
+    max_tries = 7
+    tries = 0
+
+    kwargs["method"] = method
+    kwargs["url"] = url
+    if "timeout" not in kwargs:
+        kwargs["timeout"] = (timedelta(seconds=15).total_seconds(), timedelta(seconds=15).total_seconds())
+
+    while True:
+        tries += 1
+        _logger.info(f"{method} {url}")
+        try:
+            return requests.request(**kwargs)
+        except Exception as err:
+            _logger.warning(f"{tries}/{max_tries} {method} {url} {err}")
+            if tries >= max_tries:
+                raise Exception(err)
+            safe_sleep(timedelta(seconds=0.1).total_seconds())
+            continue
+
+
+async def async_make_request(*, method: str, url: str, **kwargs) -> aiohttp.ClientResponse:
+    _logger = logging.getLogger(inspect.currentframe().f_code.co_name)
+
+    max_tries = 7
+    tries = 0
+
+    kwargs["method"] = method
+    kwargs["url"] = url
+    if "timeout" not in kwargs:
+        kwargs["timeout"] = aiohttp.ClientTimeout(total=timedelta(seconds=15).total_seconds())
+
+    while True:
+        tries += 1
+        _logger.info(f"{method} {url}")
+        try:
+            async with aiohttp.ClientSession() as session:
+                async with session.request(**kwargs) as response:
+                    await response.read()
+                    return response
+        except Exception as err:
+            _logger.warning(f"{tries}/{max_tries} {method} {url} {err}")
+            if tries >= max_tries:
+                raise Exception(err)
+            await asyncio.sleep(timedelta(seconds=0.1).total_seconds())
+            continue
+
+
+def __example():
+    pass
+
+
+async def __async_example():
+    pass
+
+
+if __name__ == '__main__':
+    __example()
+    asyncio.run(__async_example())

arpakitlib/ar_ip_util.py

@@ -0,0 +1,50 @@
+import ipaddress
+
+_ARPAKIT_LIB_MODULE_VERSION = "3.0"
+
+
+def is_ipv4_address(value: str) -> bool:
+    try:
+        ipaddress.IPv4Address(value)
+    except ValueError:
+        return False
+    return True
+
+
+def raise_if_not_ipv4_address(value: str):
+    if not is_ipv4_address(value):
+        raise ValueError(f"not is_ipv4_address({value})")
+
+
+def is_ipv6_address(value: str) -> bool:
+    try:
+        ipaddress.IPv6Address(value)
+    except ValueError:
+        return False
+    return True
+
+
+def raise_if_not_ipv6_address(value: str):
+    if not is_ipv6_address(value):
+        raise ValueError(f"not is_ipv6_address({value})")
+
+
+def is_ipv4_interface(value: str) -> bool:
+    try:
+        ipaddress.IPv4Interface(value)
+    except ValueError:
+        return False
+    return True
+
+
+def raise_if_not_ipv4_interface(value: str):
+    if not is_ipv4_interface(value):
+        raise ValueError(f"not is_ipv4_interface({value})")
+
+
+def __example():
+    pass
+
+
+if __name__ == '__main__':
+    __example()