arpakitlib 1.8.307__py3-none-any.whl → 1.8.320__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/include_fastapi_routers_from_dir.py

@@ -0,0 +1,44 @@
+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):
+        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.320.dist-info}/METADATA

@@ -1,8 +1,8 @@
 Metadata-Version: 2.4
 Name: arpakitlib
-Version: 1.8.307
+Version: 1.8.320
 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.320.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,17 @@ 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/include_fastapi_routers_from_dir.py,sha256=2QefsH_P3fHGfv-mAUzq1DDSDpYHWiP3Lco3f9jc2V0,1584
+arpakitlib-1.8.320.dist-info/METADATA,sha256=MRu1SbvEmE9xo48sKTaUB5O8EzOZNk2iHpC_O0xrZZI,3804
+arpakitlib-1.8.320.dist-info/WHEEL,sha256=zp0Cn7JsFoX2ATtOhtaFYIiE2rmFAD4OcMhtUki8W3U,88
+arpakitlib-1.8.320.dist-info/entry_points.txt,sha256=36xqR3PJFT2kuwjkM_EqoIy0qFUDPKSm_mJaI7emewE,87
+arpakitlib-1.8.320.dist-info/licenses/LICENSE,sha256=GPEDQMam2r7FSTYqM1mm7aKnxLaWcBotH7UvQtea-ec,11355
+arpakitlib-1.8.320.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()

arpakitlib/ar_arpakit_schedule_uust_api_client_util.py

@@ -1,422 +0,0 @@
-# arpakit
-
-from __future__ import annotations
-
-import asyncio
-import datetime as dt
-import logging
-from typing import Any
-from urllib.parse import urljoin
-
-import cachetools
-from aiohttp import ClientResponse
-from pydantic import ConfigDict, BaseModel
-
-from arpakitlib.ar_enumeration_util import Enumeration
-from arpakitlib.ar_http_request_util import async_make_http_request
-
-_ARPAKIT_LIB_MODULE_VERSION = "3.0"
-
-
-class Weekdays(Enumeration):
-    monday = 1
-    tuesday = 2
-    wednesday = 3
-    thursday = 4
-    friday = 5
-    saturday = 6
-    sunday = 7
-
-
-class Months(Enumeration):
-    january = 1
-    february = 2
-    march = 3
-    april = 4
-    may = 5
-    june = 6
-    july = 7
-    august = 8
-    september = 9
-    october = 10
-    november = 11
-    december = 12
-
-
-class BaseAPIModel(BaseModel):
-    model_config = ConfigDict(extra="ignore", arbitrary_types_allowed=True, from_attributes=True)
-
-
-class CurrentSemesterAPIModel(BaseAPIModel):
-    id: int
-    long_id: str
-    creation_dt: dt.datetime
-    entity_type: str
-    actualization_dt: dt.datetime
-    value: str
-
-
-class CurrentWeekAPIModel(BaseAPIModel):
-    id: int
-    long_id: str
-    creation_dt: dt.datetime
-    entity_type: str
-    actualization_dt: dt.datetime
-    value: int
-
-
-class GroupAPIModel(BaseAPIModel):
-    id: int
-    long_id: str
-    creation_dt: dt.datetime
-    entity_type: str
-    actualization_dt: dt.datetime
-    uust_api_id: int
-    title: str
-    faculty: str | None
-    course: int | None
-    difference_level: int | None = None
-    uust_api_data: dict[str, Any]
-
-
-class TeacherAPIModel(BaseAPIModel):
-    id: int
-    long_id: str
-    creation_dt: dt.datetime
-    entity_type: str
-    actualization_dt: dt.datetime
-    uust_api_id: int
-    name: str | None
-    surname: str | None
-    patronymic: str | None
-    fullname: str | None
-    shortname: str | None
-    posts: list[str]
-    post: str | None
-    units: list[str]
-    unit: str | None
-    difference_level: int | None
-    uust_api_data: dict[str, Any]
-
-
-class GroupLessonAPIModel(BaseAPIModel):
-    id: int
-    long_id: str
-    creation_dt: dt.datetime
-    entity_type: str
-    actualization_dt: dt.datetime
-    uust_api_id: int
-    type: str
-    title: str
-    weeks: list[int]
-    weekday: int
-    comment: str | None
-    time_title: str | None
-    time_start: dt.time | None
-    time_end: dt.time | None
-    numbers: list[int]
-    location: str | None
-    teacher_uust_api_id: int | None
-    group_uust_api_id: int | None
-    group: GroupAPIModel
-    teacher: TeacherAPIModel | None
-    uust_api_data: dict[str, Any]
-
-    def compare_type(self, *types: str | list[str]) -> bool:
-        type_ = self.type.strip().lower()
-        for type__ in types:
-            if isinstance(type__, str):
-                if type_ == type__.strip().lower():
-                    return True
-            elif isinstance(type__, list):
-                for type___ in type__:
-                    if type_ == type___.strip().lower():
-                        return True
-            else:
-                raise TypeError()
-        return False
-
-
-class TeacherLessonAPIModel(BaseAPIModel):
-    id: int
-    long_id: str
-    creation_dt: dt.datetime
-    entity_type: str
-    actualization_dt: dt.datetime
-    uust_api_id: int
-    type: str
-    title: str
-    weeks: list[int]
-    weekday: int
-    comment: str | None
-    time_title: str | None
-    time_start: dt.time | None
-    time_end: dt.time | None
-    numbers: list[int]
-    location: str | None
-    group_uust_api_ids: list[int]
-    teacher_uust_api_id: int
-    teacher: TeacherAPIModel
-    groups: list[GroupAPIModel]
-    uust_api_data: dict[str, Any]
-
-    def compare_type(self, *types: str | list[str]) -> bool:
-        type_ = self.type.strip().lower()
-        for type__ in types:
-            if isinstance(type__, str):
-                if type_ == type__.strip().lower():
-                    return True
-            elif isinstance(type__, list):
-                for type___ in type__:
-                    if type_ == type___.strip().lower():
-                        return True
-            else:
-                raise TypeError()
-        return False
-
-
-class WeatherInUfaAPIModel(BaseAPIModel):
-    temperature: float
-    temperature_feels_like: float
-    description: str
-    wind_speed: float
-    sunrise_dt: dt.datetime
-    sunset_dt: dt.datetime
-    has_rain: bool
-    has_snow: bool
-    data: dict
-
-
-class DatetimeAPIModel(BaseAPIModel):
-    date: dt.date
-    datetime: dt.datetime | None = None
-    year: int
-    month: int
-    day: int
-    hour: int | None = None
-    minute: int | None = None
-    second: int | None = None
-    microsecond: int | None = None
-
-
-class ARPAKITScheduleUUSTAPIClient:
-    def __init__(
-            self,
-            *,
-            base_url: str = "https://api.schedule-uust.arpakit.com/api/v1",
-            api_key: str | None = "viewer",
-            use_cache: bool = False,
-            cache_ttl: dt.timedelta | None = dt.timedelta(minutes=10)
-    ):
-        self._logger = logging.getLogger(__name__)
-        self.api_key = api_key
-        base_url = base_url.strip()
-        if not base_url.endswith("/"):
-            base_url += "/"
-        self.base_url = base_url
-        self.headers = {"Content-Type": "application/json"}
-        if api_key is not None:
-            self.headers.update({"apikey": self.api_key})
-        self.use_cache = use_cache
-        self.cache_ttl = cache_ttl
-        if cache_ttl is not None:
-            self.ttl_cache = cachetools.TTLCache(maxsize=100, ttl=cache_ttl.total_seconds())
-        else:
-            self.ttl_cache = None
-
-    async def _async_make_http_request(
-            self,
-            *,
-            method: str = "GET",
-            url: str,
-            params: dict[str, Any] | None = None,
-            **kwargs
-    ) -> ClientResponse:
-        response = await async_make_http_request(
-            method=method,
-            url=url,
-            headers=self.headers,
-            params=params,
-            max_tries_=5,
-            raise_for_status_=True,
-            **kwargs
-        )
-        return response
-
-    def clear_cache(self):
-        if self.ttl_cache is not None:
-            self.ttl_cache.clear()
-
-    async def check_auth(self) -> dict[str, Any]:
-        response = await self._async_make_http_request(
-            method="GET", url=urljoin(self.base_url, "check_auth")
-        )
-        json_data = await response.json()
-        return json_data
-
-    async def get_current_week(self) -> CurrentWeekAPIModel | None:
-        response = await self._async_make_http_request(
-            method="GET", url=urljoin(self.base_url, "get_current_week")
-        )
-        json_data = await response.json()
-        if json_data is None:
-            return None
-        return CurrentWeekAPIModel.model_validate(json_data)
-
-    async def get_current_semester(self) -> CurrentSemesterAPIModel | None:
-        response = await self._async_make_http_request(
-            method="GET", url=urljoin(self.base_url, "get_current_semester")
-        )
-        json_data = await response.json()
-        if json_data is None:
-            return None
-        return CurrentSemesterAPIModel.model_validate(json_data)
-
-    async def get_weather_in_ufa(self) -> WeatherInUfaAPIModel:
-        response = await self._async_make_http_request(
-            method="GET", url=urljoin(self.base_url, "get_weather_in_ufa")
-        )
-        json_data = await response.json()
-        return WeatherInUfaAPIModel.model_validate(json_data)
-
-    async def get_now_datetime_in_ufa(self) -> DatetimeAPIModel:
-        response = await self._async_make_http_request(
-            method="GET", url=urljoin(self.base_url, "get_now_datetime_in_ufa")
-        )
-        json_data = await response.json()
-        return DatetimeAPIModel.model_validate(json_data)
-
-    async def get_log_file_content(self) -> str | None:
-        response = await self._async_make_http_request(
-            method="GET", url=urljoin(self.base_url, "get_log_file")
-        )
-        text_data = await response.text()
-        return text_data
-
-    async def get_groups(self) -> list[GroupAPIModel]:
-        response = await self._async_make_http_request(
-            method="GET", url=urljoin(self.base_url, "get_groups")
-        )
-        json_data = await response.json()
-        return [GroupAPIModel.model_validate(d) for d in json_data]
-
-    async def get_group(
-            self, *, filter_id: int | None = None, filter_uust_api_id: int | None = None
-    ) -> GroupAPIModel | None:
-        params = {}
-        if filter_id is not None:
-            params["filter_id"] = filter_id
-        if filter_uust_api_id is not None:
-            params["filter_uust_api_id"] = filter_uust_api_id
-        response = await self._async_make_http_request(
-            method="GET", url=urljoin(self.base_url, "get_group"), params=params)
-        json_data = await response.json()
-        if json_data is None:
-            return None
-        return GroupAPIModel.model_validate(json_data)
-
-    async def find_groups(
-            self, *, q: str
-    ) -> list[GroupAPIModel]:
-        response = await self._async_make_http_request(
-            method="GET", url=urljoin(self.base_url, "find_groups"), params={"q": q.strip()}
-        )
-        json_data = await response.json()
-        return [GroupAPIModel.model_validate(d) for d in json_data]
-
-    async def get_teachers(self) -> list[TeacherAPIModel]:
-        response = await self._async_make_http_request(
-            method="GET", url=urljoin(self.base_url, "get_teachers")
-        )
-        json_data = await response.json()
-        return [TeacherAPIModel.model_validate(d) for d in json_data]
-
-    async def get_teacher(
-            self, *, filter_id: int | None = None, filter_uust_api_id: int | None = None
-    ) -> TeacherAPIModel | None:
-        params = {}
-        if filter_id is not None:
-            params["filter_id"] = filter_id
-        if filter_uust_api_id is not None:
-            params["filter_uust_api_id"] = filter_uust_api_id
-        response = await self._async_make_http_request(
-            method="GET", url=urljoin(self.base_url, "get_teacher"), params=params
-        )
-        json_data = await response.json()
-        if json_data is None:
-            return None
-        return TeacherAPIModel.model_validate(json_data)
-
-    async def find_teachers(
-            self, *, q: str
-    ) -> list[TeacherAPIModel]:
-        response = await self._async_make_http_request(
-            method="GET", url=urljoin(self.base_url, "find_teachers"), params={"q": q.strip()}
-        )
-        json_data = await response.json()
-        return [TeacherAPIModel.model_validate(d) for d in json_data]
-
-    async def find_any(
-            self, *, q: str
-    ) -> list[TeacherAPIModel | GroupLessonAPIModel]:
-        response = await self._async_make_http_request(
-            method="GET", url=urljoin(self.base_url, "find_any"), params={"q": q.strip()}
-        )
-        json_data = await response.json()
-
-        results = []
-        for d in json_data:
-            if d["entity_type"] == "group":
-                results.append(GroupAPIModel.model_validate(d))
-            elif d["entity_type"] == "teacher":
-                results.append(TeacherAPIModel.model_validate(d))
-            else:
-                pass
-        return results
-
-    async def get_group_lessons(
-            self,
-            *,
-            filter_group_id: int | None = None,
-            filter_group_uust_api_id: int | None = None
-    ) -> list[GroupLessonAPIModel]:
-        params = {}
-        if filter_group_id is not None:
-            params["filter_group_id"] = filter_group_id
-        if filter_group_uust_api_id is not None:
-            params["filter_group_uust_api_id"] = filter_group_uust_api_id
-        response = await self._async_make_http_request(
-            method="GET", url=urljoin(self.base_url, "get_group_lessons"), params=params
-        )
-        json_data = await response.json()
-        return [GroupLessonAPIModel.model_validate(d) for d in json_data]
-
-    async def get_teacher_lessons(
-            self,
-            *,
-            filter_teacher_id: int | None = None,
-            filter_teacher_uust_api_id: int | None = None
-    ) -> list[TeacherLessonAPIModel]:
-        params = {}
-        if filter_teacher_id is not None:
-            params["filter_teacher_id"] = filter_teacher_id
-        if filter_teacher_uust_api_id is not None:
-            params["filter_teacher_uust_api_id"] = filter_teacher_uust_api_id
-        response = await self._async_make_http_request(
-            method="GET", url=urljoin(self.base_url, "get_teacher_lessons"), params=params
-        )
-        json_data = await response.json()
-        return [TeacherLessonAPIModel.model_validate(d) for d in json_data]
-
-
-def __example():
-    pass
-
-
-async def __async_example():
-    pass
-
-
-if __name__ == '__main__':
-    __example()
-    asyncio.run(__async_example())

arpakitlib/ar_arpakit_schedule_uust_site_util.py

@@ -1,68 +0,0 @@
-# arpakit
-
-from urllib.parse import urlencode, urljoin
-
-from arpakitlib.ar_type_util import raise_for_type
-
-_ARPAKIT_LIB_MODULE_VERSION = "3.0"
-
-
-def generate_arpakit_schedule_uust_site_url(
-        *,
-        base_url: str = "https://schedule-uust.arpakit.com",
-        entity_type: str | None = None,
-        uust_api_id: int | None = None,
-        session: bool | None = None,
-        week: int | None = None,
-        theme: str | None = None
-) -> str:
-    raise_for_type(base_url, str)
-
-    params = {}
-
-    if entity_type is not None:  # group/teacher
-        raise_for_type(entity_type, str)
-        params["entity_type"] = entity_type
-
-    if uust_api_id is not None:  # uust_api_id of group/teacher
-        raise_for_type(uust_api_id, int)
-        params["uust_api_id"] = uust_api_id
-
-    if session is not None:  # true/false
-        raise_for_type(session, bool)
-        if session:
-            params["session"] = "true"
-        else:
-            params["session"] = "false"
-
-    if week is not None:
-        raise_for_type(week, int)
-        params["week"] = week
-
-    if theme is not None:  # dark/light
-        raise_for_type(theme, str)
-        params["theme"] = theme
-
-    if params:
-        res = urljoin(base_url, f"schedule?{urlencode(params)}")
-    else:
-        res = base_url
-
-    return res
-
-
-def __example():
-    base_url = "https://schedule-uust.arpakit.com"
-    url = generate_arpakit_schedule_uust_site_url(
-        base_url=base_url,
-        entity_type="group",
-        uust_api_id=6662,
-        session=True,
-        week=23,
-        theme="dark"
-    )
-    print(url)
-
-
-if __name__ == '__main__':
-    __example()

arpakitlib/ar_generate_celery_url.py

@@ -1,71 +0,0 @@
-from urllib.parse import quote_plus
-
-_ARPAKIT_LIB_MODULE_VERSION = "3.0"
-
-
-def generate_celery_url(
-        *,
-        scheme: str = "redis",  # или amqp, sqs, etc.
-        user: str | None = None,
-        password: str | None = None,
-        host: str = "127.0.0.1",
-        port: int | None = 6379,
-        database: str | int | None = 0,  # для Redis — номер БД; для AMQP — vhost
-        **query_params
-) -> str:
-    """
-    Генерирует Celery broker/backend URL.
-
-    Примеры:
-      redis://:mypassword@redis:6379/0
-      amqp://user:pass@rabbit:5672/myvhost
-      redis://localhost:6379/1?ssl_cert_reqs=none
-    """
-    # Формируем часть авторизации
-    auth_part = ""
-    if user and password:
-        auth_part = f"{quote_plus(user)}:{quote_plus(password)}@"
-    elif password and not user:
-        # Redis-style — пароль без юзера
-        auth_part = f":{quote_plus(password)}@"
-    elif user:
-        auth_part = f"{quote_plus(user)}@"
-
-    # Формируем хост и порт
-    host_part = host
-    if port:
-        host_part += f":{port}"
-
-    # Формируем "базу" (для Redis — номер, для AMQP — vhost)
-    db_part = ""
-    if database is not None:
-        db_part = f"/{quote_plus(str(database))}"
-
-    # Формируем query параметры
-    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"{scheme}://{auth_part}{host_part}{db_part}{query_part}"
-
-
-def __example():
-    print(generate_celery_url())
-    # → redis://127.0.0.1:6379/0
-
-    # Redis с паролем
-    print(generate_celery_url(password="supersecret", host="redis"))
-    # → redis://:supersecret@redis:6379/0
-
-    # RabbitMQ (AMQP)
-    print(generate_celery_url(scheme="amqp", user="guest", password="guest", host="rabbitmq"))
-    # → amqp://guest:guest@rabbitmq:6379/0
-
-    # Redis с параметрами
-    print(generate_celery_url(password="pass", ssl_cert_reqs="none", socket_timeout=10))
-    # → redis://:pass@127.0.0.1:6379/0?ssl_cert_reqs=none&socket_timeout=10
-
-
-if __name__ == '__main__':
-    __example()

arpakitlib/ar_schedule_uust_api_client_util.py

@@ -1,227 +0,0 @@
-# arpakit
-
-import asyncio
-import hashlib
-import logging
-from datetime import datetime, timedelta
-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
-
-_ARPAKIT_LIB_MODULE_VERSION = "3.0"
-
-
-class ScheduleUUSTAPIClient:
-    def __init__(
-            self,
-            *,
-            api_login: str,
-            api_password: str | None = None,
-            api_password_first_part: str | None = None,
-            api_url: str = "https://isu.uust.ru/api/schedule_v2",
-            api_proxy_url: str | None = None
-    ):
-        self._logger = logging.getLogger(self.__class__.__name__)
-        self.api_login = api_login
-        self.api_password = api_password
-        self.api_password_first_part = api_password_first_part
-        self.api_url = api_url
-        self.api_proxy_url = api_proxy_url
-        self.headers = {
-            "Accept": (
-                "text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;"
-                "q=0.8,application/signed-exchange;v=b3;q=0.7"
-            ),
-            "Accept-Encoding": "gzip, deflate, br, zstd",
-            "Accept-Language": "en-US,en;q=0.9,ru-RU;q=0.8,ru;q=0.7",
-            "User-Agent": (
-                "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/127.0.0.0 Safari/537.36"
-            )
-        }
-
-    async def _async_make_http_request(
-            self,
-            *,
-            method: str = "GET",
-            url: str,
-            params: dict[str, Any] | None = None,
-            **kwargs
-    ) -> ClientResponse:
-        response = await async_make_http_request(
-            method=method,
-            url=url,
-            headers=self.headers,
-            params=combine_dicts(params, self.auth_params()),
-            max_tries_=9,
-            proxy_url_=self.api_proxy_url,
-            raise_for_status_=True,
-            timeout_=timedelta(seconds=15),
-            **kwargs
-        )
-        json_data = await response.json()
-        if "error" in json_data.keys():
-            raise Exception(f"error in json_data, {json_data}")
-        return response
-
-    def auth_params(self) -> dict[str, Any]:
-        if self.api_password:
-            return {
-                "login": self.api_login,
-                "pass": self.api_password
-            }
-        elif self.api_password_first_part:
-            return {
-                "login": self.api_login,
-                "pass": self.generate_v2_token()
-            }
-        else:
-            return {}
-
-    @classmethod
-    def hash_new_token(cls, token: str) -> str:
-        sha256 = hashlib.sha256()
-        sha256.update(token.encode('utf-8'))
-        return sha256.hexdigest()
-
-    @classmethod
-    def generate_new_v2_token(cls, password_first_part: str) -> str:
-        return cls.hash_new_token(
-            password_first_part + datetime.now(tz=pytz.timezone("Asia/Yekaterinburg")).strftime("%Y-%m-%d")
-        )
-
-    def generate_v2_token(self) -> str:
-        return self.generate_new_v2_token(password_first_part=self.api_password_first_part)
-
-    async def get_current_week(self) -> int:
-        """
-        response.json example
-        {
-            'data': [15]
-        }
-        """
-
-        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:
-        """
-        response.json example
-        {
-            'data': ['Осенний семестр 2023/2024']
-        }
-        """
-
-        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]]:
-        """
-        response.json example
-        {
-            "data": {
-                "4438": {
-                    "group_id": 4438,
-                    "group_title": "АРКТ-101А",
-                    "faculty": "",
-                    "course": 1
-                }
-            }
-        }
-        """
-
-        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]]:
-        params = {
-            "ask": "get_group_schedule",
-            "id": group_id
-        }
-        if semester is not None:
-            params["semester"] = semester
-        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]]:
-        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
-        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(f"connection is bad, {e}")
-            return False
-        return True
-
-    async def check_all(self) -> dict[str, Any]:
-        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}")
-
-        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)}")
-
-        return {
-            "current_semester": current_semester,
-            "current_week": current_week,
-            "len(groups)": len(groups),
-            "len(teachers)": len(teachers)
-        }
-
-
-def __example():
-    pass
-
-
-async def __async_example():
-    pass
-
-
-if __name__ == '__main__':
-    __example()
-    asyncio.run(__async_example())