arpakitlib 1.4.0__py3-none-any.whl

arpakitlib/ar_base64_util.py

@@ -0,0 +1,30 @@
+import base64
+from typing import Optional
+
+_ARPAKIT_LIB_MODULE_VERSION = "3.0"
+
+
+def convert_base64_string_to_bytes(base64_string: str, raise_for_error: bool = False) -> Optional[bytes]:
+    try:
+        return base64.b64decode(base64_string)
+    except Exception as e:
+        if raise_for_error:
+            raise e
+        return None
+
+
+def convert_bytes_to_base64_string(bytes_: bytes, raise_for_error: bool = False) -> Optional[str]:
+    try:
+        return base64.b64encode(bytes_).decode()
+    except Exception as e:
+        if raise_for_error:
+            raise e
+        return None
+
+
+def __example():
+    pass
+
+
+if __name__ == '__main__':
+    __example()

arpakitlib/ar_base_worker.py

@@ -0,0 +1,77 @@
+import asyncio
+import logging
+from abc import ABC
+from datetime import timedelta
+from typing import Any
+
+from arpakitlib.ar_safe_sleep import safe_sleep
+
+_ARPAKIT_LIB_MODULE_VERSION = "3.0"
+
+
+class BaseWorker(ABC):
+
+    def __init__(self):
+        self.worker_name = self.__class__.__name__
+        self._logger = logging.getLogger(self.worker_name)
+        self.timeout_after_run: float | None = timedelta(seconds=15).total_seconds()
+        self.timeout_after_err_in_run: float | None = timedelta(seconds=15).total_seconds()
+
+    def sync_on_startup(self):
+        self._logger.info("sync_on_startup")
+
+    def sync_run(self):
+        raise NotImplementedError()
+
+    def sync_run_on_error(self, exception: BaseException, kwargs: dict[str, Any]):
+        self._logger.info("sync_run_on_error")
+        self._logger.exception(exception)
+
+    def safe_sync_run(self):
+        self._logger.info(f"safe_sync_run")
+        self.sync_on_startup()
+        while True:
+            try:
+                self.sync_run()
+                if self.timeout_after_run is not None:
+                    safe_sleep(self.timeout_after_run)
+            except BaseException as exception:
+                self.sync_run_on_error(exception=exception, kwargs={})
+                if self.timeout_after_err_in_run is not None:
+                    safe_sleep(self.timeout_after_err_in_run)
+
+    async def async_on_startup(self):
+        self._logger.info("async_on_startup")
+
+    async def async_run(self):
+        raise NotImplementedError()
+
+    async def async_run_on_error(self, exception: BaseException, kwargs: dict[str, Any]):
+        self._logger.info("async_run_on_error")
+        self._logger.exception(exception)
+
+    async def async_safe_run(self):
+        self._logger.info(f"async_safe_run")
+        await self.async_on_startup()
+        while True:
+            try:
+                await self.async_run()
+                if self.timeout_after_run is not None:
+                    await asyncio.sleep(self.timeout_after_run)
+            except BaseException as exception:
+                await self.async_run_on_error(exception=exception, kwargs={})
+                if self.timeout_after_err_in_run is not None:
+                    await asyncio.sleep(self.timeout_after_err_in_run)
+
+
+def __example():
+    pass
+
+
+async def __async_example():
+    pass
+
+
+if __name__ == '__main__':
+    __example()
+    asyncio.run(__async_example())

arpakitlib/ar_cache_file.py

@@ -0,0 +1,124 @@
+import logging
+from datetime import datetime
+from typing import Optional, Any
+
+import pytz
+from pydantic import BaseModel
+
+from arpakitlib.ar_json_db import JSONDbFile
+from arpakitlib.ar_type_util import raise_for_type
+
+_ARPAKIT_LIB_MODULE_VERSION = "3.0"
+
+
+class CacheBlock(BaseModel):
+    key: str
+    data: Any
+    last_update_dt: datetime
+
+
+class CacheFile:
+
+    def __init__(self, *, json_db_file: JSONDbFile):
+        self.json_db_file = json_db_file
+        self._logger = logging.getLogger(self.__class__.__name__)
+
+    def __len__(self) -> int:
+        return self.json_db_file.count_records()
+
+    def __str__(self) -> str:
+        return f"CacheFile ({self.json_db_file.filepath}) ({self.json_db_file.count_records()})"
+
+    def __repr__(self) -> str:
+        return f"CacheFile ({self.json_db_file.filepath}) ({self.json_db_file.count_records()})"
+
+    def create_block(
+            self,
+            *,
+            key: str,
+            data: Any,
+            last_update_dt: Optional[datetime] = None
+    ) -> CacheBlock:
+        raise_for_type(key, str)
+
+        if last_update_dt is None:
+            last_update_dt = datetime.now(tz=pytz.UTC)
+        raise_for_type(last_update_dt, datetime)
+        last_update_dt = last_update_dt.astimezone(tz=pytz.UTC)
+
+        _, record = self.json_db_file.create_record(
+            record_id=key,
+            record={
+                "data": data,
+                "last_update_dt": last_update_dt.isoformat()
+            }
+        )
+
+        return CacheBlock(
+            key=key,
+            data=record["data"],
+            last_update_dt=datetime.fromisoformat(record["last_update_dt"])
+        )
+
+    def get_block(self, key: str) -> Optional[CacheBlock]:
+        raise_for_type(key, str)
+
+        record = self.json_db_file.get_record(record_id=key)
+        if record is None:
+            return None
+
+        return CacheBlock(
+            key=key,
+            data=record["data"],
+            last_update_dt=datetime.fromisoformat(record["last_update_dt"])
+        )
+
+    def get_blocks(self) -> list[CacheBlock]:
+        return [
+            CacheBlock(
+                key=record_id,
+                data=record["data"],
+                last_update_dt=datetime.fromisoformat(record["last_update_dt"])
+            )
+            for record_id, record in self.json_db_file.get_records()
+        ]
+
+    def update_block(
+            self,
+            *,
+            key: str,
+            data: Optional[dict[str, Any]] = None,
+            last_update_dt: Optional[datetime] = None
+    ) -> CacheBlock:
+        raise_for_type(key, str)
+        record = self.json_db_file.get_record(record_id=key)
+        if record is None:
+            raise ValueError(f"block (key='{key}') not exists")
+
+        if data is not None:
+            raise_for_type(data, dict)
+            record["data"] = data
+
+        if last_update_dt is not None:
+            raise_for_type(last_update_dt, datetime)
+            last_update_dt = last_update_dt.astimezone(tz=pytz.UTC)
+            record["last_update_dt"] = last_update_dt.isoformat()
+
+        self.json_db_file.update_record(record_id=key, record=record)
+
+        return self.get_block(key=key)
+
+    def remove_block(self, key: str):
+        raise_for_type(key, str)
+        self.json_db_file.rm_record(record_id=key)
+
+    def remove_blocks(self):
+        self.json_db_file.rm_all_records()
+
+
+def __example():
+    pass
+
+
+if __name__ == '__main__':
+    __example()

arpakitlib/ar_datetime_util.py

@@ -0,0 +1,38 @@
+from datetime import datetime, date
+
+import pytz
+
+from arpakitlib.ar_type_util import raise_for_type
+
+_ARPAKIT_LIB_MODULE_VERSION = "3.0"
+
+
+def convert_dt_tz(dt: datetime, tz_info):
+    return dt.astimezone(tz_info)
+
+
+def convert_dt_tz_to_utc(dt: datetime):
+    return convert_dt_tz(dt=dt, tz_info=pytz.UTC)
+
+
+def now_utc_dt() -> datetime:
+    return datetime.now(tz=pytz.UTC)
+
+
+def birth_date_to_age(*, birth_date: date, raise_if_age_negative: bool = False) -> int:
+    raise_for_type(birth_date, date)
+    now_utc_dt_date = now_utc_dt().date()
+    res = now_utc_dt_date.year - birth_date.year
+    if (now_utc_dt_date.month, now_utc_dt_date.day) < (birth_date.month, birth_date.day):
+        res -= 1
+    if raise_if_age_negative and res < 0:
+        raise ValueError("raise_if_negative and res < 0")
+    return res
+
+
+def __example():
+    pass
+
+
+if __name__ == '__main__':
+    __example()

arpakitlib/ar_dict_util.py

@@ -0,0 +1,24 @@
+from typing import Any
+
+_ARPAKIT_LIB_MODULE_VERSION = "3.0"
+
+
+def combine_dicts(*dicts: dict) -> dict:
+    res = {}
+    for dict_ in dicts:
+        res.update(dict_)
+    return res
+
+
+def replace_dict_key(*, dict_: dict, old_key: Any, new_key: Any):
+    if old_key in dict_:
+        dict_[new_key] = dict_.pop(old_key)
+    return dict_
+
+
+def __example():
+    pass
+
+
+if __name__ == '__main__':
+    __example()

arpakitlib/ar_dream_ai_api_client.py

@@ -0,0 +1,120 @@
+import asyncio
+import logging
+from asyncio import sleep
+from datetime import timedelta
+from urllib.parse import urljoin
+
+import aiohttp
+from aiohttp import ClientResponseError, ClientResponse, ClientTimeout
+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
+
+_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
+    image_url: str
+    image_base64: str
+
+    def save_file(self, filepath: str):
+        with open(filepath, mode="wb") as f:
+            f.write(convert_base64_string_to_bytes(base64_string=self.image_base64))
+        return filepath
+
+
+class DreamAIAPIClient:
+    def __init__(
+            self,
+            *,
+            base_url: str = "https://api.dream_ai.arpakit.com/api/v1",
+            api_key: str | None = None
+    ):
+        self._logger = logging.getLogger(__name__)
+        self.api_key = api_key
+        base_url = base_url.strip()
+        if not base_url.endswith("/"):
+            base_url += "/"
+        self.base_url = base_url
+        self.headers = {"Content-Type": "application/json"}
+        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 sleep(timedelta(seconds=0.1).total_seconds())
+                continue
+
+    async def healthcheck(self) -> bool:
+        response = await self._async_make_request(method="GET", url=urljoin(self.base_url, "healthcheck"))
+        response.raise_for_status()
+        json_data = await response.json()
+        return json_data["data"]["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:
+            return False
+
+    async def generate_image_from_number(self, *, number: int) -> GenerateImageFromNumberResApiModel:
+        response = await self._async_make_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)
+
+
+def __example():
+    pass
+
+
+async def __async_example():
+    pass
+
+
+if __name__ == '__main__':
+    __example()
+    asyncio.run(__async_example())

arpakitlib/ar_encrypt_and_decrypt_util.py

@@ -0,0 +1,23 @@
+from cryptography.fernet import Fernet
+
+_ARPAKIT_LIB_MODULE_VERSION = "3.0"
+
+
+def generate_secret_key() -> str:
+    return Fernet.generate_key().decode()
+
+
+def encrypt_with_secret_key(string: str, secret_key: str) -> str:
+    return Fernet(secret_key.encode()).encrypt(string.encode()).decode()
+
+
+def decrypt_with_secret_key(string: str, secret_key: str) -> str:
+    return Fernet(secret_key.encode()).decrypt(string.encode()).decode()
+
+
+def __example():
+    pass
+
+
+if __name__ == '__main__':
+    __example()

arpakitlib/ar_enumeration.py

@@ -0,0 +1,76 @@
+from typing import Union, Iterator, Iterable
+
+_ARPAKIT_LIB_MODULE_VERSION = "3.0"
+
+ValueType = Union[int, str]
+ValuesForParseType = Union[ValueType, Iterable[ValueType]]
+
+
+class EasyEnumeration:
+    @classmethod
+    def iter_values(cls) -> Iterator[ValueType]:
+        big_dict = {}
+        for class_ in reversed(cls.mro()):
+            big_dict.update(class_.__dict__)
+        big_dict.update(cls.__dict__)
+
+        keys = list(big_dict.keys())
+
+        for key in keys:
+
+            if not isinstance(key, str):
+                continue
+
+            if key.startswith("__") or key.endswith("__"):
+                continue
+
+            value = big_dict[key]
+            if type(value) not in [str, int]:
+                continue
+
+            yield value
+
+    @classmethod
+    def values_set(cls) -> set[ValueType]:
+        return set(cls.iter_values())
+
+    @classmethod
+    def values_list(cls) -> list[ValueType]:
+        return list(cls.iter_values())
+
+    @classmethod
+    def parse_values(cls, *values: ValuesForParseType, validate: bool = False) -> list[ValueType]:
+        res = []
+
+        for value in values:
+
+            if isinstance(value, str) or isinstance(value, int):
+                if validate is True and value not in cls.values_set():
+                    raise ValueError(f"validate is True and {value} not in {cls.values_set()}")
+                res.append(value)
+
+            elif isinstance(value, Iterable):
+                for value_ in value:
+                    if isinstance(value_, str) or isinstance(value_, int):
+                        if validate is True and value_ not in cls.values_set():
+                            raise ValueError(f"validate is True and {value_} not in {cls.values_set()}")
+                        res.append(value_)
+                    else:
+                        raise TypeError(f"bad type, value={value}, type={type(value)}")
+
+            else:
+                raise TypeError(f"bad type, value={value}, type={type(value)}")
+
+        return res
+
+    @classmethod
+    def parse_and_validate_values(cls, *values: ValuesForParseType) -> list[ValueType]:
+        return cls.parse_values(*values, validate=True)
+
+
+def __example():
+    pass
+
+
+if __name__ == '__main__':
+    __example()