arpakitlib 1.8.307__tar.gz → 1.8.322__tar.gz

{arpakitlib-1.8.307 → arpakitlib-1.8.322}/PKG-INFO

@@ -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 → arpakitlib-1.8.322}/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-1.8.322/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-1.8.307 → arpakitlib-1.8.322}/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-1.8.307 → arpakitlib-1.8.322}/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-1.8.307 → arpakitlib-1.8.322}/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-1.8.307 → arpakitlib-1.8.322}/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-1.8.307 → arpakitlib-1.8.322}/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-1.8.322/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-1.8.322/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 → arpakitlib-1.8.322}/pyproject.toml

@@ -1,11 +1,12 @@
 [project]
 name = "arpakitlib"
-version = "1.8.307"
+version = "1.8.322"
 description = "arpakitlib"
 authors = [
     { name = "arpakit_company", email = "support@arpakit.com" }
 ]
-license = { text = "Apache License 2.0" }
+license = "Apache-2.0"
+license-files = ["LICENSE"]
 readme = "README.md"
 keywords = ["arpakitlib", "arpakit", "arpakit-company", "arpakitcompany", "arpakit_company"]
 requires-python = ">=3.12.4,<4.0"

arpakitlib-1.8.307/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()