arpakitlib 1.8.336__tar.gz → 1.9.6__tar.gz

{arpakitlib-1.8.336 → arpakitlib-1.9.6}/LICENSE

@@ -186,7 +186,7 @@
       same "printed page" as the copyright notice for easier
       identification within third-party archives.
 
-   Copyright 2024-present Arsen Sabirzyanov
+   Copyright 2024-present ARPAKIT-Company
 
    Licensed under the Apache License, Version 2.0 (the "License");
    you may not use this file except in compliance with the License.

{arpakitlib-1.8.336 → arpakitlib-1.9.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: arpakitlib
-Version: 1.8.336
+Version: 1.9.6
 Summary: arpakitlib
 License-Expression: Apache-2.0
 License-File: LICENSE
@@ -72,13 +72,15 @@ Description-Content-Type: text/markdown
 
 # arpakitlib
 
-## Текущая версия шаблона arpakit_project_template_v_5 находится в разработке, она неверная. В скором времени будет stable version.
-
 ## 🚀 Simplify Your Development Workflow
 
-A collection of lightweight and convenient development tools by Arpakit, designed to simplify and accelerate your
+A collection of lightweight and convenient development tools by arpakit, designed to simplify and accelerate your
 workflow
 
+## Important
+
+The most up-to-date version is on GitHub or GitLab.
+
 ---
 
 ### Supported Python version
@@ -90,31 +92,11 @@ workflow
 ### Installation with Poetry
 
 ```
-poetry add arpakitlib
-```
-
-### Installation with pip
-
-```
-pip install arpakitlib
-```
-
-### arpakitlib command
-
-```
-poetry run arpakitlib -c help
-poetry run arpakitlib -c init_arpakit_project_template -version 5 -project_dirpath ./ -overwrite_if_exists true
+poetry add git+https://github.com/ARPAKIT-Company/arpakitlib.git@master
 ```
 
 ---
 
-### Links
-
-- https://pypi.org/project/arpakitlib/
-- https://test.pypi.org/project/arpakitlib/
-- https://github.com/ARPAKIT-Company/arpakitlib
-
----
 
 ## ❤️ Made by ARPAKIT Company ❤️
 

arpakitlib-1.9.6/README.md

@@ -0,0 +1,31 @@
+# arpakitlib
+
+## 🚀 Simplify Your Development Workflow
+
+A collection of lightweight and convenient development tools by arpakit, designed to simplify and accelerate your
+workflow
+
+## Important
+
+The most up-to-date version is on GitHub or GitLab.
+
+---
+
+### Supported Python version
+
+- Python 3.12.4
+
+---
+
+### Installation with Poetry
+
+```
+poetry add git+https://github.com/ARPAKIT-Company/arpakitlib.git@master
+```
+
+---
+
+
+## ❤️ Made by ARPAKIT Company ❤️
+
+

arpakitlib-1.9.6/arpakitlib/ar_aiogram_as_tg_command_2_util.py

@@ -0,0 +1,192 @@
+# arpakit
+import ast
+import asyncio
+import json
+import logging
+from typing import Any, get_origin, get_args, Awaitable, Callable
+
+from aiogram import types
+from aiogram.enums import ParseMode
+from aiogram.filters import CommandObject
+from pydantic import BaseModel, Field, ConfigDict
+from pydantic_core import PydanticUndefined
+
+from arpakitlib.ar_parse_command_util import parse_command
+
+_ARPAKIT_LIB_MODULE_VERSION = "3.0"
+
+_logger = logging.getLogger(__name__)
+
+
+class BaseTgCommandModel(BaseModel):
+    model_config = ConfigDict(extra="ignore", arbitrary_types_allowed=True, from_attributes=True)
+
+    help: bool | None = Field(default=False)
+
+
+class ExampleTgCommandModel(BaseTgCommandModel):
+    """Это описание команды hello-world"""
+
+    hello: str | None = Field(description="Example Desc", default="Hello world")
+
+
+def _generate_help_text(
+        *,
+        command_name: str,
+        model_class: type[BaseTgCommandModel],
+        desc: str | None = None
+) -> str:
+    """Генерирует help-текст по описанию модели."""
+    lines = [f"<b>Command</b> /{command_name}"]
+
+    if desc:
+        desc = desc.strip()
+        if desc:
+            lines.append(f"\n{desc}")
+
+    lines.append(f"\n\n<b>Fields ({len(model_class.model_fields)}):</b>")
+
+    for name, field in model_class.model_fields.items():
+
+        default_value = (
+            field.default
+            if field.default is not PydanticUndefined
+            else "<i>required</i>"
+        )
+
+        origin = get_origin(field.annotation)
+        args = get_args(field.annotation)
+
+        if origin is list and args:
+            type_name = f"list[{args[0].__name__}]"
+        elif hasattr(field.annotation, "__name__"):
+            type_name = field.annotation.__name__
+        else:
+            type_name = str(field.annotation)
+
+        description = f" — {field.description}" if field.description else ""
+
+        lines.append(f"\n• <code>-{name}</code>: <i>{type_name}</i>{description} (default: {default_value})")
+
+    lines.append(f"\n\n<b>Usage for help:</b>\n<code>/{command_name} -help</code>")
+
+    return "\n".join(lines)
+
+
+def _parse_tg_param(value: Any) -> Any:
+    """Интеллектуальное преобразование строки из Telegram-команды в Python-значение."""
+    if isinstance(value, (bool, int, float)) or value is None:
+        return value
+
+    v = value.strip()
+    if v.lower() in {"true", "false"}:
+        return v.lower() == "true"
+
+    try:
+        result = ast.literal_eval(v)
+        # Если получился список — проверим, не смесь ли типов
+        if isinstance(result, list):
+            # Если все элементы одного типа — оставляем
+            if len(result) > 0 and len({type(x) for x in result}) > 1:
+                # Приводим всё к строкам для единообразия
+                result = [str(x) for x in result]
+        return result
+    except Exception:
+        # не получилось распарсить — возвращаем как строку
+        pass
+
+    try:
+        result = json.loads(v)
+        return result
+    except Exception:
+        pass
+
+    return v
+
+
+def as_tg_command_handler(
+        *,
+        tg_command_format_class: type[BaseTgCommandModel],
+        desc: str | None = None
+) -> Callable[[Callable[..., Awaitable[Any]]], Callable[..., Awaitable[Any]]]:
+    def decorator(handler):
+
+        async def new_handler(*args, **kwargs):
+
+            message: types.Message = args[0]
+            if not isinstance(message, types.Message):
+                raise TypeError("not isinstance(message, types.Message)")
+
+            tg_command: CommandObject = kwargs.get("command")
+            if tg_command is None:
+                raise ValueError("Missing 'command' in handler kwargs")
+
+            try:
+
+                parsed_command = parse_command(text=tg_command.text)
+                kwargs["parsed_command"] = parsed_command
+
+                if parsed_command.has_flag(flag="help") or parsed_command.has_flag(flag="h"):
+                    await message.answer(
+                        text=_generate_help_text(
+                            command_name=tg_command.command,
+                            model_class=tg_command_format_class,
+                            desc=desc
+                        ),
+                        disable_web_page_preview=True,
+                        parse_mode=ParseMode.HTML
+                    )
+                    return None
+
+                tg_command_model_data: dict[str, Any] = {}
+
+                for key, value in parsed_command.key_to_value.items():
+                    if value is None:
+                        tg_command_model_data[key] = True
+                    else:
+                        tg_command_model_data[key] = _parse_tg_param(value=value)
+
+                for i, value in enumerate(parsed_command.values_without_key):
+                    tg_command_model_data[f"arg_{i}"] = _parse_tg_param(value=value)
+
+                tg_command_format_obj = tg_command_format_class(**tg_command_model_data)
+
+                kwargs["tg_command_format_obj"] = tg_command_format_obj
+
+            except Exception as exception:
+
+                _logger.exception("Error while parsing command %s", tg_command.text, exc_info=True)
+
+                await message.answer(
+                    text=(
+                        f"<b>Bad command usage</b> /{tg_command.command}"
+                        f"\n"
+                        f"\n<b>Error:</b>"
+                        f"\n{exception}"
+                        f"\n"
+                        f"\nUse <code>/{tg_command.command} -help</code> for help info"
+                    ),
+                    disable_web_page_preview=True,
+                    parse_mode=ParseMode.HTML
+                )
+
+                return None
+
+            return await handler(*args, **kwargs)
+
+        return new_handler
+
+    return decorator
+
+
+def __example():
+    pass
+
+
+async def __async_example():
+    pass
+
+
+if __name__ == '__main__':
+    __example()
+    asyncio.run(__async_example())

{arpakitlib-1.8.336 → arpakitlib-1.9.6}/arpakitlib/ar_aiogram_as_tg_command_util.py

@@ -1,7 +1,9 @@
 # arpakit
+# DEPRECATED
 
 import asyncio
 import logging
+from pathlib import Path
 from typing import Optional, Any, Callable
 
 from aiogram import types
@@ -17,6 +19,8 @@ _ARPAKIT_LIB_MODULE_VERSION = "3.0"
 
 _logger = logging.getLogger(__name__)
 
+_logger.warning(f"Module '{Path(__file__).name}' is deprecated; use 'ar_aiogram_as_tg_command_2_util' instead.")
+
 
 class BadTgCommandFormat(BadCommandFormat):
     pass

{arpakitlib-1.8.336 → arpakitlib-1.9.6}/arpakitlib/ar_arpakit_lib_module_util.py

@@ -150,13 +150,7 @@ def get_arpakit_lib_modules() -> ArpakitLibModules:
 
 
 def __example():
-    for module_name, d in (
-            get_arpakit_lib_modules().module_name_to_module_version_and_module_has_errors().items()
-    ):
-        print(module_name)
-        print(d)
-        print()
-    print("have_modules_with_error", get_arpakit_lib_modules().have_modules_with_error())
+    pass
 
 
 if __name__ == '__main__':

{arpakitlib-1.8.336 → arpakitlib-1.9.6}/arpakitlib/ar_base64_util.py

@@ -37,9 +37,7 @@ def convert_file_to_base64_string(*, filepath: str, raise_for_error: bool = Fals
 
 
 def __example():
-    print(convert_base64_string_to_string(
-        base64_string=convert_file_to_base64_string(filepath="./ar_arpakitlib_cli_util.py")
-    ))
+    pass
 
 
 if __name__ == '__main__':

arpakitlib-1.9.6/arpakitlib/ar_base_http_api_client_util.py

@@ -0,0 +1,47 @@
+import logging
+from typing import Any
+
+import aiohttp
+import requests
+
+from arpakitlib.ar_dict_util import combine_dicts
+from arpakitlib.ar_http_request_util import async_make_http_request, sync_make_http_request
+
+
+class BaseHTTPAPIClient:
+    def __init__(self):
+        self.headers = {"Content-Type": "application/json"}
+        self._logger = logging.getLogger(f"{self.__class__.__name__}")
+
+    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 {})),
+            **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 {})),
+            **kwargs
+        )
+
+    def healthcheck(self) -> bool:
+        raise NotImplemented()

{arpakitlib-1.8.336 → arpakitlib-1.9.6}/arpakitlib/ar_base_worker_util.py

@@ -183,7 +183,7 @@ def safe_run_workers_in_background(
 
 
 async def a():
-    print("1")
+    pass
 
 
 def __example():

{arpakitlib-1.8.336 → arpakitlib-1.9.6}/arpakitlib/ar_clone_pydantic_model_fields_util.py

@@ -13,14 +13,14 @@ def clone_pydantic_model_fields(
         base_model: Type[BaseModel] = BaseModel,
         fields_to_remove: Iterable[str] | None = None,
         new_class_name: str | None = None,
-        class_name_prefix: str | None = "Cloned"
+        class_name_suffix: str | None = "Cloned"
 ) -> Type[BaseModel]:
     if fields_to_remove is None:
         fields_to_remove = set()
-    if class_name_prefix is None:
-        class_name_prefix = "Cloned"
+    if class_name_suffix is None:
+        class_name_suffix = "Cloned"
     if new_class_name is None:
-        new_class_name = f"{model_cls.__name__}{class_name_prefix}"
+        new_class_name = f"{model_cls.__name__}{class_name_suffix}"
 
     field_defs: dict[str, tuple[type[Any], Any]] = {}
 

arpakitlib-1.9.6/arpakitlib/ar_dict_util.py

@@ -0,0 +1,59 @@
+# arpakit
+
+from typing import Any
+
+_ARPAKIT_LIB_MODULE_VERSION = "3.0"
+
+
+def combine_dicts(*dicts: dict) -> dict[Any, Any]:
+    res = {}
+    for dict_ in dicts:
+        res.update(dict_)
+    return res
+
+
+def replace_dict_key(*, dict_: dict, old_key: Any, new_key: Any) -> dict[Any, Any]:
+    if old_key in dict_:
+        dict_[new_key] = dict_.pop(old_key)
+    return dict_
+
+
+class GetTypedFromDictException(Exception):
+    pass
+
+
+def get_typed_from_dict(
+        *,
+        d: dict,
+        key: str,
+        type_,
+        allow_missing: bool = False,
+        custom_exception: type[Exception] = GetTypedFromDictException
+) -> Any:
+    """
+    Получает d[key], проверяет, что оно относится к типу typ.
+    Если ключ отсутствует:
+        - если allow_non_existing=True → возвращаем None
+        - иначе → KeyError
+    Если тип не совпадает → TypeError
+    """
+
+    if key not in d:
+        if allow_missing:
+            return None
+        raise custom_exception(f"Missing key: {key}")
+
+    val = d[key]
+
+    if not isinstance(val, type_):
+        raise custom_exception(f"Expected {type_}, got {type(val)} for key '{key}'")
+
+    return val
+
+
+def __example():
+    pass
+
+
+if __name__ == '__main__':
+    __example()

arpakitlib-1.9.6/arpakitlib/ar_exception_util.py

@@ -0,0 +1,18 @@
+import traceback
+
+_ARPAKIT_LIB_MODULE_VERSION = "3.0"
+
+
+def exception_to_traceback_str(exception: BaseException) -> str:
+    try:
+        return "".join(traceback.format_exception(type(exception), exception, exception.__traceback__))
+    except Exception as exception_:
+        return f"Failed to format exception to traceback str {exception!r}: {exception_!r}"
+
+
+def __example():
+    pass
+
+
+if __name__ == '__main__':
+    __example()

{arpakitlib-1.8.336 → arpakitlib-1.9.6}/arpakitlib/ar_generate_connection_url_util.py

@@ -58,21 +58,7 @@ def generate_connection_url(
 
 
 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
+    pass
 
 
 if __name__ == '__main__':

arpakitlib-1.9.6/arpakitlib/ar_generate_difficult_password_util.py

@@ -0,0 +1,41 @@
+import random
+import secrets
+import string
+import uuid
+
+
+def generate_difficult_password(*, difficult: int = 1):
+    # динамический диапазон длины
+    base = 32 + difficult * 16  # минимальная длина
+    variance = 64 + difficult * 32  # насколько может "гулять"
+    target_len = random.randint(base, base + variance)
+
+    alphabet = (
+            string.ascii_letters +
+            string.digits +
+            string.punctuation
+    )
+
+    password = []
+
+    # добавляем случайный шум из UUID блоков
+    for _ in range(difficult * 2):
+        noise_block = uuid.uuid4().hex
+        password.append(noise_block)
+
+    # основная часть пароля — криптостойкие символы
+    for _ in range(target_len):
+        password.append(secrets.choice(alphabet))
+
+    # финальная перемешка обеспечивает нерегулярность структуры
+    secrets.SystemRandom().shuffle(password)
+
+    return "".join(password)
+
+
+def __example():
+    pass
+
+
+if __name__ == '__main__':
+    __example()

{arpakitlib-1.8.336 → arpakitlib-1.9.6}/arpakitlib/ar_generate_simple_code_util.py

@@ -10,7 +10,7 @@ def generate_simple_code(
 
 
 def __example():
-    print(generate_simple_code(amount=5))
+    pass
 
 
 if __name__ == '__main__':

{arpakitlib-1.8.336 → arpakitlib-1.9.6}/arpakitlib/ar_list_util.py

@@ -57,12 +57,30 @@ def remove_from_lists_if_left(
     return lists_
 
 
+def int_to_list_(value: int | list | None) -> list[int] | None:
+    if isinstance(value, int):
+        return [value]
+    elif isinstance(value, list):
+        return value
+    elif value is None:
+        return None
+    else:
+        raise TypeError(f"{type(value)=}")
+
+
+def str_to_list_(value: str | list | None) -> list[str] | None:
+    if isinstance(value, str):
+        return [value]
+    elif isinstance(value, list):
+        return value
+    elif value is None:
+        return None
+    else:
+        raise TypeError(f"{type(value)=}")
+
+
 def __example():
-    a = remove_from_list_if_left(
-        list_=[1, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3],
-        values=[1, 2, 3]
-    )
-    print(a)
+    pass
 
 
 if __name__ == '__main__':

{arpakitlib-1.8.336 → arpakitlib-1.9.6}/arpakitlib/ar_need_type_util.py

@@ -62,17 +62,7 @@ def parse_need_type(value: Any, need_type: str, allow_none: bool = False) -> Any
 
 
 def __example():
-    print(parse_need_type(value=123, need_type="int"))
-    print(parse_need_type(value="True", need_type="bool"))
-    print(parse_need_type(value=123.456, need_type="float"))
-    print(parse_need_type(value='[1, 2, 3]', need_type="list_of_int"))
-    print(parse_need_type(value='["a", "b", "c"]', need_type="list_of_str"))
-    print(parse_need_type(value='[1.1, 2.2, 3.3]', need_type="list_of_float"))
-    print(parse_need_type(value='{"key": "value"}', need_type="json"))
-    print(parse_need_type(value="hello world", need_type="str"))
-    print(parse_need_type(value="[]", need_type=NeedTypes.list_of_str))
-    print(parse_need_type(value="", need_type=NeedTypes.list_of_str))
-    print(parse_need_type(value="none,asfasfas", need_type=NeedTypes.list_of_str))
+    pass
 
 
 if __name__ == '__main__':

{arpakitlib-1.8.336 → arpakitlib-1.9.6}/arpakitlib/ar_pydantic_schema_from_sqlalchemy_model_util.py

@@ -75,8 +75,6 @@ def _type_matches(*, type_: Any, allowed_types: list[type]) -> bool:
     - Annotated (смотрит на базовый тип),
     - generics (List[int], Dict[str, Any]) — сравнивает по origin (list, dict, и т.п.).
     """
-    if type_ is Any:
-        return True
 
     origin = get_origin(type_)
     if origin is Union:  # Optional/Union
@@ -126,7 +124,8 @@ def pydantic_schema_from_sqlalchemy_model(
         remove_property_prefixes: list[str] | None = None,
         skip_property_if_cannot_define_type: bool = True,
         skip_property_name_if_exists: bool = True,
-        model_name_suffix: str = "Schema"
+        model_name_prefix: str | None = "Schema",
+        model_name_suffix: str | None = "Schema",
 ) -> type[BaseModel]:
     """
     Генерирует Pydantic-модель из колонок SQLAlchemy-модели и (опционально) из @property.
@@ -139,7 +138,13 @@ def pydantic_schema_from_sqlalchemy_model(
     - exclude_property_names: blacklist имён свойств (исключаются после whitelist'а).
     """
     mapper = inspect(sqlalchemy_model).mapper
-    model_name = model_name or f"{sqlalchemy_model.__name__}{model_name_suffix}"
+
+    if not model_name:
+        model_name = str(sqlalchemy_model.__name__)
+        if model_name_prefix:
+            model_name = f"{model_name_prefix}{model_name}"
+        if model_name_suffix:
+            model_name = f"{model_name}{model_name_suffix}"
 
     annotations: dict[str, Any] = {}
     attrs: dict[str, Any] = {}

{arpakitlib-1.8.336 → arpakitlib-1.9.6}/arpakitlib/ar_rat_func_util.py

@@ -63,14 +63,7 @@ async def rat_async_func(
 
 
 def __example():
-    def go():
-        return "go"
-
-    a = rat_sync_func(sync_func=go)
-    print(a.has_exception)
-    print(a)
-    print(a.is_func_res_set)
-    print(a.is_func_res_not_set)
+    pass
 
 
 if __name__ == '__main__':