arpakitlib 1.4.0__py3-none-any.whl

arpakitlib/ar_parse_command.py

@@ -0,0 +1,102 @@
+import shlex
+from typing import Optional
+
+from pydantic import BaseModel
+
+_ARPAKIT_LIB_MODULE_VERSION = "3.0"
+
+
+class BadCommandFormat(Exception):
+    pass
+
+
+class ParsedCommand(BaseModel):
+    command: str
+    key_to_value: dict[str, Optional[str]] = {}
+    values_without_key: list[str] = []
+
+    @property
+    def keys(self) -> list[str]:
+        return [k for k, v in self.key_to_value.items() if v is not None]
+
+    @property
+    def flags(self) -> list[str]:
+        return [k for k, v in self.key_to_value.items() if v is None]
+
+    @property
+    def values(self) -> list[str]:
+        return [self.key_to_value[k] for k in self.keys]
+
+    def get_value_by_key(self, key: str) -> Optional[str]:
+        return self.key_to_value.get(key)
+
+    def key_exists(self, key: str) -> bool:
+        return key in self.key_to_value.keys()
+
+    def keys_exists(self, keys: list[str]) -> bool:
+        for key in keys:
+            if key in self.keys:
+                return True
+        return False
+
+    def has_flag(self, flag: str) -> bool:
+        return flag in self.flags
+
+    def get_value_by_index(self, index: int) -> Optional[str]:
+        if index >= len(self.values_without_key):
+            return None
+        return self.values_without_key[index]
+
+
+def parse_command(text: str) -> ParsedCommand:
+    text = " ".join([text_.strip() for text_ in text.split(" ") if text_.strip()]).strip()
+
+    parts = shlex.split(text)
+    if not parts:
+        raise BadCommandFormat("not parts")
+    if len(parts[0]) == 1:
+        raise BadCommandFormat("len(parts[0]) == 1")
+
+    res = ParsedCommand(command=parts[0])
+
+    last_key: Optional[str] = None
+    for part in parts[1:]:
+        part = part.strip()
+
+        if not part:
+            raise BadCommandFormat("not part")
+        if part == "-" or part == "--":
+            raise BadCommandFormat("part == '-' or part == '--'")
+
+        if part.startswith("-") or part.startswith("--"):  # if it is key
+            if part.startswith("-"):
+                part = part[1:]
+            if part.startswith("-"):
+                part = part[1:]
+            if part.startswith("-"):
+                raise BadCommandFormat("a lots of -")
+
+            if part in res.key_to_value:
+                raise BadCommandFormat(f"{part} in {res.key_to_value}")
+
+            res.key_to_value[part] = None
+            last_key = part
+
+            continue
+
+        if last_key is not None:  # if it is value
+            res.key_to_value[last_key] = part
+            last_key = None
+            continue
+
+        res.values_without_key.append(part)  # if it is values_without_key
+
+    return res
+
+
+def __example():
+    pass
+
+
+if __name__ == '__main__':
+    __example()

arpakitlib/ar_postgresql_util.py

@@ -0,0 +1,45 @@
+from arpakitlib.ar_logging_util import setup_normal_logging
+from arpakitlib.ar_run_cmd import run_cmd
+from arpakitlib.ar_type_util import raise_for_type
+
+_ARPAKIT_LIB_MODULE_VERSION = "3.0"
+
+
+def make_postgresql_db_dump(
+        *,
+        user: str,
+        host: str = "127.0.0.1",
+        db_name: str,
+        port: int = 5432,
+        out_filepath: str = "db_dump.sql",
+        password: str | None = None
+) -> str:
+    raise_for_type(user, str)
+    raise_for_type(host, str)
+    raise_for_type(db_name, str)
+    raise_for_type(port, int)
+    if password:
+        run_cmd_res = run_cmd(
+            command=f"echo {password} | pg_dump -U {user} -h {host} {db_name} -p {port} > {out_filepath}"
+        )
+    else:
+        run_cmd_res = run_cmd(
+            command=f"pg_dump -U {user} -h {host} {db_name} -p {port} > {out_filepath}"
+        )
+    run_cmd_res.raise_for_bad_return_code()
+
+    return out_filepath
+
+
+def __example():
+    setup_normal_logging()
+    make_postgresql_db_dump(
+        user="arpakitlib",
+        db_name="arpakitlib",
+        port=50629,
+        password="arpakitlib"
+    )
+
+
+if __name__ == '__main__':
+    __example()

arpakitlib/ar_run_cmd.py

@@ -0,0 +1,48 @@
+from __future__ import annotations
+
+import subprocess
+
+from pydantic import BaseModel
+
+_ARPAKIT_LIB_MODULE_VERSION = "3.0"
+
+
+class RunCmdResHasErr(Exception):
+    pass
+
+
+class RunCmdRes(BaseModel):
+    out: str
+    err: str
+    return_code: int
+
+    @property
+    def has_bad_return_code(self) -> bool:
+        return self.return_code != 0
+
+    def raise_for_bad_return_code(self):
+        if self.has_bad_return_code is True:
+            raise RunCmdResHasErr(f"return_code={self.return_code}, err={self.err}")
+        return
+
+
+def run_cmd(command: str, raise_for_bad_return_code: bool = False) -> RunCmdRes:
+    subprocess_res = subprocess.run(command, shell=True, stderr=subprocess.PIPE, stdout=subprocess.PIPE, check=False)
+
+    res = RunCmdRes(
+        out=subprocess_res.stdout.decode(),
+        err=subprocess_res.stderr.decode(),
+        return_code=subprocess_res.returncode
+    )
+    if raise_for_bad_return_code is True:
+        res.raise_for_bad_return_code()
+
+    return res
+
+
+def __example():
+    pass
+
+
+if __name__ == '__main__':
+    __example()

arpakitlib/ar_safe_sleep.py

@@ -0,0 +1,23 @@
+import logging
+import math
+from time import sleep
+
+_ARPAKIT_LIB_MODULE_VERSION = "3.0"
+
+_logger = logging.getLogger(__name__)
+
+
+def safe_sleep(sleep_time: float | int):
+    _logger.info(f"sleep_time={sleep_time}")
+    frac, int_part = math.modf(sleep_time)
+    for i in range(int(int_part)):
+        sleep(1)
+    sleep(frac)
+
+
+def __example():
+    pass
+
+
+if __name__ == '__main__':
+    __example()

arpakitlib/ar_schedule_uust_api_client.py

@@ -0,0 +1,216 @@
+import asyncio
+import hashlib
+import logging
+from datetime import timedelta, datetime
+from typing import Optional, Any
+
+import aiohttp
+import pytz
+from aiohttp import ClientTimeout
+from aiohttp_socks import ProxyConnector
+
+from arpakitlib.ar_dict_util import combine_dicts
+
+_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"
+            )
+        }
+
+    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(password_first_part=self.api_password_first_part)
+            }
+        else:
+            return {}
+
+    @classmethod
+    def hash_token(cls, token: str) -> str:
+        sha256 = hashlib.sha256()
+        sha256.update(token.encode('utf-8'))
+        return sha256.hexdigest()
+
+    @classmethod
+    def generate_v2_token(cls, password_first_part: str) -> str:
+        return cls.hash_token(
+            password_first_part + datetime.now(tz=pytz.timezone("Asia/Yekaterinburg")).strftime("%Y-%m-%d")
+        )
+
+    async def _async_get_request(
+            self,
+            *,
+            url: str,
+            params: Optional[dict] = None
+    ) -> dict[str, Any]:
+        max_tries = 7
+        tries = 0
+
+        while True:
+            self._logger.info(f"GET {url} {params} proxy={self.api_proxy_url}")
+
+            tries += 1
+
+            connector = (
+                ProxyConnector.from_url(self.api_proxy_url)
+                if self.api_proxy_url is not None
+                else None
+            )
+
+            try:
+                async with aiohttp.ClientSession(connector=connector) as session:
+                    async with session.get(
+                            url=url,
+                            params=params,
+                            timeout=ClientTimeout(total=timedelta(seconds=15).total_seconds())
+                    ) as response:
+                        response.raise_for_status()
+                        return await response.json()
+            except Exception as err:
+                self._logger.warning(f"{tries}/{max_tries} {err} GET {url} {params}  proxy={self.api_proxy_url}")
+                if tries >= max_tries:
+                    raise err
+                await asyncio.sleep(timedelta(seconds=1).total_seconds())
+                self._logger.warning(f"{tries}/{max_tries} AGAIN GET {url} {params}  proxy={self.api_proxy_url}")
+                continue
+
+    async def get_current_week(self) -> int:
+        """
+        response.json example
+        {
+            'data': [15]
+        }
+        """
+
+        params = combine_dicts(self.auth_params(), {"ask": "get_current_week"})
+        json_data = await self._async_get_request(
+            url=self.api_url,
+            params=params
+        )
+        return json_data["data"][0]
+
+    async def get_current_semester(self) -> str:
+        """
+        response.json example
+        {
+            'data': ['Осенний семестр 2023/2024']
+        }
+        """
+
+        params = combine_dicts(self.auth_params(), {"ask": "get_current_semestr"})
+        json_data = await self._async_get_request(
+            url=self.api_url,
+            params=params
+        )
+        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
+                }
+            }
+        }
+        """
+
+        params = combine_dicts(self.auth_params(), {"ask": "get_group_list"})
+        json_data = await self._async_get_request(
+            url=self.api_url,
+            params=params
+        )
+        return list(json_data["data"].values())
+
+    async def get_group_lessons(self, group_id: int, semester: str | None = None) -> list[dict[str, Any]]:
+        params = combine_dicts(
+            self.auth_params(),
+            {
+                "ask": "get_group_schedule",
+                "id": group_id
+            }
+        )
+        if semester is not None:
+            params["semester"] = semester
+        json_data = await self._async_get_request(
+            url=self.api_url,
+            params=params
+        )
+        return json_data["data"]
+
+    async def get_teachers(self) -> list[dict[str, Any]]:
+        params = combine_dicts(self.auth_params(), {"ask": "get_teacher_list"})
+        json_data = await self._async_get_request(
+            url=self.api_url,
+            params=params
+        )
+        return list(json_data["data"].values())
+
+    async def get_teacher_lessons(self, teacher_id: int, semester: str | None = None) -> list[dict[str, Any]]:
+        params = combine_dicts(self.auth_params(), {"ask": "get_teacher_schedule", "id": teacher_id})
+        if semester is not None:
+            params["semester"] = semester
+        json_data = await self._async_get_request(
+            url=self.api_url,
+            params=params
+        )
+        return json_data["data"]
+
+    async def check_conn(self):
+        await self.get_current_week()
+
+    async def is_conn_good(self):
+        try:
+            await self.check_conn()
+        except Exception as e:
+            self._logger.error(e)
+            return False
+        return True
+
+
+def __example():
+    pass
+
+
+async def __async_example():
+    pass
+
+
+if __name__ == '__main__':
+    __example()
+    asyncio.run(__async_example())

arpakitlib/ar_sqlalchemy_util.py

@@ -0,0 +1,124 @@
+import logging
+from datetime import timedelta, datetime
+from typing import Any
+from uuid import uuid4
+
+from sqlalchemy import create_engine, QueuePool, text, func, inspect, INTEGER, TEXT, TIMESTAMP
+from sqlalchemy.orm import sessionmaker, DeclarativeBase, Mapped, mapped_column
+from sqlalchemy.orm.session import Session
+
+from arpakitlib.ar_datetime_util import now_utc_dt
+from arpakitlib.ar_json_util import safely_transfer_to_json_str
+
+_ARPAKIT_LIB_MODULE_VERSION = "3.0"
+
+
+class BaseDBM(DeclarativeBase):
+    __abstract__ = True
+    _bus_data: dict[str, Any] | None = None
+
+    @property
+    def bus_data(self) -> dict[str, Any]:
+        if self._bus_data is None:
+            self._bus_data = {}
+        return self._bus_data
+
+    def simple_dict(self) -> dict[str, Any]:
+        return {c.key: getattr(self, c.key) for c in inspect(self).mapper.column_attrs}
+
+    def simple_json(self) -> str:
+        return safely_transfer_to_json_str(self.simple_dict())
+
+
+class SimpleDBM(BaseDBM):
+    __abstract__ = True
+
+    id: Mapped[int] = mapped_column(
+        INTEGER, primary_key=True, autoincrement=True, nullable=False
+    )
+    long_id: Mapped[str] = mapped_column(
+        TEXT, insert_default=uuid4, unique=True, nullable=False
+    )
+    creation_dt: Mapped[datetime] = mapped_column(
+        TIMESTAMP, insert_default=now_utc_dt, index=True, nullable=False
+    )
+
+
+class SQLAlchemyDB:
+    def __init__(self, *, db_url: str, echo: bool = False):
+        self._logger = logging.getLogger(self.__class__.__name__)
+        self.engine = create_engine(
+            url=db_url,
+            echo=echo,
+            pool_size=5,
+            max_overflow=10,
+            poolclass=QueuePool,
+            pool_timeout=timedelta(seconds=30).total_seconds()
+        )
+        self.sessionmaker = sessionmaker(bind=self.engine)
+        self.func_new_session_counter = 0
+
+    def drop_celery_tables(self):
+        with self.engine.connect() as connection:
+            connection.execute(text("DROP TABLE IF EXISTS celery_tasksetmeta CASCADE;"))
+            connection.execute(text("DROP TABLE IF EXISTS celery_taskmeta CASCADE;"))
+            connection.commit()
+            self._logger.info("celery tables were dropped")
+
+    def remove_celery_tables_data(self):
+        with self.engine.connect() as connection:
+            connection.execute(text("DELETE FROM celery_tasksetmeta;"))
+            connection.execute(text("DELETE FROM celery_taskmeta;"))
+            connection.commit()
+            self._logger.info("celery tables data were removed")
+
+    def init(self):
+        BaseDBM.metadata.create_all(bind=self.engine, checkfirst=True)
+        self._logger.info("db was inited")
+
+    def drop(self):
+        BaseDBM.metadata.drop_all(bind=self.engine, checkfirst=True)
+        self._logger.info("db was dropped")
+
+    def reinit(self):
+        BaseDBM.metadata.drop_all(bind=self.engine, checkfirst=True)
+        BaseDBM.metadata.create_all(bind=self.engine, checkfirst=True)
+        self._logger.info("db was reinited")
+
+    def check_conn(self):
+        self.engine.connect()
+        self._logger.info("db conn is good")
+
+    def new_session(self) -> Session:
+        self.func_new_session_counter += 1
+        return self.sessionmaker(bind=self.engine)
+
+    def is_conn_good(self) -> bool:
+        try:
+            self.check_conn()
+        except Exception as e:
+            self._logger.error(e)
+            return False
+        return True
+
+    def generate_unique_id(self, *, class_dbm: type[BaseDBM]):
+        with self.new_session() as session:
+            res = session.query(func.max(class_dbm.id)).scalar()
+            while session.query(class_dbm).filter(class_dbm.id == res).first() is not None:
+                res += 1
+        return res
+
+    def generate_unique_long_id(self, *, class_dbm: type[BaseDBM]):
+        with self.new_session() as session:
+            res = str(uuid4())
+            while session.query(class_dbm).filter(class_dbm.long_id == res).first() is not None:
+                res = str(uuid4())
+        return res
+
+
+def __example():
+    pass
+
+
+if __name__ == '__main__':
+    __example()