arpakitlib 1.8.307__py3-none-any.whl → 1.8.322__py3-none-any.whl

arpakitlib/ar_ensure_sqlalchemy_check_constraints.py

@@ -73,12 +73,14 @@ def ensure_sqlalchemy_check_constraints(*, base_: type[DeclarativeBase], engine:
     # Возьмём соединение и транзакцию (BEGIN), чтобы изменения были атомарными
 
     with engine.begin() as conn:
-        conn_inspector = sqlalchemy.inspect(conn)
+        conn_inspection_ = sqlalchemy.inspect(conn)
 
         for table in base_.metadata.tables.values():
+            if not conn_inspection_.has_table(table.name, schema=table.schema):
+                continue
 
             # Соберём существующие CHECK-и из БД
-            existing = conn_inspector.get_check_constraints(table.name, schema=table.schema)
+            existing = conn_inspection_.get_check_constraints(table.name, schema=table.schema)
 
             # Множества для быстрых проверок
             existing_names: Set[str] = set()

arpakitlib/ar_generate_connection_url_util.py

@@ -0,0 +1,79 @@
+from urllib.parse import quote_plus
+
+
+def generate_connection_url(
+        *,
+        scheme: str = "postgresql",  # общий случай: postgresql, sqlite, redis, amqp и т.п.
+        user: str | None = None,
+        password: str | None = None,
+        host: str | None = "127.0.0.1",
+        port: int | None = None,
+        database: str | int | None = None,
+        quote_query_params: bool = True,
+        **query_params
+) -> str:
+    """
+    Универсальная функция для генерации URL соединений (Postgres, Redis, AMQP, SQLite и др.)
+
+    Примеры:
+      postgresql://user:pass@localhost:5432/dbname
+      sqlite:///path/to/db.sqlite3
+      redis://:mypassword@redis:6379/0
+      amqp://user:pass@rabbit:5672/myvhost
+    """
+    # Формируем часть авторизации
+    auth_part = ""
+    if user and password:
+        auth_part = f"{quote_plus(user)}:{quote_plus(password)}@"
+    elif password and not user:
+        auth_part = f":{quote_plus(password)}@"
+    elif user:
+        auth_part = f"{quote_plus(user)}@"
+
+    # Формируем хост и порт
+    if scheme.startswith("sqlite"):
+        host_part = ""
+    else:
+        host_part = host or ""
+        if port:
+            host_part += f":{port}"
+
+    # Формируем "базу" (database / номер / путь)
+    db_part = ""
+    if database is not None:
+        db_part = f"/{quote_plus(str(database))}"
+
+    # Формируем query параметры
+    query_part = ""
+    if query_params:
+        query_items = []
+        for k, v in query_params.items():
+            value = str(v)
+            if quote_query_params:
+                value = quote_plus(value)
+            query_items.append(f"{k}={value}")
+        query_part = f"?{'&'.join(query_items)}"
+
+    return f"{scheme}://{auth_part}{host_part}{db_part}{query_part}"
+
+
+def __example():
+    print(generate_connection_url())
+    # → redis://127.0.0.1:6379/0
+
+    # Redis с паролем
+    print(generate_connection_url(password="supersecret", host="redis"))
+    # → redis://:supersecret@redis:6379/0
+
+    # RabbitMQ (AMQP)
+    print(generate_connection_url(scheme="amqp", user="guest", password="guest", host="rabbitmq", port=6789))
+    # → amqp://guest:guest@rabbitmq:6379/0
+
+    # Redis с параметрами
+    print(generate_connection_url(scheme="mongodb", user="root", password="pass", host="localhost", port=27017,
+                                  authSource="fghjkl;", quote_query_params=True))
+    # → redis://:pass@127.0.0.1:6379/0?ssl_cert_reqs=none&socket_timeout=10
+
+
+if __name__ == '__main__':
+    __example()

arpakitlib/ar_mongodb_util.py

@@ -4,8 +4,6 @@ import asyncio
 import logging
 from abc import abstractmethod
 from random import randint
-from typing import Optional
-from urllib.parse import quote
 
 from pymongo import MongoClient
 from pymongo.collection import Collection
@@ -14,27 +12,6 @@ from pymongo.database import Database
 _ARPAKIT_LIB_MODULE_VERSION = "3.0"
 
 
-def generate_mongo_uri(
-        *,
-        mongo_user: Optional[str] = None,
-        mongo_password: Optional[str] = None,
-        mongo_hostname: str = "localhost",
-        mongo_port: int = 27017,
-        mongo_auth_db: Optional[str] = None
-) -> str:
-    res: str = f'mongodb://'
-    if mongo_user:
-        res += f"{mongo_user}"
-        if mongo_password:
-            res += f":{quote(mongo_password)}"
-        res += "@"
-    res += f"{mongo_hostname}:{mongo_port}"
-    if mongo_auth_db is not None:
-        res += f"/?authSource={mongo_auth_db}"
-
-    return res
-
-
 class EasyMongoDb:
     def __init__(
             self,

arpakitlib/ar_settings_util.py

@@ -8,12 +8,24 @@ from pydantic_settings import BaseSettings
 _ARPAKIT_LIB_MODULE_VERSION = "3.0"
 
 
-def generate_env_example(settings_class: Union[BaseSettings, type[BaseSettings]]):
+def generate_env_example(settings_class: Union[BaseSettings, type[BaseSettings]]) -> str:
     res = ""
     for k, f in settings_class.model_fields.items():
         if f.default is not PydanticUndefined:
-            res += f"# {k}=\n"
+            v = f.default
+            # Приводим к строке для .env
+            if isinstance(v, bool):
+                s = "true" if v else "false"
+            elif v is None:
+                s = "None"
+            else:
+                s = str(v)
+            # Если дефолт — строка с пробелами → в кавычки (экранируем \ и ")
+            if isinstance(v, str) and any(ch.isspace() for ch in v):
+                s = '"' + s.replace("\\", "\\\\").replace('"', '\\"') + '"'
+            res += f"{k}={s}\n"
         else:
+            # обязательное поле — без значения
             res += f"{k}=\n"
     return res
 
@@ -25,8 +37,17 @@ class SimpleSettings(BaseSettings):
     @classmethod
     def validate_all_fields(cls, values: dict[str, Any]) -> dict[str, Any]:
         for key, value in values.items():
-            if isinstance(value, str) and value.lower().strip() in {"null", "none", "nil"}:
+            if not isinstance(value, str):
+                continue
+            if value.lower().strip() in {"null", "none", "nil"}:
                 values[key] = None
+            elif value.lower().strip() == "default_value":
+                field = cls.model_fields.get(key)
+                if field is not None:
+                    if field.default is not None:
+                        values[key] = field.default
+                    elif field.default_factory is not None:
+                        values[key] = field.default_factory()
         return values
 
     @classmethod

arpakitlib/ar_sqlalchemy_drop_check_constraints.py

@@ -58,6 +58,9 @@ def drop_sqlalchemy_check_constraints(*, base_: type[DeclarativeBase], engine: E
         conn_inspection_ = sqlalchemy.inspect(conn)
 
         for table in base_.metadata.tables.values():
+            if not conn_inspection_.has_table(table.name, schema=table.schema):
+                continue
+
             fqtn = _qualified_name(table.schema, table.name, engine.dialect.name)
 
             # берём ВСЕ реальные CHECK-и из базы

arpakitlib/ar_sqlalchemy_util.py

@@ -3,7 +3,6 @@ import asyncio
 import logging
 from datetime import timedelta, datetime
 from typing import Any, Collection
-from urllib.parse import quote_plus
 from uuid import uuid4
 
 import sqlalchemy
@@ -17,44 +16,6 @@ from arpakitlib.ar_datetime_util import now_utc_dt
 _ARPAKIT_LIB_MODULE_VERSION = "3.0"
 
 
-def generate_sqlalchemy_url(
-        *,
-        base: str = "postgresql",
-        user: str | None = None,
-        password: str | None = None,
-        host: str | None = "127.0.0.1",
-        port: int | None = 5432,
-        database: str | None = None,
-        **query_params
-) -> str | None:
-    if host is None or port is None:
-        return None
-
-    auth_part = ""
-    if user and password:
-        auth_part = f"{quote_plus(user)}:{quote_plus(password)}@"
-    elif user:
-        auth_part = f"{quote_plus(user)}@"
-
-    if base.startswith("sqlite"):
-        host_part = ""
-    else:
-        host_part = f"{host}"
-        if port:
-            host_part += f":{port}"
-
-    database_part = f"/{database}" if database else ""
-    if base.startswith("sqlite") and database:
-        database_part = f"/{database}"
-
-    query_part = ""
-    if query_params:
-        query_items = [f"{key}={quote_plus(str(value))}" for key, value in query_params.items()]
-        query_part = f"?{'&'.join(query_items)}"
-
-    return f"{base}://{auth_part}{host_part}{database_part}{query_part}"
-
-
 class BaseDBM(DeclarativeBase):
     __abstract__ = True
     __table_args__ = {"extend_existing": True}
@@ -333,9 +294,11 @@ class SQLAlchemyDb:
         self.base_dbm.metadata.drop_all(bind=self.engine, checkfirst=True)
         self._logger.info("dropped")
 
-    def reinit(self):
+    def reinit(self, ensure_check_constraints: bool = True):
         self.base_dbm.metadata.drop_all(bind=self.engine, checkfirst=True)
         self.base_dbm.metadata.create_all(bind=self.engine, checkfirst=True)
+        if ensure_check_constraints:
+            self.ensure_check_constraints()
         self._logger.info("reinited")
 
     def reinit_all(self):

arpakitlib/ar_uppercase_env_keys.py

@@ -13,14 +13,16 @@ LINE_RE = re.compile(r"""
     $
 """, re.VERBOSE)
 
-COMMENT_RE = re.compile(r"^\s*#")
+COMMENT_KEY_RE = re.compile(r"^(\s*#\s*)([A-Za-z_][A-Za-z0-9_]*)(\s*=\s*.*)$")
 
 
-def uppercase_env_keys(*, path: str | Path,
-                       output: Optional[str | Path] = None,
-                       backup: bool = False) -> Path:
+def uppercase_env_keys(
+        *, path: str | Path,
+        output: Optional[str | Path] = None,
+        backup: bool = False
+) -> Path:
     """
-    Преобразует имена переменных в .env в верхний регистр.
+    Преобразует имена переменных в .env и в комментариях в верхний регистр.
 
     :param path: путь к исходному .env
     :param output: путь к файлу вывода. Если None — правит на месте.
@@ -33,18 +35,29 @@ def uppercase_env_keys(*, path: str | Path,
 
     text = src.read_text(encoding="utf-8-sig").splitlines(keepends=True)
 
-    seen_upper = set()
     out_lines = []
 
     for line in text:
-        # комментарии и пустые строки — как есть
-        if not line.strip() or COMMENT_RE.match(line):
+        stripped = line.strip()
+
+        # пустые строки — оставляем как есть
+        if not stripped:
             out_lines.append(line)
             continue
 
+        # комментарий с "ключом" вида # KEY=
+        m_comment = COMMENT_KEY_RE.match(line.rstrip("\n"))
+        if m_comment:
+            prefix, key, rest = m_comment.groups()
+            key_up = key.upper()
+            # сохраняем оригинальный символ конца строки, если он был
+            newline = "\n" if line.endswith("\n") else ""
+            out_lines.append(f"{prefix}{key_up}{rest}{newline}")
+            continue
+
+        # стандартная строка с KEY=VAL
         m = LINE_RE.match(line.rstrip("\n"))
         if not m:
-            # строки без "=" или нестандартные — не трогаем
             out_lines.append(line)
             continue
 
@@ -55,12 +68,10 @@ def uppercase_env_keys(*, path: str | Path,
         val = m.group("val")
 
         key_up = key.upper()
-        # аккуратно соберем строку обратно (сохраняя пробелы/формат)
-        new_line = f"{lead}{(export_kw + ' ') if export_kw else ''}{key_up}{eq}{val}\n"
+        newline = "\n" if line.endswith("\n") else ""
+        new_line = f"{lead}{(export_kw + ' ') if export_kw else ''}{key_up}{eq}{val}{newline}"
         out_lines.append(new_line)
 
-        seen_upper.add(key_up)
-
     # запись
     if output is None:
         if backup:

arpakitlib/ar_yookassa_api_client_util.py

@@ -0,0 +1,175 @@
+from __future__ import annotations
+
+import asyncio
+import logging
+import uuid
+from datetime import timedelta
+from typing import Any
+
+import aiohttp
+import requests
+from arpakitlib.ar_dict_util import combine_dicts
+from arpakitlib.ar_enumeration_util import Enumeration
+from arpakitlib.ar_http_request_util import sync_make_http_request, async_make_http_request
+from arpakitlib.ar_type_util import raise_for_type
+
+"""
+https://yookassa.ru/developers/api
+"""
+
+
+class YookassaAPIClient:
+    class PaymentStatuses(Enumeration):
+        pending = "pending"
+        waiting_for_capture = "waiting_for_capture"
+        succeeded = "succeeded"
+        canceled = "canceled"
+
+    def __init__(self, *, secret_key: str, shop_id: int):
+        super().__init__()
+        self.secret_key = secret_key
+        self.shop_id = shop_id
+        self.headers = {"Content-Type": "application/json"}
+        self._logger = logging.getLogger(f"{self.__class__.__name__}-{shop_id}")
+
+    def _sync_make_http_request(
+            self,
+            *,
+            method: str,
+            url: str,
+            headers: dict[str, Any] | None = None,
+            **kwargs
+    ) -> requests.Response:
+        return sync_make_http_request(
+            method=method,
+            url=url,
+            headers=combine_dicts(self.headers, (headers if headers is not None else {})),
+            max_tries_=3,
+            raise_for_status_=True,
+            timeout_=timedelta(seconds=3),
+            not_raise_for_statuses_=[404],
+            auth=(self.shop_id, self.secret_key),
+            enable_logging_=False,
+            **kwargs
+        )
+
+    async def _async_make_http_request(
+            self,
+            *,
+            method: str = "GET",
+            url: str,
+            headers: dict[str, Any] | None = None,
+            **kwargs
+    ) -> aiohttp.ClientResponse:
+        return await async_make_http_request(
+            method=method,
+            url=url,
+            headers=combine_dicts(self.headers, (headers if headers is not None else {})),
+            max_tries_=3,
+            raise_for_status_=True,
+            not_raise_for_statuses_=[404],
+            timeout_=timedelta(seconds=3),
+            auth=aiohttp.BasicAuth(login=str(self.shop_id), password=self.secret_key),
+            enable_logging_=False,
+            **kwargs
+        )
+
+    def sync_create_payment(self, *, json_body: dict[str, Any]) -> dict[str, Any]:
+
+        """
+        json_body example
+        json_body = {
+            "amount": {
+                "value": "2.0",
+                "currency": "RUB"
+            },
+            "description": "description",
+            "confirmation": {
+                "type": "redirect",
+                "return_url": f"https://t.me/{get_tg_bot_username()}",
+                "locale": "ru_RU"
+            },
+            "capture": True,
+            "metadata": {},
+            "merchant_customer_id": ""
+        }
+        """
+
+        response = self._sync_make_http_request(
+            method="POST",
+            url="https://api.yookassa.ru/v3/payments",
+            headers={"Idempotence-Key": str(uuid.uuid4())},
+            json=json_body,
+        )
+        json_data = response.json()
+        response.raise_for_status()
+        return json_data
+
+    def sync_get_payment(self, *, payment_id: str) -> dict[str, Any] | None:
+        raise_for_type(payment_id, str)
+        response = self._sync_make_http_request(
+            method="GET",
+            url=f"https://api.yookassa.ru/v3/payments/{payment_id}",
+            headers=self.headers
+        )
+        json_data = response.json()
+        if response.status_code == 404:
+            return None
+        response.raise_for_status()
+        return json_data
+
+    async def async_create_payment(self, *, json_body: dict[str, Any]) -> dict[str, Any]:
+
+        """
+        json_body example
+        json_body = {
+            "amount": {
+                "value": "2.0",
+                "currency": "RUB"
+            },
+            "description": "description",
+            "confirmation": {
+                "type": "redirect",
+                "return_url": f"https://t.me/{get_tg_bot_username()}",
+                "locale": "ru_RU"
+            },
+            "capture": True,
+            "metadata": {},
+            "merchant_customer_id": ""
+        }
+        """
+
+        response = await self._async_make_http_request(
+            method="POST",
+            url="https://api.yookassa.ru/v3/payments",
+            headers={"Idempotence-Key": str(uuid.uuid4())},
+            json=json_body,
+        )
+        json_data = await response.json()
+        response.raise_for_status()
+        return json_data
+
+    async def async_get_payment(self, *, payment_id: str) -> dict[str, Any] | None:
+        raise_for_type(payment_id, str)
+        response = await self._async_make_http_request(
+            method="GET",
+            url=f"https://api.yookassa.ru/v3/payments/{payment_id}",
+        )
+        json_data = await response.json()
+        if response.status == 404:
+            return None
+        response.raise_for_status()
+        return json_data
+
+
+def __example():
+    pass
+
+
+async def __async_example():
+    pass
+
+
+if __name__ == '__main__':
+    __example()
+    asyncio.run(__async_example())

arpakitlib/include_fastapi_routers_from_dir.py

@@ -0,0 +1,46 @@
+import importlib.util
+import os
+from fastapi import APIRouter
+
+
+def include_fastapi_routers_from_dir(
+        *,
+        router: APIRouter,
+        base_dir: str = ".",
+        exclude_filenames: list[str] | None = None,
+):
+    """
+    Рекурсивно ищет все .py файлы с объектом `api_router` типа APIRouter
+    и подключает их к переданному `router`.
+
+    Префикс = имя файла без .py
+    exclude_filenames — список имён файлов, которые нужно пропустить (без путей)
+    """
+    if exclude_filenames is None:
+        exclude_filenames = ["__init__.py"]
+
+    for root, _, files in os.walk(base_dir):
+        files.sort()
+
+        for filename in files:
+            if not filename.endswith(".py") or filename in exclude_filenames:
+                continue
+
+            file_path = os.path.join(root, filename)
+            module_name = (
+                os.path.relpath(file_path, base_dir)
+                .replace(os.sep, ".")
+                .removesuffix(".py")
+            )
+
+            spec = importlib.util.spec_from_file_location(module_name, file_path)
+            module = importlib.util.module_from_spec(spec)
+            spec.loader.exec_module(module)
+
+            api_router = getattr(module, "api_router", None)
+            if isinstance(api_router, APIRouter):
+                prefix = "/" + filename[:-3]  # имя файла без .py
+                router.include_router(
+                    router=api_router,
+                    prefix=prefix
+                )

{arpakitlib-1.8.307.dist-info → arpakitlib-1.8.322.dist-info}/METADATA

@@ -1,8 +1,8 @@
 Metadata-Version: 2.4
 Name: arpakitlib
-Version: 1.8.307
+Version: 1.8.322
 Summary: arpakitlib
-License: Apache-2.0
+License-Expression: Apache-2.0
 License-File: LICENSE
 Keywords: arpakitlib,arpakit,arpakit-company,arpakitcompany,arpakit_company
 Author: arpakit_company

{arpakitlib-1.8.307.dist-info → arpakitlib-1.8.322.dist-info}/RECORD

@@ -375,12 +375,9 @@ arpakitlib/_arpakit_project_template_v_5/project/util/arpakitlib_project_templat
 arpakitlib/_arpakit_project_template_v_5/project/util/etc.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 arpakitlib/_arpakit_project_template_v_5/project/util/send_email_.py,sha256=AZ2PHRQh-l7H3WLxgxygEKD8c_WPguIq4weP2zqfF9I,4748
 arpakitlib/_arpakit_project_template_v_5/todo.txt,sha256=q132Jbx229ThY77S3YiN-Cj5AVm7k1VlJcMYIbZUHUY,3
-arpakitlib/ar_additional_model_util.py,sha256=GFg-glLCxH9X95R2bhTJsscVwv37FgE1qbaAAyXrnIE,917
 arpakitlib/ar_aiogram_as_tg_command_util.py,sha256=4bizX5Xg-E2-r2TXXGQGanJozsIWPVf5luO3vKUN8p8,8471
 arpakitlib/ar_arpakit_lib_module_util.py,sha256=g9uWwTK2eEzmErqwYeVgXDYVMREN8m5CdmgEumAEQfw,5919
 arpakitlib/ar_arpakit_project_template_util.py,sha256=5-o6eTmh-2DqsIqmo63SXw7ttExhmuAehMNc4s0GdtU,3278
-arpakitlib/ar_arpakit_schedule_uust_api_client_util.py,sha256=MRPaF31CRhYA45ldPnoRpaTPMazCJq0jbwDxW5rvMww,12937
-arpakitlib/ar_arpakit_schedule_uust_site_util.py,sha256=8wLct9Gd4MWkXzB6nSmETAwTPLw8lfpWgx0LoWSAOvg,1643
 arpakitlib/ar_arpakitlib_cli_util.py,sha256=RJGcfEZ_q74FJ4tqdXvt7xQpShTszOvKu1mbp3D8qzw,2599
 arpakitlib/ar_base64_util.py,sha256=udSSpeXMZx0JgQknl4hQgZ8kr1Ps_aQOloIXu4T9dMQ,1286
 arpakitlib/ar_base_worker_util.py,sha256=4XN29vkju1OBmvZj1MVjxGXVWQzcs9Sdd90JBj1QoFg,6336
@@ -391,13 +388,13 @@ arpakitlib/ar_clone_pydantic_model_fields.py,sha256=5i77NGEjnY2ppk_Ot179egQGNDvg
 arpakitlib/ar_datetime_util.py,sha256=3Pw8ljsBKkkEUCmu1PsnJqNeG5bVLqtpsUGaztJF8jQ,1432
 arpakitlib/ar_dict_util.py,sha256=oet-9AJEjQZfG_EI82BuYW0jdW2NQxKjPXol_nfTXjw,447
 arpakitlib/ar_encrypt_decrypt_util.py,sha256=GhWnp7HHkbhwFVVCzO1H07m-5gryr4yjWsXjOaNQm1Y,520
-arpakitlib/ar_ensure_sqlalchemy_check_constraints.py,sha256=JJbgaUiLT8D8oDVevP25wlMz1BTtx0JMasJ_ILyIJ3o,5328
+arpakitlib/ar_ensure_sqlalchemy_check_constraints.py,sha256=gqZTPSCAPUMRiXcmv9xls5S8YkUAg-gwFIEvqQsJ_JM,5437
 arpakitlib/ar_enumeration_util.py,sha256=XoFInWtGzbIr6fJq0un5nettaDfOLAyY84ovwj7n_7g,3030
 arpakitlib/ar_exception_util.py,sha256=3hZKsj34TZVdmd4JAQz7w515smWqB8o3gTwAEjuMdnI,408
 arpakitlib/ar_file_storage_in_dir_util.py,sha256=Zh922S6-aIy0p_Fen8GTTrGpixpPQ6c-wFLukiSK4Ck,4091
 arpakitlib/ar_file_util.py,sha256=GUdJYm1tUZnYpY-SIPRHAZBHGra8NKy1eYEI0D5AfhY,489
 arpakitlib/ar_func_util.py,sha256=lG0bx_DtxWN4skbUim0liRZ6WUyLVV8Qfk6iZNtCZOs,1042
-arpakitlib/ar_generate_celery_url.py,sha256=ddzOokXKZRGRDQu18amnW5ZaekcMihwsmyUn0FzpgVU,2274
+arpakitlib/ar_generate_connection_url_util.py,sha256=sU55IA0v3TZ5PzJgc01Q9cABIzF9BrgSXu4USxOIlVY,2665
 arpakitlib/ar_generate_simple_code.py,sha256=EkrebrTi7sArSRAuxvN5BPm_A0-dFSCZgdoJhx5kPhk,344
 arpakitlib/ar_hash_util.py,sha256=Iqy6KBAOLBQMFLWv676boI5sV7atT2B-fb7aCdHOmIQ,340
 arpakitlib/ar_http_request_util.py,sha256=PCUtGOQIvNScrLqD_9Z8LqT-7a-lP2y-Y-CH5vGdn7Q,7663
@@ -409,7 +406,7 @@ arpakitlib/ar_list_of_dicts_to_xlsx.py,sha256=MyjEl4Jl4beLVZqLVQMMv0-XDtBD3Xh4Z_
 arpakitlib/ar_list_util.py,sha256=xaUk2BnLvDMP5HDh_GFfH-nIXCg-f8NsrrUKXRcVUsU,1788
 arpakitlib/ar_log_async_func_if_error.py,sha256=qtr_eK9o1BrcA_7S9Ns7nVmOS81Yv6eMXHdasc4MftQ,495
 arpakitlib/ar_logging_util.py,sha256=Q9R4-Cx3TAn3VLcKyNFeKS3luYBouj-umR6_TSKmVYw,1336
-arpakitlib/ar_mongodb_util.py,sha256=2ECkTnGAZ92qxioL-fmN6R4yZOSr3bXdXLWTzT1C3vk,4038
+arpakitlib/ar_mongodb_util.py,sha256=orRb81o9CzD9kkWbbNQCbSMTl2xLcctUDdx_FxirKww,3411
 arpakitlib/ar_need_type_util.py,sha256=XmY1kswz8j9oo5f9CxRu0_zgfvxWrXPYKOj6MM04sGk,2604
 arpakitlib/ar_parse_command.py,sha256=1WTdQoWVshoDZ1jDaKeTzajfqaYHP3FNO0-REyo1aMY,3003
 arpakitlib/ar_postgresql_util.py,sha256=1AuLjEaa1Lg4pzn-ukCVnDi35Eg1k91APRTqZhIJAdo,945
@@ -421,17 +418,18 @@ arpakitlib/ar_really_validate_url.py,sha256=aaSPVMbz2DSqlC2yk2g44-kTIiHlITfJwIG9
 arpakitlib/ar_retry_func_util.py,sha256=LB4FJRsu2cssnPw6X8bCEcaGpQsXhkLkgeU37w1t9fU,2250
 arpakitlib/ar_run_cmd_util.py,sha256=D_rPavKMmWkQtwvZFz-Io5Ak8eSODHkcFeLPzNVC68g,1072
 arpakitlib/ar_safe_func.py,sha256=JQNaM3q4Z6nUE8bDfzXNBGkWSXm0PZ-GMMvu6UWUIYk,2400
-arpakitlib/ar_schedule_uust_api_client_util.py,sha256=rXI2_3OTaIBgR-GixM1Ti-Ue1f9nOcO3EUpYRqdGpYM,6973
-arpakitlib/ar_settings_util.py,sha256=Y5wi_cmsjDjfJpM0VJHjbo0NoVPKfypKaD1USowwDtQ,1327
+arpakitlib/ar_settings_util.py,sha256=FeQQkuVrLVYkFAIg3Wy6ysyTt_sqLTX0REAe60gbM3k,2361
 arpakitlib/ar_sleep_util.py,sha256=ggaj7ML6QK_ADsHMcyu6GUmUpQ_9B9n-SKYH17h-9lM,1045
 arpakitlib/ar_sqladmin_util.py,sha256=SEoaowAPF3lhxPsNjwmOymNJ55Ty9rmzvsDm7gD5Ceo,861
-arpakitlib/ar_sqlalchemy_drop_check_constraints.py,sha256=XEqnMrIwSYasW_UOJ8xU-JhsVrcYeyehalFuSvmJMak,3518
-arpakitlib/ar_sqlalchemy_util.py,sha256=vWNCzFv13YsGRZaemkNI1_BF__4Z1_Vqm-gqQL1PRrQ,17034
+arpakitlib/ar_sqlalchemy_drop_check_constraints.py,sha256=uVktYLjNHrMPWQAq8eBpapShPKbLb3LrRBnnss3gaYY,3624
+arpakitlib/ar_sqlalchemy_util.py,sha256=_7sGYLgKAq_YYVuphyc9yXlaGbV-FTmLI2uEnNwBmjE,16040
 arpakitlib/ar_str_util.py,sha256=2lGpnXDf2h1cBZpVf5i1tX_HCv5iBd6IGnrCw4QWWlY,4350
 arpakitlib/ar_type_util.py,sha256=Cs_tef-Fc5xeyAF54KgISCsP11NHyzIsglm4S3Xx7iM,4049
-arpakitlib/ar_uppercase_env_keys.py,sha256=UFHLGIR70UB02eD7IAIBrZIbycwWCx3OP_W4J2cx2Jw,2395
-arpakitlib-1.8.307.dist-info/METADATA,sha256=oYo45m-EQwszIIuS46JanZzDJVMj6LLAMnapYJcRLP8,3793
-arpakitlib-1.8.307.dist-info/WHEEL,sha256=zp0Cn7JsFoX2ATtOhtaFYIiE2rmFAD4OcMhtUki8W3U,88
-arpakitlib-1.8.307.dist-info/entry_points.txt,sha256=36xqR3PJFT2kuwjkM_EqoIy0qFUDPKSm_mJaI7emewE,87
-arpakitlib-1.8.307.dist-info/licenses/LICENSE,sha256=GPEDQMam2r7FSTYqM1mm7aKnxLaWcBotH7UvQtea-ec,11355
-arpakitlib-1.8.307.dist-info/RECORD,,
+arpakitlib/ar_uppercase_env_keys.py,sha256=BsUCJhfchBIav0AE54_tVgYcE4p1JYoWdPGCHWZnROA,2790
+arpakitlib/ar_yookassa_api_client_util.py,sha256=Mst07IblAJmU98HfOfJqT_RRfnuGrIB1UOQunGGWO8I,5264
+arpakitlib/include_fastapi_routers_from_dir.py,sha256=Umg16sPQC6R-T8FD7mlmqP1TbgH-_v2eDasrZJzImQM,1606
+arpakitlib-1.8.322.dist-info/METADATA,sha256=7I4FON25AN9tOuK2iozXNi4M_4F3t1FJkbpfWCFrO08,3804
+arpakitlib-1.8.322.dist-info/WHEEL,sha256=zp0Cn7JsFoX2ATtOhtaFYIiE2rmFAD4OcMhtUki8W3U,88
+arpakitlib-1.8.322.dist-info/entry_points.txt,sha256=36xqR3PJFT2kuwjkM_EqoIy0qFUDPKSm_mJaI7emewE,87
+arpakitlib-1.8.322.dist-info/licenses/LICENSE,sha256=GPEDQMam2r7FSTYqM1mm7aKnxLaWcBotH7UvQtea-ec,11355
+arpakitlib-1.8.322.dist-info/RECORD,,

arpakitlib/ar_additional_model_util.py

@@ -1,40 +0,0 @@
-# arpakit
-from typing import Any
-
-from pydantic import BaseModel, ConfigDict
-
-_ARPAKIT_LIB_MODULE_VERSION = "3.0"
-
-
-class BaseAM(BaseModel):
-    model_config = ConfigDict(extra="forbid", arbitrary_types_allowed=True, from_attributes=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 __example():
-    class UserAM(BaseAM):
-        id: int
-        name: str
-        email: str
-
-        @property
-        def bus_data_age(self) -> int | None:
-            return self.bus_data.get("age")
-
-    user = UserAM(id=1, name="John Doe", email="john.doe@example.com")
-    print(user.name)  # John Doe
-
-    # bus_data
-    user.bus_data["age"] = 22
-    print(user.bus_data)  # {'age': '22'}
-    print(user.bus_data_age)  # 22
-
-
-if __name__ == '__main__':
-    __example()