arpakitlib 1.4.0__py3-none-any.whl

arpakitlib/ar_ssh_runner.py

@@ -0,0 +1,260 @@
+from __future__ import annotations
+
+import asyncio
+import logging
+from datetime import timedelta
+from typing import Optional, Any
+
+import asyncssh
+import paramiko
+from pydantic import BaseModel
+
+from arpakitlib.ar_json_util import safely_transfer_to_json_str
+
+_ARPAKIT_LIB_MODULE_VERSION = "3.0"
+
+
+class SSHRunTimeouts:
+    fast_command = timedelta(minutes=0, seconds=15).total_seconds()
+    medium_command = timedelta(minutes=2, seconds=30).total_seconds()
+    long_command = timedelta(minutes=5, seconds=0).total_seconds()
+
+
+class SSHBaseErr(Exception):
+    pass
+
+
+class SSHCannotConnect(SSHBaseErr):
+    pass
+
+
+class SSHCannotRun(SSHBaseErr):
+    pass
+
+
+class SSHRunResHasErr(SSHBaseErr):
+
+    def __init__(self, ssh_run_res: SSHRunRes):
+        self.ssh_run_res = ssh_run_res
+
+    def __repr__(self):
+        return f"return_code={self.ssh_run_res.return_code}, stderr={self.ssh_run_res.err.strip()}"
+
+    def __str__(self):
+        return f"return_code={self.ssh_run_res.return_code}, stderr={self.ssh_run_res.err.strip()}"
+
+
+class SSHRunRes(BaseModel):
+    out: str
+    err: str
+    return_code: int | None = None
+
+    def simple_dict(self) -> dict[str, Any]:
+        return {
+            "out": self.out,
+            "err": self.err,
+            "return_code": self.return_code,
+            "has_bad_return_code": self.has_bad_return_code,
+            "has_err": self.has_err
+        }
+
+    def simple_json(self) -> str:
+        return safely_transfer_to_json_str(self.simple_dict())
+
+    def __repr__(self) -> str:
+        return self.simple_json()
+
+    def __str__(self) -> str:
+        return self.simple_json()
+
+    @property
+    def has_bad_return_code(self) -> bool:
+        if self.return_code is None:
+            return False
+        return self.return_code != 0
+
+    @property
+    def has_err(self) -> bool:
+        if self.err:
+            return True
+        return False
+
+    def raise_for_bad_return_code(self):
+        if self.has_bad_return_code:
+            raise SSHRunResHasErr(ssh_run_res=self)
+
+    def raise_for_err(self):
+        if self.has_err:
+            raise SSHRunResHasErr(ssh_run_res=self)
+
+
+class SSHRunner:
+
+    def __init__(
+            self,
+            *,
+            hostname: str,
+            port: int = 22,
+            username: str = "root",
+            password: Optional[str] = None,
+            base_timeout: int = timedelta(seconds=5).total_seconds()
+    ):
+        self.hostname = hostname
+        self.port = port
+        self.username = username
+        self.password = password
+
+        self.base_timeout = base_timeout
+
+        self._logger = logging.getLogger(
+            f"{logging.getLogger(self.__class__.__name__)} - {self.username}@{self.hostname}:{self.port}"
+        )
+
+        self.async_conn: Optional[asyncssh.SSHClientConnection] = None
+
+        self.sync_client = paramiko.SSHClient()
+        self.sync_client.set_missing_host_key_policy(paramiko.AutoAddPolicy())
+
+    """SYNC"""
+
+    def sync_connect(self) -> SSHRunner:
+        try:
+            self.sync_client.connect(
+                hostname=self.hostname,
+                username=self.username,
+                password=self.password,
+                port=self.port,
+                timeout=self.base_timeout,
+                auth_timeout=self.base_timeout,
+                banner_timeout=self.base_timeout,
+                channel_timeout=self.base_timeout
+            )
+        except Exception as err:
+            raise SSHCannotConnect(err)
+        return self
+
+    def sync_check_connection(self):
+        self.sync_connect()
+
+    def sync_is_conn_good(self) -> bool:
+        try:
+            self.sync_check_connection()
+        except SSHCannotConnect:
+            return False
+        return True
+
+    def sync_run(
+            self,
+            command: str,
+            *,
+            timeout: float | None = SSHRunTimeouts.medium_command,
+            raise_for_bad_return_code: bool = True
+    ) -> SSHRunRes:
+        if timeout is None:
+            timeout = self.base_timeout
+
+        self._logger.info(command)
+
+        self.sync_connect()
+
+        try:
+            stdin, stdout, stderr = self.sync_client.exec_command(
+                command=command,
+                timeout=timeout
+            )
+            return_code = stdout.channel.recv_exit_status()
+            stdout = stdout.read().decode()
+            stderr = stderr.read().decode()
+        except Exception as err:
+            raise SSHCannotRun(err)
+
+        ssh_run_res = SSHRunRes(
+            out=stdout,
+            err=stderr,
+            return_code=return_code
+        )
+        if raise_for_bad_return_code is True:
+            ssh_run_res.raise_for_bad_return_code()
+
+        return ssh_run_res
+
+    def sync_close(self):
+        self.sync_client.close()
+
+    """ASYNC SYNC"""
+
+    async def async_connect(self) -> SSHRunner:
+        if self.async_conn is None:
+            try:
+                self.async_conn = await asyncssh.connect(
+                    host=self.hostname,
+                    username=self.username,
+                    password=self.password,
+                    port=self.port,
+                    connect_timeout=self.base_timeout,
+                    known_hosts=None
+                )
+            except Exception as err:
+                raise SSHCannotConnect(err)
+        return self
+
+    async def async_check_connection(self):
+        await self.async_connect()
+
+    async def async_is_conn_good(self) -> bool:
+        try:
+            await self.async_check_connection()
+        except SSHCannotConnect:
+            return False
+        return True
+
+    async def async_run(
+            self,
+            command: str,
+            *,
+            timeout: float | None = SSHRunTimeouts.medium_command,
+            raise_for_bad_return_code: bool = True
+    ) -> SSHRunRes:
+        if timeout is None:
+            timeout = self.base_timeout
+
+        self._logger.info(command)
+
+        await self.async_connect()
+
+        try:
+            result: asyncssh.SSHCompletedProcess = await self.async_conn.run(
+                command,
+                check=False,
+                timeout=timeout
+            )
+        except Exception as err:
+            raise SSHCannotRun(err)
+
+        ssh_run_res = SSHRunRes(
+            out=result.stdout,
+            err=result.stderr,
+            return_code=result.returncode
+        )
+        if raise_for_bad_return_code is True:
+            ssh_run_res.raise_for_bad_return_code()
+
+        return ssh_run_res
+
+    def async_close(self):
+        if self.async_conn is not None:
+            self.async_conn.close()
+            self.async_conn = None
+
+
+def __example():
+    pass
+
+
+async def __async_example():
+    pass
+
+
+if __name__ == '__main__':
+    __example()
+    asyncio.run(__async_example())

arpakitlib/ar_str_util.py

@@ -0,0 +1,79 @@
+from typing import Optional
+
+from bs4 import BeautifulSoup
+
+from arpakitlib.ar_type_util import raise_for_type
+
+_ARPAKIT_LIB_MODULE_VERSION = "3.0"
+
+
+def str_in(string: str, main_string: str, *, max_diff: Optional[int] = None) -> bool:
+    if string not in main_string:
+        return False
+
+    if max_diff is None:
+        return True
+
+    diff = len(main_string) - len(string)
+    if diff <= max_diff:
+        return True
+
+    return False
+
+
+def bidirectional_str_in(string1: str, string2: str, *, max_diff: Optional[int] = None) -> bool:
+    if (
+            str_in(string=string1, main_string=string2, max_diff=max_diff)
+            or str_in(string=string2, main_string=string1, max_diff=max_diff)
+    ):
+        return True
+    return False
+
+
+def str_startswith(string: str, main_string: str, max_diff: Optional[int] = None) -> bool:
+    if not main_string.startswith(string):
+        return False
+
+    if max_diff is None:
+        return True
+
+    diff = len(main_string) - len(string)
+    if diff <= max_diff:
+        return True
+
+    return False
+
+
+def bidirectional_str_startswith(string1: str, string2: str, max_diff: Optional[int] = None) -> bool:
+    if str_startswith(string1, string2, max_diff=max_diff) or str_startswith(string2, string1, max_diff=max_diff):
+        return True
+    return False
+
+
+def blank_if_none(string: Optional[str] = None) -> str:
+    if string is None:
+        return ""
+    return string
+
+
+def remove_html(string: str) -> str:
+    raise_for_type(string, str)
+    return BeautifulSoup(string, "html.parser").text
+
+
+def remove_tags(string: str) -> str:
+    raise_for_type(string, str)
+    return string.replace("<", "").replace(">", "")
+
+
+def remove_tags_and_html(string: str) -> str:
+    raise_for_type(string, str)
+    return remove_tags(remove_html(string))
+
+
+def __example():
+    pass
+
+
+if __name__ == '__main__':
+    __example()

arpakitlib/ar_type_util.py

@@ -0,0 +1,82 @@
+from typing import Optional, Any
+
+_ARPAKIT_LIB_MODULE_VERSION = "3.0"
+
+
+# ---
+
+
+class NotSet:
+    pass
+
+
+def is_set(v: Any) -> bool:
+    return not (v is NotSet or isinstance(v, NotSet))
+
+
+def is_set_and_not_none(v: Any) -> bool:
+    return is_set(v) and (v is not None)
+
+
+def is_not_set(v: Any) -> bool:
+    return not is_set(v)
+
+
+def is_not_set_or_none(v: Any) -> bool:
+    return is_not_set(v) or (v is None)
+
+
+def raise_if_set(v: Any):
+    if is_set(v):
+        raise ValueError("value is set")
+
+
+def raise_if_not_set(v: Any):
+    if not is_set(v):
+        raise ValueError("value not set")
+
+
+def make_none_if_not_set(v: Any) -> Any:
+    if is_not_set(v):
+        return None
+    return v
+
+
+# ---
+
+
+def raise_for_type(comparable, need_type, comment_for_error: Optional[str] = None):
+    if comparable is need_type:
+        return
+
+    if not isinstance(comparable, need_type):
+        err = f"raise_for_type, {comparable} != {need_type}, type {type(comparable)} != type {need_type}"
+        if comment_for_error:
+            err += f"\n{comment_for_error}"
+        raise TypeError(err)
+
+
+def raise_for_types(comparable, need_types, comment_for_error: Optional[str] = None):
+    exceptions = []
+    for need_type in need_types:
+        try:
+            raise_for_type(comparable=comparable, need_type=need_type, comment_for_error=comment_for_error)
+            return
+        except TypeError as e:
+            exceptions.append(e)
+    if exceptions:
+        err = f"raise_for_types, {comparable} not in {need_types}, type {type(comparable)} not in {need_types}"
+        if comment_for_error:
+            err += f"\n{comment_for_error}"
+        raise TypeError(err)
+
+
+# ---
+
+
+def __example():
+    pass
+
+
+if __name__ == '__main__':
+    __example()

arpakitlib/ar_yookassa_api_client.py

@@ -0,0 +1,224 @@
+from __future__ import annotations
+
+import asyncio
+import logging
+import uuid
+from datetime import timedelta
+from typing import Optional, Any
+
+import aiohttp
+import requests
+
+from arpakitlib.ar_dict_util import combine_dicts
+from arpakitlib.ar_enumeration import EasyEnumeration
+from arpakitlib.ar_safe_sleep import safe_sleep
+from arpakitlib.ar_type_util import raise_for_type
+
+_ARPAKIT_LIB_MODULE_VERSION = "3.0"
+
+"""
+https://yookassa.ru/developers/api
+"""
+
+
+class YookassaPaymentStatuses(EasyEnumeration):
+    pending = "pending"
+    waiting_for_capture = "waiting_for_capture"
+    succeeded = "succeeded"
+    canceled = "canceled"
+
+
+class YookassaAPIException(Exception):
+    pass
+
+
+class YookassaAPIClient:
+    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(self.__class__.__name__)
+
+    def _sync_make_request(self, method: str, url: str, **kwargs) -> requests.Response:
+        max_tries = 7
+        tries = 0
+
+        kwargs["url"] = url
+        kwargs["method"] = method
+        kwargs["timeout"] = (timedelta(seconds=3).total_seconds(), timedelta(seconds=3).total_seconds())
+        if "headers" not in kwargs:
+            kwargs["headers"] = {}
+        kwargs["headers"] = combine_dicts(self.headers, kwargs["headers"])
+        kwargs["auth"] = (self.shop_id, self.secret_key)
+
+        while True:
+            self._logger.info(f"{method} {url}")
+            tries += 1
+            try:
+                return requests.request(**kwargs)
+            except Exception as err:
+                self._logger.warning(f"{tries}/{max_tries} {err} {method} {url}")
+                if tries >= max_tries:
+                    raise YookassaAPIException(err)
+                safe_sleep(timedelta(seconds=0.1).total_seconds())
+                continue
+
+    async def _async_make_request(self, method: str, url: str, **kwargs) -> aiohttp.ClientResponse:
+        max_tries = 7
+        tries = 0
+
+        kwargs["url"] = url
+        kwargs["method"] = method
+        kwargs["timeout"] = aiohttp.ClientTimeout(total=timedelta(seconds=15).total_seconds())
+        if "headers" not in kwargs:
+            kwargs["headers"] = {}
+        kwargs["headers"] = combine_dicts(self.headers, kwargs["headers"])
+        kwargs["auth"] = aiohttp.BasicAuth(login=str(self.shop_id), password=self.secret_key)
+
+        while True:
+            self._logger.info(f"{method} {url}")
+            tries += 1
+            try:
+                async with aiohttp.ClientSession() as session:
+                    async with session.request(**kwargs) as response:
+                        await response.read()
+                        return response
+            except Exception as err:
+                self._logger.warning(f"{tries}/{max_tries} {err} {method} {url}")
+                if tries >= max_tries:
+                    raise YookassaAPIException(err)
+                await asyncio.sleep(timedelta(seconds=0.1).total_seconds())
+                continue
+
+    def sync_create_payment(
+            self,
+            json_body: dict[str, Any],
+            idempotence_key: Optional[str] = None
+    ) -> 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": ""
+        }
+        """
+
+        if idempotence_key is None:
+            idempotence_key = str(uuid.uuid4())
+
+        headers = combine_dicts({"Idempotence-Key": idempotence_key})
+
+        response = self._sync_make_request(
+            method="POST",
+            url="https://api.yookassa.ru/v3/payments",
+            headers=headers,
+            json=json_body,
+        )
+
+        json_data = response.json()
+
+        response.raise_for_status()
+
+        return json_data
+
+    def sync_get_payment(self, payment_id: str) -> Optional[dict[str, Any]]:
+        raise_for_type(payment_id, str)
+
+        response = self._sync_make_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], idempotence_key: Optional[str] = None
+    ) -> 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": ""
+        }
+        """
+
+        if idempotence_key is None:
+            idempotence_key = str(uuid.uuid4())
+
+        headers = combine_dicts({"Idempotence-Key": idempotence_key})
+
+        response = await self._async_make_request(
+            method="POST",
+            url="https://api.yookassa.ru/v3/payments",
+            headers=headers,
+            json=json_body,
+        )
+
+        json_data = await response.json()
+
+        response.raise_for_status()
+
+        return json_data
+
+    async def async_get_payment(self, payment_id: str) -> Optional[dict[str, Any]]:
+        raise_for_type(payment_id, str)
+
+        response = await self._async_make_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())