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

arpakitlib/ar_schedule_uust_api_client_util.py

@@ -3,14 +3,14 @@
 import asyncio
 import hashlib
 import logging
-from datetime import datetime, timedelta
+from datetime import datetime
 from typing import Any
 
 import pytz
+from aiohttp import ClientResponse
 
 from arpakitlib.ar_dict_util import combine_dicts
 from arpakitlib.ar_http_request_util import async_make_http_request
-from arpakitlib.ar_type_util import raise_for_type
 
 _ARPAKIT_LIB_MODULE_VERSION = "3.0"
 
@@ -72,25 +72,25 @@ 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_get_request(
+    async def _async_make_http_request(
             self,
             *,
+            method: str = "GET",
             url: str,
-            params: dict | None = None
-    ) -> dict[str, Any]:
+            params: dict[str, Any] | None = None
+    ) -> ClientResponse:
         response = await async_make_http_request(
+            method=method,
             url=url,
-            method="GET",
+            headers=self.headers,
             params=combine_dicts(params, self.auth_params()),
             proxy_url_=self.api_proxy_url,
-            max_tries_=9,
-            timeout_=timedelta(seconds=15),
-            raise_for_status_=True,
-            headers=self.headers
+            raise_for_status_=True
         )
         json_data = await response.json()
-        raise_for_type(json_data, dict)
-        return json_data
+        if "error" in json_data.keys():
+            raise Exception(f"error in json_data, {json_data}")
+        return response
 
     async def get_current_week(self) -> int:
         """
@@ -100,10 +100,11 @@ class ScheduleUUSTAPIClient:
         }
         """
 
-        json_data = await self._async_make_http_get_request(
+        response = await self._async_make_http_request(
             url=self.api_url,
             params={"ask": "get_current_week"}
         )
+        json_data = await response.json()
         return json_data["data"][0]
 
     async def get_current_semester(self) -> str:
@@ -114,10 +115,11 @@ class ScheduleUUSTAPIClient:
         }
         """
 
-        json_data = await self._async_make_http_get_request(
+        response = await self._async_make_http_request(
             url=self.api_url,
             params={"ask": "get_current_semestr"}
         )
+        json_data = await response.json()
         return json_data["data"][0]
 
     async def get_groups(self) -> list[dict[str, Any]]:
@@ -135,10 +137,11 @@ class ScheduleUUSTAPIClient:
         }
         """
 
-        json_data = await self._async_make_http_get_request(
+        response = await self._async_make_http_request(
             url=self.api_url,
             params={"ask": "get_group_list"}
         )
+        json_data = await response.json()
         return list(json_data["data"].values())
 
     async def get_group_lessons(self, group_id: int, semester: str | None = None) -> list[dict[str, Any]]:
@@ -148,45 +151,56 @@ class ScheduleUUSTAPIClient:
         }
         if semester is not None:
             params["semester"] = semester
-        json_data = await self._async_make_http_get_request(
+        response = await self._async_make_http_request(
             url=self.api_url,
             params=params
         )
+        json_data = await response.json()
         return json_data["data"]
 
     async def get_teachers(self) -> list[dict[str, Any]]:
-        json_data = await self._async_make_http_get_request(
+        response = await self._async_make_http_request(
             url=self.api_url,
             params={"ask": "get_teacher_list"}
         )
+        json_data = await response.json()
         return list(json_data["data"].values())
 
     async def get_teacher_lessons(self, teacher_id: int, semester: str | None = None) -> list[dict[str, Any]]:
         params = {"ask": "get_teacher_schedule", "id": teacher_id}
         if semester is not None:
             params["semester"] = semester
-        json_data = await self._async_make_http_get_request(
+        response = await self._async_make_http_request(
             url=self.api_url,
             params=params
         )
+        json_data = await response.json()
         return json_data["data"]
 
     async def check_conn(self):
         await self.get_current_week()
+        self._logger.info(f"connection is good")
 
     async def is_conn_good(self):
         try:
             await self.check_conn()
         except Exception as e:
-            self._logger.error(e)
+            self._logger.error(f"connection is bad", exc_info=e)
             return False
         return True
 
     async def check_all(self):
-        await self.get_groups()
-        await self.get_teachers()
-        await self.get_current_semester()
-        await self.get_current_week()
+        groups = await self.get_groups()
+        self._logger.info(f"groups len: {len(groups)}")
+
+        teachers = await self.get_teachers()
+        self._logger.info(f"teachers len: {len(teachers)}")
+
+        current_semester = await self.get_current_semester()
+        self._logger.info(f"current_semester: {current_semester}")
+
+        current_week = await self.get_current_week()
+        self._logger.info(f"current_week: {current_week}")
 
 
 def __example():

arpakitlib/ar_settings_util.py

@@ -1,19 +1,34 @@
+# arpakit
+
+from typing import Union
+
 from pydantic import ConfigDict, field_validator
+from pydantic_core import PydanticUndefined
 from pydantic_settings import BaseSettings
 
 from arpakitlib.ar_enumeration_util import Enumeration
-from arpakitlib.ar_generate_env_example import generate_env_example
+
+_ARPAKIT_LIB_MODULE_VERSION = "3.0"
+
+
+def generate_env_example(settings_class: Union[BaseSettings, type[BaseSettings]]):
+    res = ""
+    for k, f in settings_class.model_fields.items():
+        if f.default is not PydanticUndefined:
+            res += f"# {k}=\n"
+        else:
+            res += f"{k}=\n"
+    return res
 
 
 class SimpleSettings(BaseSettings):
     model_config = ConfigDict(extra="ignore")
 
     class ModeTypes(Enumeration):
-        local: str = "local"
-        test: str = "preprod"
+        not_prod: str = "not_prod"
         prod: str = "prod"
 
-    mode_type: str = ModeTypes.local
+    mode_type: str = ModeTypes.not_prod
 
     @field_validator("mode_type")
     @classmethod
@@ -22,17 +37,28 @@ class SimpleSettings(BaseSettings):
         return v
 
     @property
-    def is_mode_type_local(self) -> bool:
-        return self.mode_type == self.ModeTypes.local
-
-    @property
-    def is_mode_type_test(self) -> bool:
-        return self.mode_type == self.ModeTypes.test
+    def is_mode_type_not_prod(self) -> bool:
+        return self.mode_type == self.ModeTypes.not_prod
 
     @property
     def is_mode_type_prod(self) -> bool:
         return self.mode_type == self.ModeTypes.prod
 
     @classmethod
-    def env_example(cls) -> str:
+    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
+
+
+def __example():
+    pass
+
+
+if __name__ == '__main__':
+    __example()

arpakitlib/ar_sleep_util.py

@@ -1,7 +1,6 @@
 # arpakit
 
 import asyncio
-import logging
 import math
 from time import sleep
 
@@ -9,12 +8,8 @@ from asyncpg.pgproto.pgproto import timedelta
 
 _ARPAKIT_LIB_MODULE_VERSION = "3.0"
 
-_logger = logging.getLogger(__name__)
-
 
 def sync_safe_sleep(n: timedelta | float | int):
-    _logger.info(f"sync_safe_sleep ({n}) starts")
-
     if isinstance(n, timedelta):
         n = n.total_seconds()
     elif isinstance(n, int):
@@ -31,12 +26,8 @@ def sync_safe_sleep(n: timedelta | float | int):
         sleep(1)
     sleep(frac)
 
-    _logger.info(f"sync_safe_sleep ({n}) ends")
-
 
 async def async_safe_sleep(n: timedelta | float | int):
-    _logger.info(f"async_safe_sleep ({n}) starts")
-
     if isinstance(n, timedelta):
         n = n.total_seconds()
     elif isinstance(n, int):
@@ -48,11 +39,7 @@ async def async_safe_sleep(n: timedelta | float | int):
 
     n: float = n
 
-    _logger.info(f"sleep_time ({n}) starts")
     await asyncio.sleep(n)
-    _logger.info(f"sleep_time ({n}) ends")
-
-    _logger.info(f"async_safe_sleep ({n}) ends")
 
 
 def __example():

arpakitlib/ar_sqlalchemy_model_util.py

@@ -10,11 +10,19 @@ from sqlalchemy.orm import DeclarativeBase, Mapped, mapped_column
 
 from arpakitlib.ar_datetime_util import now_utc_dt
 from arpakitlib.ar_enumeration_util import Enumeration
-from arpakitlib.ar_json_util import safely_transfer_to_json_str
+from arpakitlib.ar_json_util import safely_transfer_obj_to_json_str
 
 _ARPAKIT_LIB_MODULE_VERSION = "3.0"
 
 
+def generate_default_long_id():
+    return (
+        f"longid"
+        f"{str(uuid4()).replace('-', '')}"
+        f"{str(now_utc_dt().timestamp()).replace('.', '')}"
+    )
+
+
 class BaseDBM(DeclarativeBase):
     __abstract__ = True
     _bus_data: dict[str, Any] | None = None
@@ -26,17 +34,29 @@ class BaseDBM(DeclarativeBase):
         return self._bus_data
 
     def simple_dict(self, *, include_sd_properties: bool = True) -> dict[str, Any]:
-        res = {c.key: getattr(self, c.key) for c in inspect(self).mapper.column_attrs}
+        res = {}
+
+        for c in inspect(self).mapper.column_attrs:
+            value = getattr(self, c.key)
+            if isinstance(value, BaseDBM):
+                res[c.key] = value.simple_dict(include_sd_properties=include_sd_properties)
+            else:
+                res[c.key] = value
 
         if include_sd_properties:
             for attr_name in dir(self):
                 if attr_name.startswith("sdp_") and isinstance(getattr(type(self), attr_name, None), property):
-                    res[attr_name.removesuffix("sdp_")] = getattr(self, attr_name)
+                    prop_name = attr_name.removeprefix("sdp_")
+                    value = getattr(self, attr_name)
+                    if isinstance(value, BaseDBM):
+                        res[prop_name] = value.simple_dict(include_sd_properties=include_sd_properties)
+                    else:
+                        res[prop_name] = value
 
         return res
 
     def simple_json(self, *, include_sd_properties: bool = True) -> str:
-        return safely_transfer_to_json_str(self.simple_dict(include_sd_properties=include_sd_properties))
+        return safely_transfer_obj_to_json_str(self.simple_dict(include_sd_properties=include_sd_properties))
 
 
 class SimpleDBM(BaseDBM):
@@ -46,7 +66,7 @@ class SimpleDBM(BaseDBM):
         INTEGER, primary_key=True, autoincrement=True, sort_order=-3, nullable=False
     )
     long_id: Mapped[str] = mapped_column(
-        TEXT, insert_default=uuid4, unique=True, sort_order=-2, nullable=False
+        TEXT, insert_default=generate_default_long_id, unique=True, sort_order=-2, nullable=False
     )
     creation_dt: Mapped[datetime] = mapped_column(
         TIMESTAMP(timezone=True), insert_default=now_utc_dt, index=True, sort_order=-1, nullable=False
@@ -73,6 +93,11 @@ class StoryLogDBM(SimpleDBM):
     )
 
 
+class BaseOperationTypes(Enumeration):
+    healthcheck_ = "healthcheck"
+    raise_fake_exception_ = "raise_fake_exception"
+
+
 class OperationDBM(SimpleDBM):
     __tablename__ = "operation"
 
@@ -82,16 +107,12 @@ class OperationDBM(SimpleDBM):
         executed_without_error = "executed_without_error"
         executed_with_error = "executed_with_error"
 
-    class Types(Enumeration):
-        healthcheck_ = "healthcheck"
-        raise_fake_exception_ = "raise_fake_exception"
-
     status: Mapped[str] = mapped_column(
         TEXT, index=True, insert_default=Statuses.waiting_for_execution,
         server_default=Statuses.waiting_for_execution, nullable=False
     )
     type: Mapped[str] = mapped_column(
-        TEXT, index=True, insert_default=Types.healthcheck_, nullable=False
+        TEXT, index=True, insert_default=BaseOperationTypes.healthcheck_, nullable=False
     )
     execution_start_dt: Mapped[datetime | None] = mapped_column(TIMESTAMP(timezone=True), nullable=True)
     execution_finish_dt: Mapped[datetime | None] = mapped_column(TIMESTAMP(timezone=True), nullable=True)
@@ -128,6 +149,10 @@ class OperationDBM(SimpleDBM):
             return None
         return self.duration.total_seconds()
 
+    @property
+    def sdp_duration_total_seconds(self) -> float | None:
+        return self.duration_total_seconds
+
 
 def __example():
     pass

arpakitlib/ar_sqlalchemy_util.py

@@ -26,9 +26,10 @@ class SQLAlchemyDB:
             self,
             *,
             db_url: str = "postgresql://arpakitlib:arpakitlib@localhost:50629/arpakitlib",
-            echo: bool = False,
+            db_echo: bool = False,
             need_include_operation_dbm: bool = False,
-            need_include_story_dbm: bool = False
+            need_include_story_dbm: bool = False,
+            db_models: list[Any] | None = None
     ):
         self._logger = logging.getLogger(self.__class__.__name__)
         self.need_include_operation_dbm = need_include_operation_dbm
@@ -37,7 +38,7 @@ class SQLAlchemyDB:
             self.need_include_story_dbm = True
         self.engine = create_engine(
             url=db_url,
-            echo=echo,
+            echo=db_echo,
             pool_size=5,
             max_overflow=10,
             poolclass=QueuePool,

arpakitlib/{ar_ssh_util.py → ar_ssh_runner_util.py}

@@ -11,7 +11,7 @@ import asyncssh
 import paramiko
 from pydantic import BaseModel
 
-from arpakitlib.ar_json_util import safely_transfer_to_json_str
+from arpakitlib.ar_json_util import safely_transfer_obj_to_json_str
 
 _ARPAKIT_LIB_MODULE_VERSION = "3.0"
 
@@ -61,7 +61,7 @@ class SSHRunRes(BaseModel):
         }
 
     def simple_json(self) -> str:
-        return safely_transfer_to_json_str(self.simple_dict())
+        return safely_transfer_obj_to_json_str(self.simple_dict())
 
     def __repr__(self) -> str:
         return self.simple_json()

arpakitlib/ar_str_util.py

@@ -52,12 +52,18 @@ def bidirectional_str_startswith(string1: str, string2: str, max_diff: Optional[
     return False
 
 
-def blank_if_none(string: Optional[str] = None) -> str:
+def make_blank_if_none(string: Optional[str] = None) -> str:
     if string is None:
         return ""
     return string
 
 
+def make_none_if_blank(string: Optional[str] = None) -> str | None:
+    if not string:
+        return None
+    return string
+
+
 def remove_html(string: str) -> str:
     raise_for_type(string, str)
     return BeautifulSoup(string, "html.parser").text
@@ -73,8 +79,43 @@ def remove_tags_and_html(string: str) -> str:
     return remove_tags(remove_html(string))
 
 
+def raise_if_string_blank(string: str) -> str:
+    if not string:
+        raise ValueError("not string")
+    return string
+
+
 def __example():
-    pass
+    print("str_in:")
+    print(str_in(string="hello", main_string="hello world"))  # True
+    print(str_in(string="bye", main_string="hello world"))  # False
+    print(str_in(string="hello", main_string="hello world", max_diff=6))  # True
+    print(str_in(string="hello", main_string="hello world", max_diff=1))  # False
+
+    print("\nbidirectional_str_in:")
+    print(bidirectional_str_in(string1="hello", string2="hello world"))  # True
+    print(bidirectional_str_in(string1="world", string2="hello world"))  # True
+
+    print("\nstr_startswith:")
+    print(str_startswith(string="hello", main_string="hello world"))  # True
+    print(str_startswith(string="world", main_string="hello world"))  # False
+
+    print("\nbidirectional_str_startswith:")
+    print(bidirectional_str_startswith(string1="hello", string2="hello world"))  # True
+    print(bidirectional_str_startswith(string1="world", string2="hello world"))  # False
+
+    print("\nmake blank_if_none:")
+    print(make_blank_if_none())  # ""
+    print(make_blank_if_none(string="test"))  # "test"
+
+    print("\nremove_html:")
+    print(remove_html(string="<div>Hello <b>World</b></div>"))  # "Hello World"
+
+    print("\nremove_tags:")
+    print(remove_tags(string="<div>Hello <b>World</b></div>"))  # "divHello bWorldbdiv"
+
+    print("\nremove_tags_and_html:")
+    print(remove_tags_and_html("<div>Hello <b>World</b></div>"))  # "Hello World"
 
 
 if __name__ == '__main__':

arpakitlib/ar_type_util.py

@@ -67,13 +67,77 @@ def raise_for_types(comparable, need_types, comment_for_error: Optional[str] = N
         raise TypeError(err)
 
 
-def raise_if_not_async_func(func: Any):
-    if not inspect.iscoroutinefunction(func):
-        raise TypeError(f"The provided function '{func.__name__}' is not an async function")
+def make_none_to_false(v: Any) -> Any:
+    if v is None:
+        return False
+    return v
+
+
+def raise_if_none(v: Any) -> Any:
+    if v is None:
+        raise ValueError(f"v is None, v={v}, type(v)={type(v)}")
+    return v
+
+
+def raise_if_not_none(v: Any) -> Any:
+    if v is not None:
+        raise ValueError(f"v is not None, v={v}, type(v)={type(v)}")
+    return v
 
 
 def __example():
-    pass
+    print("is_set:")
+    print(is_set(v=NotSet))  # False
+    print(is_set(v="hello world"))  # True
+
+    print("\nis_not_set:")
+    print(is_not_set(v=NotSet))  # True
+    print(is_not_set(v="hello world"))  # False
+
+    print("\nis_set_and_not_none:")
+    print(is_set_and_not_none(v=NotSet))  # False
+    print(is_set_and_not_none(v=None))  # False
+    print(is_set_and_not_none(v=1000))  # True
+
+    print("\nis_not_set_or_none:")
+    print(is_not_set_or_none(v=NotSet))  # True
+    print(is_not_set_or_none(v=None))  # True
+    print(is_not_set_or_none(v=100))  # False
+
+    print("\nmake_none_if_not_set:")
+    print(make_none_if_not_set(v=NotSet))  # None
+    print(make_none_if_not_set(v="hello world"))  # hello world
+
+    print("\nmake_none_to_false:")
+    print(make_none_to_false(v=None))  # False
+    print(make_none_to_false(v=True))  # True
+    print(make_none_to_false(v=100))  # 100
+
+    print("\nraise_if_set:")
+    try:
+        raise_if_set(v=100)  # raise
+    except ValueError as e:
+        print(e)
+
+    print("\nraise_if_set:")
+    try:
+        raise_if_not_set(v=NotSet)  # raise
+    except ValueError as e:
+        print(e)
+
+    print("\nraise_for_type:")
+    try:
+        raise_for_type(comparable="test", need_type=str)  # pass
+        raise_for_type(comparable=100, need_type=str)  # raise
+    except TypeError as e:
+        print(e)
+
+    print("\nraise_for_types:")
+    try:
+        raise_for_types(comparable="test", need_types=[str, int])  # pass
+        raise_for_types(comparable=100.5, need_types=[str, int], comment_for_error="Ooops")  # raise
+    except TypeError as e:
+        print(e)
 
 
 if __name__ == '__main__':