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

arpakitlib/ar_base_worker_util.py

@@ -2,91 +2,138 @@
 
 import asyncio
 import logging
+import multiprocessing
+import threading
 from abc import ABC
 from datetime import timedelta
+from typing import Any
 
+from arpakitlib.ar_enumeration_util import Enumeration
+from arpakitlib.ar_func_util import is_async_function, is_sync_function
 from arpakitlib.ar_sleep_util import sync_safe_sleep, async_safe_sleep
 
 _ARPAKIT_LIB_MODULE_VERSION = "3.0"
 
 
 class BaseWorker(ABC):
-
-    def __init__(self):
+    def __init__(
+            self,
+            *,
+            timeout_after_run=timedelta(seconds=0.1),
+            timeout_after_err_in_run=timedelta(seconds=1),
+            startup_funcs: list[Any] | None = None
+    ):
+        if startup_funcs is None:
+            startup_funcs = []
+        self.startup_funcs = startup_funcs
         self.worker_name = self.__class__.__name__
         self._logger = logging.getLogger(self.worker_name)
-        self.timeout_after_run = timedelta(seconds=0.1).total_seconds()
-        self.timeout_after_err_in_run = timedelta(seconds=1).total_seconds()
+        self.timeout_after_run = timeout_after_run.total_seconds()
+        self.timeout_after_err_in_run = timeout_after_err_in_run.total_seconds()
+
+    def sync_run_startup_funcs(self):
+        for startup_func in self.startup_funcs:
+            if is_async_function(startup_func):
+                asyncio.run(startup_func())
+            elif is_sync_function(startup_func):
+                startup_func()
+            else:
+                raise TypeError("no sync and not async")
 
     def sync_on_startup(self):
         pass
 
     def sync_run(self):
-        raise NotImplementedError()
+        self._logger.info("hello world")
 
     def sync_run_on_error(self, exception: BaseException, **kwargs):
-        self._logger.exception(exception)
+        pass
 
     def sync_safe_run(self):
-        self._logger.info(f"start sync_safe_run")
-
-        self._logger.info("start sync_on_startup ")
-        self.sync_on_startup()
-        self._logger.info("finish sync_on_startup")
-
+        self._logger.info("start")
+        try:
+            self.sync_on_startup()
+        except BaseException as exception:
+            self._logger.error("error in sync_on_startup", exc_info=exception)
+            raise exception
         while True:
-
             try:
-
-                self._logger.info("start sync_run")
                 self.sync_run()
-                self._logger.info("finish sync_run")
-
-                if self.timeout_after_run is not None:
-                    sync_safe_sleep(self.timeout_after_run)
-
             except BaseException as exception:
-
-                self._logger.info("start sync_run_on_error")
-                self.sync_run_on_error(exception=exception)
-                self._logger.info("start sync_run_on_error")
-
-                if self.timeout_after_err_in_run is not None:
-                    sync_safe_sleep(self.timeout_after_err_in_run)
+                self._logger.error("error in sync_run", exc_info=exception)
+                try:
+                    self.sync_run_on_error(exception=exception)
+                except BaseException as exception_:
+                    self._logger.error("error in sync_run_on_error", exc_info=exception_)
+                    raise exception_
+            if self.timeout_after_run is not None:
+                sync_safe_sleep(self.timeout_after_run)
+
+    async def async_run_startup_funcs(self):
+        for startup_func in self.startup_funcs:
+            if is_async_function(startup_func):
+                await startup_func()
+            elif is_sync_function(startup_func):
+                startup_func()
+            else:
+                raise TypeError("no sync and not async")
 
     async def async_on_startup(self):
         pass
 
     async def async_run(self):
-        raise NotImplementedError()
+        self._logger.info("hello world")
 
     async def async_run_on_error(self, exception: BaseException, **kwargs):
-        self._logger.exception(exception)
+        pass
 
     async def async_safe_run(self):
-        self._logger.info(f"start async_safe_run")
-
-        self._logger.info("start async_on_startup")
-        await self.async_on_startup()
-        self._logger.info("start async_on_startup")
-
+        self._logger.info("start async_safe_run")
+        try:
+            await self.async_on_startup()
+        except BaseException as exception:
+            self._logger.error("error in async_on_startup", exc_info=exception)
+            raise exception
         while True:
-
             try:
-
                 await self.async_run()
-
-                if self.timeout_after_run is not None:
-                    await async_safe_sleep(self.timeout_after_run)
-
             except BaseException as exception:
-
-                self._logger.info("start async_run_on_error")
-                await self.async_run_on_error(exception=exception)
-                self._logger.info("finish async_run_on_error")
-
-                if self.timeout_after_err_in_run is not None:
-                    await async_safe_sleep(self.timeout_after_err_in_run)
+                self._logger.error("error in async_run", exc_info=exception)
+                try:
+                    await self.async_run_on_error(exception=exception)
+                except BaseException as exception_:
+                    self._logger.error("error in async_run_on_error", exc_info=exception_)
+                    raise exception_
+            if self.timeout_after_err_in_run is not None:
+                await async_safe_sleep(self.timeout_after_err_in_run)
+
+
+class SafeRunInBackgroundModes(Enumeration):
+    async_task = "async_task"
+    thread = "thread"
+    process = "process"
+
+
+def safe_run_worker_in_background(*, worker: BaseWorker, mode: str) -> (
+        asyncio.Task | threading.Thread | multiprocessing.Process
+):
+    if mode == SafeRunInBackgroundModes.async_task:
+        res: asyncio.Task = asyncio.create_task(worker.async_safe_run())
+    elif mode == SafeRunInBackgroundModes.thread:
+        res: threading.Thread = threading.Thread(
+            target=worker.sync_safe_run,
+            daemon=True
+        )
+        res.start()
+    elif mode == SafeRunInBackgroundModes.process:
+        res: multiprocessing.Process = multiprocessing.Process(
+            target=worker.sync_safe_run,
+            daemon=True
+        )
+        res.start()
+    else:
+        raise ValueError(f"unknown safe_run_mode={mode}")
+    return res
 
 
 def __example():

arpakitlib/ar_dream_ai_api_client_util.py

@@ -2,16 +2,14 @@
 
 import asyncio
 import logging
-from datetime import timedelta
+from typing import Any
 from urllib.parse import urljoin
 
-import aiohttp
-from aiohttp import ClientResponseError, ClientResponse, ClientTimeout
+from aiohttp import ClientResponse
 from pydantic import ConfigDict, BaseModel
 
 from arpakitlib.ar_base64_util import convert_base64_string_to_bytes
-from arpakitlib.ar_json_util import safely_transfer_to_json_str
-from arpakitlib.ar_sleep_util import async_safe_sleep
+from arpakitlib.ar_http_request_util import async_make_http_request
 
 _ARPAKIT_LIB_MODULE_VERSION = "3.0"
 
@@ -19,9 +17,6 @@ _ARPAKIT_LIB_MODULE_VERSION = "3.0"
 class BaseAPIModel(BaseModel):
     model_config = ConfigDict(extra="forbid", arbitrary_types_allowed=True, from_attributes=True)
 
-    def simple_json(self) -> str:
-        return safely_transfer_to_json_str(self.model_dump(mode="json"))
-
 
 class GenerateImageFromNumberResApiModel(BaseAPIModel):
     image_filename: str
@@ -34,12 +29,12 @@ class GenerateImageFromNumberResApiModel(BaseAPIModel):
         return filepath
 
 
-class DreamAIAPIClient:
+class DREAMAIAPIClient:
     def __init__(
             self,
             *,
-            base_url: str = "https://api.dream_ai.arpakit.com/api/v1",
-            api_key: str | None = None
+            base_url: str = "https://api.dreamai.arpakit.com/api/v1",
+            api_key: str | None = "1"
     ):
         self._logger = logging.getLogger(__name__)
         self.api_key = api_key
@@ -51,60 +46,39 @@ class DreamAIAPIClient:
         if api_key is not None:
             self.headers.update({"apikey": api_key})
 
-    async def _async_make_request(self, *, method: str = "GET", url: str, **kwargs) -> ClientResponse:
-        max_tries = 7
-        tries = 0
-
-        kwargs["url"] = url
-        kwargs["method"] = method
-        kwargs["timeout"] = ClientTimeout(total=timedelta(seconds=15).total_seconds())
-        kwargs["headers"] = self.headers
-
-        while True:
-            tries += 1
-            self._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:
-                self._logger.warning(f"{tries}/{max_tries} {err} {method} {url}")
-                if tries >= max_tries:
-                    raise err
-                await async_safe_sleep(timedelta(seconds=0.1).total_seconds())
-                continue
+    async def _async_make_http_request(
+            self,
+            *,
+            method: str = "GET",
+            url: str,
+            params: dict[str, Any] | None = None
+    ) -> ClientResponse:
+        response = await async_make_http_request(
+            method=method,
+            url=url,
+            params=params,
+            headers=self.headers,
+        )
+        response.raise_for_status()
+        return response
 
     async def healthcheck(self) -> bool:
-        response = await self._async_make_request(method="GET", url=urljoin(self.base_url, "healthcheck"))
-        response.raise_for_status()
+        response = await self._async_make_http_request(method="GET", url=urljoin(self.base_url, "healthcheck"))
         json_data = await response.json()
-        return json_data["data"]["healthcheck"]
+        return json_data["data"]["healthcheck"] == "healthcheck"
 
     async def is_healthcheck_good(self) -> bool:
         try:
             return await self.healthcheck()
-        except ClientResponseError:
-            return False
-
-    async def auth_healthcheck(self) -> bool:
-        response = await self._async_make_request(method="GET", url=urljoin(self.base_url, "auth_healthcheck"))
-        response.raise_for_status()
-        json_data = await response.json()
-        return json_data["data"]["auth_healthcheck"]
-
-    async def is_auth_healthcheck_good(self) -> bool:
-        try:
-            return await self.auth_healthcheck()
-        except ClientResponseError:
+        except Exception as exception:
+            self._logger.error(exception)
             return False
 
     async def generate_image_from_number(self, *, number: int) -> GenerateImageFromNumberResApiModel:
-        response = await self._async_make_request(
+        response = await self._async_make_http_request(
             method="GET", url=urljoin(self.base_url, "generate_image_from_number"),
             params={"number": number}
         )
-        response.raise_for_status()
         json_data = await response.json()
         return GenerateImageFromNumberResApiModel.model_validate(json_data)
 

arpakitlib/ar_enumeration_util.py

@@ -69,6 +69,17 @@ class Enumeration:
     def parse_and_validate_values(cls, *values: ValuesForParseType) -> list[ValueType]:
         return cls.parse_values(*values, validate=True)
 
+    @classmethod
+    def str_for_print(cls) -> str:
+        res = f"{cls.__name__} (len={len(cls.values_list())})"
+        for v in cls.values_list():
+            res += f"\n- {v}"
+        return res.strip()
+
+    @classmethod
+    def print(cls):
+        print(cls.str_for_print())
+
 
 def __example():
     pass

arpakitlib/ar_exception_util.py

@@ -0,0 +1,18 @@
+import traceback
+
+_ARPAKIT_LIB_MODULE_VERSION = "3.0"
+
+
+def exception_to_traceback_str(exception: BaseException) -> str:
+    return "".join(traceback.format_exception(type(exception), exception, exception.__traceback__))
+
+
+def __example():
+    try:
+        raise Exception()
+    except Exception as exception:
+        print(exception_to_traceback_str(exception))
+
+
+if __name__ == '__main__':
+    __example()

arpakitlib/ar_fastapi_static/healthcheck

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