arpakitlib 1.7.257__py3-none-any.whl → 1.8.1__py3-none-any.whl

arpakitlib/ar_func_util.py

@@ -5,50 +5,40 @@ from typing import Callable
 _ARPAKIT_LIB_MODULE_VERSION = "3.0"
 
 
-def is_async_function(func: Callable) -> bool:
-    return asyncio.iscoroutinefunction(func)
+def is_async_callable(obj: Callable) -> bool:
+    if inspect.ismethod(obj) or inspect.isfunction(obj):
+        return inspect.iscoroutinefunction(obj)
+    if isinstance(obj, (staticmethod, classmethod)):
+        return inspect.iscoroutinefunction(obj.__func__)
+    return False
 
 
-def is_async_object(obj: object) -> bool:
-    return asyncio.iscoroutine(obj)
+def raise_if_not_async_callable(obj: Callable):
+    if not is_async_callable(obj):
+        raise TypeError(f"The provided callable '{obj.__name__}' is not an async")
 
 
-def is_sync_function(func: Callable) -> bool:
-    return inspect.isfunction(func) and not is_async_function(func)
+# ---
 
 
-def raise_if_not_async_func(func: Callable):
-    if not is_async_function(func):
-        raise TypeError(f"The provided function '{func.__name__}' is not an async function")
+def is_async_object(obj: object) -> bool:
+    return asyncio.iscoroutine(obj)
 
 
-def raise_if_not_sync_func(func: Callable):
-    if not is_sync_function(func):
-        raise TypeError(f"The provided function '{func.__name__}' is not a sync function")
+# ---
 
 
-def raise_if_async_func(func: Callable):
-    if is_async_function(func):
-        raise TypeError(f"The provided function '{func.__name__}' should not be async")
+def is_sync_function(obj: Callable) -> bool:
+    return callable(obj) and not is_async_callable(obj=obj)
 
 
-def raise_if_sync_func(func: Callable):
-    if is_sync_function(func):
-        raise TypeError(f"The provided function '{func.__name__}' should not be sync")
+def raise_if_not_sync_callable(obj: Callable):
+    if not is_sync_function(obj):
+        raise TypeError(f"The provided callable '{obj.__name__}' is not an sync")
 
 
 def __example():
-    def one():
-        pass
-
-    async def two():
-        pass
-
-    print(is_sync_function(one))
-    print(is_sync_function(two))
-
-    print(is_async_function(one))
-    print(is_async_function(two))
+    pass
 
 
 if __name__ == '__main__':

arpakitlib/ar_http_request_util.py

@@ -29,6 +29,7 @@ def sync_make_http_request(
         not_raise_for_statuses_: list[int] | None = None,
         timeout_: timedelta | float = timedelta(seconds=15).total_seconds(),
         enable_logging_: bool = False,
+        exception_class_: type[Exception] | None = None,
         **kwargs
 ) -> requests.Response:
     if isinstance(timeout_, float):
@@ -75,7 +76,10 @@ def sync_make_http_request(
                     f"{tries_counter}/{max_tries_}, bad try {method} {url} {params}, exception={exception}"
                 )
             if tries_counter >= max_tries_:
-                raise exception
+                if exception_class_ is not None:
+                    raise exception_class_(exception)
+                else:
+                    raise exception
             sync_safe_sleep(timedelta(seconds=0.1).total_seconds())
             continue
 
@@ -92,6 +96,7 @@ async def async_make_http_request(
         not_raise_for_statuses_: list[int] | None = None,
         timeout_: timedelta | None = timedelta(seconds=15),
         enable_logging_: bool = False,
+        exception_class_: type[Exception] | None = None,
         **kwargs
 ) -> aiohttp.ClientResponse:
     tries_counter = 0
@@ -137,7 +142,10 @@ async def async_make_http_request(
                     f"{tries_counter}/{max_tries_}, bad try {method} {url} {params}, exception={exception}"
                 )
             if tries_counter >= max_tries_:
-                raise exception
+                if exception_class_ is not None:
+                    raise exception_class_(exception)
+                else:
+                    raise exception
             await async_safe_sleep(timedelta(seconds=0.1).total_seconds())
             continue
 

arpakitlib/ar_rat_func_util.py

@@ -64,7 +64,7 @@ async def rat_async_func(
 
 def __example():
     def go():
-        return "asfaf"
+        return "go"
 
     a = rat_sync_func(sync_func=go)
     print(a.has_exception)

arpakitlib/ar_retry_func_util.py

@@ -27,11 +27,11 @@ async def async_retry_func(
     while True:
         try:
             return await async_func(*async_func_args, **async_func_kwargs)
-        except Exception:
+        except Exception as exception:
             tries += 1
             if not endlessly and tries >= max_tries:
                 if raise_if_exception:
-                    raise
+                    raise exception
                 return None
             if timeout_after_exception:
                 await async_safe_sleep(timeout_after_exception.total_seconds())
@@ -54,11 +54,11 @@ def sync_retry_func(
     while True:
         try:
             return sync_func(*sync_func_args, **sync_func_kwargs)
-        except Exception:
+        except Exception as exception:
             tries += 1
             if not endlessly and tries >= max_tries:
                 if raise_if_exception:
-                    raise
+                    raise exception
                 return None
             if timeout_after_exception:
                 sync_safe_sleep(timeout_after_exception.total_seconds())

arpakitlib/ar_schedule_uust_api_client_util.py

@@ -189,7 +189,7 @@ class ScheduleUUSTAPIClient:
         try:
             await self.check_conn()
         except Exception as e:
-            self._logger.error(f"connection is bad", exc_info=e)
+            self._logger.error(f"connection is bad, {e}")
             return False
         return True
 

arpakitlib/ar_settings_util.py

@@ -1,17 +1,10 @@
 # arpakit
-import os
 from typing import Union, Any
 
-import pytz
-from pydantic import ConfigDict, field_validator, model_validator
+from pydantic import ConfigDict, model_validator
 from pydantic_core import PydanticUndefined
-from pydantic_core.core_schema import ValidationInfo
 from pydantic_settings import BaseSettings
 
-from arpakitlib.ar_enumeration_util import Enumeration
-from arpakitlib.ar_json_util import safely_transfer_obj_to_json_str
-from arpakitlib.ar_sqlalchemy_util import generate_sqlalchemy_url
-
 _ARPAKIT_LIB_MODULE_VERSION = "3.0"
 
 
@@ -25,12 +18,7 @@ def generate_env_example(settings_class: Union[BaseSettings, type[BaseSettings]]
     return res
 
 
-class ModeTypes(Enumeration):
-    not_prod: str = "not_prod"
-    prod: str = "prod"
-
-
-class BaseSettings2(BaseSettings):
+class SimpleSettings(BaseSettings):
     model_config = ConfigDict(extra="ignore")
 
     @model_validator(mode="before")
@@ -53,197 +41,8 @@ class BaseSettings2(BaseSettings):
         return env_example
 
 
-class SimpleSettings(BaseSettings2):
-    mode_type: str = ModeTypes.not_prod
-
-    @field_validator("mode_type")
-    @classmethod
-    def validate_mode_type(cls, v: str):
-        ModeTypes.parse_and_validate_values(v.lower().strip())
-        return v
-
-    @property
-    def is_mode_type_not_prod(self) -> bool:
-        return self.mode_type == ModeTypes.not_prod
-
-    def raise_if_mode_type_not_prod(self):
-        if self.is_mode_type_not_prod:
-            raise ValueError(f"mode type = {self.mode_type}")
-
-    @property
-    def is_mode_type_prod(self) -> bool:
-        return self.mode_type == ModeTypes.prod
-
-    def raise_if_mode_type_prod(self):
-        if self.is_mode_type_prod:
-            raise ValueError(f"mode type = {self.mode_type}")
-
-
-class AdvancedSettings(SimpleSettings):
-    project_name: str | None = None
-
-    @field_validator("project_name", mode="after")
-    def validate_project_name(cls, v: Any, validation_info: ValidationInfo, **kwargs) -> str | None:
-        if isinstance(v, str):
-            return v.strip()
-        return v
-
-    sqlalchemy_db_user: str | None = None
-
-    sqlalchemy_db_password: str | None = None
-
-    sqlalchemy_db_host: str | None = None
-
-    sqlalchemy_db_port: int | None = None
-
-    sqlalchemy_db_database: str | None = None
-
-    sqlalchemy_sync_db_url: str | None = None
-
-    @field_validator("sqlalchemy_sync_db_url", mode="after")
-    def validate_sqlalchemy_sync_db_url(cls, v: Any, validation_info: ValidationInfo, **kwargs) -> str | None:
-        if v is not None:
-            return v
-
-        return generate_sqlalchemy_url(
-            base="postgresql",
-            user=validation_info.data.get("sqlalchemy_db_user"),
-            password=validation_info.data.get("sqlalchemy_db_password"),
-            host=validation_info.data.get("sqlalchemy_db_host"),
-            port=validation_info.data.get("sqlalchemy_db_port"),
-            database=validation_info.data.get("sqlalchemy_db_database")
-        )
-
-    sqlalchemy_async_db_url: str | None = None
-
-    @field_validator("sqlalchemy_async_db_url", mode="after")
-    def validate_sqlalchemy_async_db_url(cls, v: Any, validation_info: ValidationInfo, **kwargs) -> str | None:
-        if v is not None:
-            return v
-
-        return generate_sqlalchemy_url(
-            base="postgresql",
-            user=validation_info.data.get("sqlalchemy_db_user"),
-            password=validation_info.data.get("sqlalchemy_db_password"),
-            host=validation_info.data.get("sqlalchemy_db_host"),
-            port=validation_info.data.get("sqlalchemy_db_port"),
-            database=validation_info.data.get("sqlalchemy_db_database")
-        )
-
-    @property
-    def is_any_sql_db_url_set(self) -> bool:
-        if self.sqlalchemy_sync_db_url is not None:
-            return True
-        if self.sqlalchemy_async_db_url is not None:
-            return True
-        return False
-
-    sqlalchemy_db_echo: bool = False
-
-    api_port: int | None = None
-
-    @field_validator("api_port", mode="before")
-    def validate_api_port(cls, v: Any, validation_info: ValidationInfo, **kwargs) -> int | None:
-        if isinstance(v, str):
-            if v.isdigit():
-                return int(v)
-        return None
-
-    api_init_sqlalchemy_db: bool = False
-
-    api_init_json_db: bool = False
-
-    api_logging__api_func_before_in_handle_exception: bool = True
-
-    api_story_log__api_func_before_in_handle_exception: bool = False
-
-    api_correct_api_key: str | None = "test"
-
-    api_correct_token: str | None = "test"
-
-    api_enable_admin1: bool = False
-
-    api_start_operation_executor_worker: bool = False
-
-    api_start_scheduled_operation_creator_worker: bool = False
-
-    admin1_secret_key: str | None = "85a9583cb91c4de7a78d7eb1e5306a04418c9c43014c447ea8ec8dd5deb4cf71"
-
-    tg_bot_token: str | None = None
-
-    tg_bot_proxy_url: str | None = None
-
-    tg_bot_init_sqlalchemy_db: bool = False
-
-    tg_bot_init_json_db: bool = False
-
-    var_dirpath: str | None = None
-
-    log_filepath: str | None = None
-
-    @field_validator("log_filepath", mode="after")
-    def validate_log_filepath(cls, v: Any, validation_info: ValidationInfo, **kwargs) -> str | None:
-        if v is not None:
-            return v
-        var_dirpath = validation_info.data.get("var_dirpath")
-        if var_dirpath is None:
-            return None
-        return os.path.join(var_dirpath, "story.log")
-
-    cache_dirpath: str | None = None
-
-    @field_validator("cache_dirpath", mode="after")
-    def validate_cache_dirpath(cls, v: Any, validation_info: ValidationInfo, **kwargs) -> str | None:
-        if v is not None:
-            return v
-        var_dirpath = validation_info.data.get("var_dirpath")
-        if var_dirpath is None:
-            return None
-        return os.path.join(var_dirpath, "cache")
-
-    media_dirpath: str | None = None
-
-    @field_validator("media_dirpath", mode="after")
-    def validate_media_dirpath(cls, v: Any, validation_info: ValidationInfo, **kwargs) -> str | None:
-        if v is not None:
-            return v
-        var_dirpath = validation_info.data.get("var_dirpath")
-        if var_dirpath is None:
-            return None
-        return os.path.join(var_dirpath, "media")
-
-    dump_dirpath: str | None = None
-
-    @field_validator("dump_dirpath", mode="after")
-    def validate_dump_dirpath(cls, v: Any, validation_info: ValidationInfo, **kwargs) -> str | None:
-        if v is not None:
-            return v
-        var_dirpath = validation_info.data.get("var_dirpath")
-        if var_dirpath is None:
-            return None
-        return os.path.join(var_dirpath, "dump")
-
-    local_timezone: str | None = None
-
-    @property
-    def local_timezone_as_pytz(self) -> Any:
-        return pytz.timezone(self.local_timezone)
-
-    json_db_dirpath: str | None = None
-
-    @field_validator("json_db_dirpath", mode="after")
-    def validate_json_db_dirpath(cls, v: Any, validation_info: ValidationInfo, **kwargs) -> str | None:
-        if v is not None:
-            return v
-        var_dirpath = validation_info.data.get("var_dirpath")
-        if var_dirpath is None:
-            return None
-        project_name = validation_info.data.get("project_name")
-        return os.path.join(var_dirpath, f"{project_name}_json_db")
-
-
 def __example():
-    print(safely_transfer_obj_to_json_str(AdvancedSettings(var_dirpath="./var").model_dump(mode="json")))
+    pass
 
 
 if __name__ == '__main__':

arpakitlib/ar_sqladmin_util.py

@@ -1,105 +1,10 @@
-# arpakit
-from sqladmin import ModelView
-from sqladmin.models import ModelViewMeta
-
-from arpakitlib.ar_class_util import CollectingSubclassesMeta
-from arpakitlib.ar_sqlalchemy_model_util import OperationDBM, StoryLogDBM
-
-_ARPAKIT_LIB_MODULE_VERSION = "3.0"
-
-
-def create_combined_meta(*metas):
-    """
-    Создает объединённый метакласс для устранения конфликтов.
-    """
-
-    class CombinedMeta(*metas):
-        pass
-
-    return CombinedMeta
-
+from __future__ import annotations
 
-class SimpleModelView(ModelView, metaclass=create_combined_meta(CollectingSubclassesMeta, ModelViewMeta)):
-    can_create = True
-    can_edit = True
-    can_delete = True
-    can_view_details = True
-    can_export = True
-    page_size = 50
-    page_size_options = [25, 50, 100, 200]
-    save_as = True
-    save_as_continue = True
-    export_types = ["xlsx", "csv", "json"]
-
-
-class OperationMV(SimpleModelView, model=OperationDBM):
-    name = "Operation"
-    name_plural = "Operations"
-    column_list = [
-        OperationDBM.id,
-        OperationDBM.long_id,
-        OperationDBM.creation_dt,
-        OperationDBM.status,
-        OperationDBM.type,
-        OperationDBM.execution_start_dt,
-        OperationDBM.execution_finish_dt,
-        OperationDBM.input_data,
-        OperationDBM.output_data,
-        OperationDBM.error_data
-    ]
-    form_columns = [
-        OperationDBM.status,
-        OperationDBM.type,
-        OperationDBM.execution_start_dt,
-        OperationDBM.execution_finish_dt,
-        OperationDBM.input_data,
-        OperationDBM.output_data,
-        OperationDBM.error_data
-    ]
-    column_default_sort = [
-        (OperationDBM.creation_dt, True)
-    ]
-    column_searchable_list = [
-        OperationDBM.id,
-        OperationDBM.long_id,
-        OperationDBM.status,
-        OperationDBM.type,
-    ]
-
-
-class StoryLogMV(SimpleModelView, model=StoryLogDBM):
-    name = "StoryLog"
-    name_plural = "StoryLogs"
-    column_list = [
-        StoryLogDBM.id,
-        StoryLogDBM.long_id,
-        StoryLogDBM.creation_dt,
-        StoryLogDBM.level,
-        StoryLogDBM.title,
-        StoryLogDBM.data
-    ]
-    form_columns = [
-        StoryLogDBM.level,
-        StoryLogDBM.title,
-        StoryLogDBM.data
-    ]
-    column_default_sort = [
-        (StoryLogDBM.creation_dt, True)
-    ]
-    column_searchable_list = [
-        StoryLogDBM.id,
-        StoryLogDBM.long_id,
-        StoryLogDBM.level,
-        StoryLogDBM.title,
-        StoryLogDBM.data
-    ]
-
-
-def __example():
-    print(len(SimpleModelView.all_subclasses))
-    for model_view in SimpleModelView.all_subclasses:
-        print(model_view)
+from sqladmin import ModelView
 
 
-if __name__ == '__main__':
-    __example()
+def get_string_info_from_model_view(class_: type[ModelView]):
+    res = f"Model Views: {len(class_.__subclasses__())}"
+    for i, cls in enumerate(class_.__subclasses__()):
+        res += f"\n{i + 1}. {cls.__name__}"
+    return res

arpakitlib/ar_sqlalchemy_util.py

@@ -12,18 +12,11 @@ from sqlalchemy.orm import sessionmaker, DeclarativeBase
 from sqlalchemy.orm.session import Session
 
 from arpakitlib.ar_datetime_util import now_utc_dt
-from arpakitlib.ar_sqlalchemy_model_util import BaseDBM
+from arpakitlib.ar_json_util import safely_transfer_obj_to_json_str
 
 _ARPAKIT_LIB_MODULE_VERSION = "3.0"
 
 
-def get_string_info_from_declarative_base(class_: type[DeclarativeBase]):
-    res = f"Models: {len(class_.__subclasses__())}"
-    for i, cls in enumerate(class_.__subclasses__()):
-        res += f"\n{i + 1}. {cls.__name__}"
-    return res
-
-
 def generate_sqlalchemy_url(
         *,
         base: str = "postgresql",
@@ -62,6 +55,57 @@ def generate_sqlalchemy_url(
     return f"{base}://{auth_part}{host_part}{database_part}{query_part}"
 
 
+class BaseDBM(DeclarativeBase):
+    __abstract__ = True
+    _bus_data: dict[str, Any] | None = None
+
+    @property
+    def bus_data(self) -> dict[str, Any]:
+        if self._bus_data is None:
+            self._bus_data = {}
+        return self._bus_data
+
+    def simple_dict(self, *, include_sd_properties: bool = True) -> dict[str, Any]:
+        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)
+            elif isinstance(value, list):
+                res[c.key] = [
+                    item.simple_dict(include_sd_properties=include_sd_properties)
+                    if isinstance(item, BaseDBM) else item
+                    for item in value
+                ]
+            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):
+                    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)
+                    elif isinstance(value, list):
+                        res[prop_name] = [
+                            item.simple_dict(include_sd_properties=include_sd_properties)
+                            if isinstance(item, BaseDBM) else item
+                            for item in value
+                        ]
+                    else:
+                        res[prop_name] = value
+
+        return res
+
+    def simple_dict_with_sd_properties(self) -> dict[str, Any]:
+        return self.simple_dict(include_sd_properties=True)
+
+    def simple_json(self, *, include_sd_properties: bool = True) -> str:
+        return safely_transfer_obj_to_json_str(self.simple_dict(include_sd_properties=include_sd_properties))
+
+
 class SQLAlchemyDb:
     def __init__(
             self,
@@ -72,7 +116,7 @@ class SQLAlchemyDb:
             base_dbm: type[BaseDBM] | None = None,
             db_models: list[Any] | None = None,
     ):
-        self._logger = logging.getLogger()
+        self._logger = logging.getLogger(self.__class__.__name__)
 
         self.db_url = sync_db_url
         if self.db_url is not None:
@@ -101,6 +145,7 @@ class SQLAlchemyDb:
         self.func_new_async_session_counter = 0
 
         self.base_dbm = base_dbm
+        self.db_models = db_models
 
     def is_table_exists(self, table_name: str) -> bool:
         with self.engine.connect() as connection:
@@ -112,7 +157,7 @@ class SQLAlchemyDb:
             connection.execute(text("DROP TABLE IF EXISTS celery_tasksetmeta CASCADE;"))
             connection.execute(text("DROP TABLE IF EXISTS celery_taskmeta CASCADE;"))
             connection.commit()
-            self._logger.info("celery tables were dropped")
+        self._logger.info("celery tables were dropped")
 
     def remove_celery_tables_data(self):
         if not self.is_table_exists("celery_tasksetmeta"):
@@ -122,14 +167,14 @@ class SQLAlchemyDb:
             connection.execute(text("DELETE FROM celery_tasksetmeta;"))
             connection.execute(text("DELETE FROM celery_taskmeta;"))
             connection.commit()
-            self._logger.info("celery tables data were removed")
+        self._logger.info("celery tables data were removed")
 
     def drop_alembic_tables(self):
         with self.engine.connect() as connection:
             connection.execute(text("DROP TABLE IF EXISTS alembic_version CASCADE;"))
             connection.execute(text("DROP TABLE IF EXISTS alembic_version CASCADE;"))
             connection.commit()
-            self._logger.info("alembic_version tables were dropped")
+        self._logger.info("alembic_version tables were dropped")
 
     def remove_alembic_tables_data(self):
         if not self.is_table_exists("alembic_version"):
@@ -138,7 +183,7 @@ class SQLAlchemyDb:
         with self.engine.connect() as connection:
             connection.execute(text("DELETE FROM alembic_version;"))
             connection.commit()
-            self._logger.info("alembic tables data were removed")
+        self._logger.info("alembic tables data were removed")
 
     def init(self):
         self.base_dbm.metadata.create_all(bind=self.engine, checkfirst=True)
@@ -191,6 +236,13 @@ class SQLAlchemyDb:
         return now_utc_dt()
 
 
+def get_string_info_from_declarative_base(class_: type[DeclarativeBase]):
+    res = f"Db Models: {len(class_.__subclasses__())}"
+    for i, cls in enumerate(class_.__subclasses__()):
+        res += f"\n{i + 1}. {cls.__name__}"
+    return res
+
+
 def __example():
     pass
 

arpakitlib/ar_type_util.py

@@ -151,8 +151,6 @@ def __example():
     except TypeError as e:
         print(e)
 
-    print(get_setted_elements_as_dict_from_dict({"afs": "ASfa", "asfasf": NotSet}))
-
 
 if __name__ == '__main__':
     __example()

{arpakitlib-1.7.257.dist-info → arpakitlib-1.8.1.dist-info}/METADATA

@@ -1,11 +1,11 @@
 Metadata-Version: 2.3
 Name: arpakitlib
-Version: 1.7.257
+Version: 1.8.1
 Summary: arpakitlib
 License: Apache-2.0
 Keywords: arpakitlib,arpakit,arpakit-company,arpakitcompany,arpakit_company
-Author: arpakit
-Author-email: arpakit@gmail.com
+Author: arpakit_support
+Author-email: support@arpakit.com
 Requires-Python: >=3.12.4,<4.0
 Classifier: Development Status :: 5 - Production/Stable
 Classifier: Intended Audience :: Developers
@@ -55,6 +55,7 @@ Requires-Dist: uvicorn (>=0.34.0,<0.35.0)
 Project-URL: Documentation, https://github.com/ARPAKIT-Company/arpakitlib
 Project-URL: Homepage, https://github.com/ARPAKIT-Company/arpakitlib
 Project-URL: Repository, https://github.com/ARPAKIT-Company/arpakitlib
+Project-URL: arpakit_company_site, https://arpakit.com/
 Project-URL: telegram_channel, https://t.me/arpakitlib
 Description-Content-Type: text/markdown
 
@@ -89,6 +90,7 @@ pip install arpakitlib
 
 ```
 poetry run arpakitlib -c help
+poetry run arpakitlib -c init_arpakit_project_template -version 1 -project_dirpath ./ -overwrite_if_exists True
 ```
 
 ---