MainShortcuts2 2.7.0__tar.gz → 2.7.2__tar.gz

{mainshortcuts2-2.7.0 → mainshortcuts2-2.7.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: MainShortcuts2
-Version: 2.7.0
+Version: 2.7.2
 Summary: Сокращение и улучшение функций + консольные утилиты
 Author: MainPlay TG
 Author-email: xbox.roman6666666666@gmail.com
@@ -19,6 +19,8 @@ Project-URL: Repository, https://github.com/MainPlay-TG/MainShortcuts2.py
 Description-Content-Type: text/markdown
 
 # MainShortcuts2
+[![Build and upload release](https://github.com/MainPlay-TG/MainShortcuts2.py/actions/workflows/build.yml/badge.svg)](https://github.com/MainPlay-TG/MainShortcuts2.py/actions/workflows/build.yml)
+<a href="https://pypi.org/project/MainShortcuts2/"><img alt="PyPi" src="https://img.shields.io/pypi/format/mainshortcuts2?style=flat&label=PyPi"/></a>
 ## Описание
 Сокращение и улучшение функций
 ## Установка

{mainshortcuts2-2.7.0 → mainshortcuts2-2.7.2}/README.md

@@ -1,4 +1,6 @@
 # MainShortcuts2
+[![Build and upload release](https://github.com/MainPlay-TG/MainShortcuts2.py/actions/workflows/build.yml/badge.svg)](https://github.com/MainPlay-TG/MainShortcuts2.py/actions/workflows/build.yml)
+<a href="https://pypi.org/project/MainShortcuts2/"><img alt="PyPi" src="https://img.shields.io/pypi/format/mainshortcuts2?style=flat&label=PyPi"/></a>
 ## Описание
 Сокращение и улучшение функций
 ## Установка

{mainshortcuts2-2.7.0 → mainshortcuts2-2.7.2}/pyproject.toml

@@ -1,5 +1,5 @@
 [tool.poetry]
-version = "2.7.0"
+version = "2.7.2"
 name = "MainShortcuts2"
 description = "Сокращение и улучшение функций + консольные утилиты"
 authors = ["MainPlay TG <xbox.roman6666666666@gmail.com>"]

mainshortcuts2-2.7.2/src/MainShortcuts2/api/github.py

@@ -0,0 +1,383 @@
+import os
+import requests
+from .base import BaseClient, ObjectBase
+from functools import cached_property
+from pathlib import Path
+from typing import IO
+from urllib.parse import urlparse
+__all__ = [
+    "Client",
+    "Release",
+    "ReleaseAsset",
+    "UrlInfo",
+    "User",
+]
+
+
+class _CatBase:
+  _n: str
+
+  def __init__(self, client: "Client"):
+    self._c = client
+
+  def _r(self, httpm: str, apim: str, **kw):
+    return self._c.request(httpm, self._n + "/" + apim, **kw)
+
+
+class _ObjBase(ObjectBase):
+  client: "Client"
+
+  @classmethod
+  def _get(cls, client, data, **kw):
+    if data:
+      return cls(client, data, **kw)
+
+
+class _HasUrl(_ObjBase):
+  def __init__(self, client: BaseClient, raw: dict, *args, **kwargs):
+    super().__init__(client, raw, *args, **kwargs)
+    self.url: str = self["url"]
+
+  @cached_property
+  def url_info(self):
+    return UrlInfo(self.url)
+
+
+class UrlInfo:
+  asset_id: int | None
+  release_id: int | None
+  release_tag: str | None
+  repo: str | None
+  username: str | None
+
+  def __init__(self, url: str):
+    parsed = urlparse(url)
+    path = parsed.path.split("/")
+    self.repo = None
+    self.username = None
+    l = len(path)
+    if parsed.hostname == "api.github.com":
+      if l > 2 and path[1] in ("repos", "users"):
+        self.username = path[2]
+        if l > 3 and path[1] == "repos":
+          self.repo = path[3]
+          if l > 5 and path[4] == "releases":
+            if path[5] == "assets" and l > 6 and path[6].isdigit():
+              self.asset_id = int(path[6])
+            elif path[5].isdigit():
+              self.release_id = int(path[5])
+    elif parsed.hostname == "github.com":
+      if l > 1:
+        self.username = path[1]
+        if l > 2:
+          self.repo = path[2]
+          if l > 4 and path[3] == "releases":
+            self.release_tag = path[4]
+    else:
+      raise ValueError("Unknown hostname: %s" % parsed.hostname)
+
+  def get_asset(self, client: "Client"):
+    if self.asset_id:
+      return client.release_assets.get(self.username, self.repo, self.asset_id)
+
+  def get_release(self, client: "Client"):
+    if self.release_id:
+      return client.releases.get(self.username, self.repo, self.release_id)
+    if self.release_tag:
+      return client.releases.get_by_tag_name(self.username, self.repo, self.release_tag)
+
+  def get_user(self, client: "Client"):
+    if self.username:
+      return client.users.get(self.username)
+
+
+class User(_HasUrl):
+  """A GitHub user."""
+
+  def _init(self):
+    self.avatar_url: str = self["avatar_url"]
+    self.email: str | None = self["email"]
+    self.events_url: str = self["events_url"]
+    self.followers_url: str = self["followers_url"]
+    self.following_url: str = self["following_url"]
+    self.gists_url: str = self["gists_url"]
+    self.gravatar_id: str | None = self["gravatar_id"]
+    self.html_url: str = self["html_url"]
+    self.id: int = self["id"]
+    self.login: str = self["login"]
+    self.name: str | None = self["name"]
+    self.node_id: str = self["node_id"]
+    self.organizations_url: str = self["organizations_url"]
+    self.received_events_url: str = self["received_events_url"]
+    self.repos_url: str = self["repos_url"]
+    self.site_admin: bool = self["site_admin"]
+    self.starred_at: str | None = self["starred_at"]
+    self.starred_url: str = self["starred_url"]
+    self.subscriptions_url: str = self["subscriptions_url"]
+    self.type: str = self["type"]
+    self.user_view_type: str | None = self["user_view_type"]
+
+  def reload(self):
+    return self.client.users.get(self.login)
+
+
+class Release(_HasUrl):
+  """A release."""
+
+  def _init(self):
+    self.assets_url: str = self["assets_url"]
+    self.assets = [ReleaseAsset(self.client, i) for i in self["assets"]]  # type: ignore
+    self.author = User(self.client, self["author"])
+    self.body_html: str | None = self["body_html"]
+    self.body_text: str | None = self["body_text"]
+    self.body: str | None = self["body"]
+    self.created_at: str = self["created_at"]
+    self.discussion_url: str | None = self["discussion_url"]
+    self.draft: bool = self["draft"]
+    self.html_url: str = self["html_url"]
+    self.id: int = self["id"]
+    self.immutable: bool = self["immutable"]
+    self.mentions_count: int | None = self["mentions_count"]
+    self.name: str | None = self["name"]
+    self.node_id: str = self["node_id"]
+    self.prerelease: bool = self["prerelease"]
+    self.published_at: str | None = self["published_at"]
+    self.tag_name: str = self["tag_name"]
+    self.tarball_url: str | None = self["tarball_url"]
+    self.target_commitish: str = self["target_commitish"]
+    self.updated_at: str | None = self["updated_at"]
+    self.upload_url: str = self["upload_url"]
+    self.zipball_url: str | None = self["zipball_url"]
+
+  def delete(self):
+    self.client.releases.delete(self.url_info.username, self.url_info.repo, self.id)
+
+  def reload(self):
+    return self.client.releases.get(self.url_info.username, self.url_info.repo, self.id)
+
+  def update(self, **data):
+    return self.client.releases.update(self.url_info.username, self.url_info.repo, self.id, **data)
+
+
+class ReleaseAsset(_HasUrl):
+  """Data related to a release."""
+
+  def _init(self):
+    self.browser_download_url: str = self["browser_download_url"]
+    self.content_type: str = self["content_type"]
+    self.created_at: str = self["created_at"]
+    self.digest: str | None = self["digest"]
+    self.download_count: int = self["download_count"]
+    self.id: int = self["id"]
+    self.label: str | None = self["label"]
+    self.name: str = self["name"]
+    self.node_id: str = self["node_id"]
+    self.size: int = self["size"]
+    self.state: str = self["state"]
+    self.type: str | None = self["type"]
+    self.updated_at: str = self["updated_at"]
+    self.uploader = User._get(self.client, self["uploader"])
+
+  def delete(self):
+    self.client.release_assets.delete(self.url_info.username, self.url_info.repo, self.id)
+
+  def reload(self):
+    return self.client.release_assets.get(self.url_info.username, self.url_info.repo, self.id)
+
+  def update(self, **data):
+    return self.client.release_assets.update(self.url_info.username, self.url_info.repo, self.id, **data)
+
+
+class Client(BaseClient):
+  class _ReleaseAssets(_CatBase):
+    def _r(self, httpm, owner, repo, asset_id, **kw):
+      return self._c.request(httpm, f"repos/{owner}/{repo}/releases/assets/{asset_id}", **kw)
+
+    def delete(self, owner: str, repo: str, asset_id: int):
+      """Delete a release asset"""
+      self._r("DELETE", owner, repo, asset_id)
+
+    def get(self, owner: str, repo: str, asset_id: int):
+      """Get a release asset"""
+      return ReleaseAsset(self._c, self._r("GET", owner, repo, asset_id))
+
+    def list(self, owner: str, repo: str, release_id: int, per_page=30, page=1):
+      """List release assets"""
+      resp: list = self._c.request("GET", f"repos/{owner}/{repo}/releases/{release_id}/assets", params={"per_page": per_page, "page": page})
+      return [ReleaseAsset(self._c, i) for i in resp]
+
+    def update(self, owner: str, repo: str, asset_id: int, *,
+               label: str = None,
+               name: str = None,
+               state: str = None,
+               ):
+      """Update a release asset"""
+      data = {}
+      if label:
+        data["label"] = label
+      if name:
+        data["name"] = name
+      if state:
+        data["state"] = state
+      if not data:
+        return self.get(owner, repo, asset_id)
+      return ReleaseAsset(self._c, self._r("PATCH", owner, repo, asset_id, json=data))
+
+    def upload(self, owner: str, repo: str, release_id: int, data: bytes | Path | IO[bytes], name: str = None, label: str = None, **kw):
+      """Upload a release asset"""
+      kw.setdefault("headers", {})
+      if isinstance(data, Path):
+        with data.open("rb") as f:
+          kw["label"] = label
+          kw["name"] = name or data.name
+          return self.upload(owner, repo, release_id, f, **kw)
+      elif isinstance(data, bytes):
+        kw["data"] = data
+        kw["headers"]["Content-Length"] = len(data)
+      else:
+        pos = data.tell()
+        data.seek(0, os.SEEK_END)
+        kw["headers"]["Content-Length"] = data.tell()
+        data.seek(pos)
+        kw["data"] = data
+        if not name:
+          fname = getattr(data, "name", None)
+          if fname:
+            name = os.path.basename(fname)
+      kw.setdefault("params", {})
+      if label:
+        kw["params"]["label"] = label
+      if not name:
+        raise ValueError("You must specify the name")
+      kw["headers"].setdefault("Content-Type", "application/octet-stream")
+      kw["params"]["name"] = name
+      resp = self._c.request("POST", f"/repos/{owner}/{repo}/releases/{release_id}/assets", **kw)
+      return ReleaseAsset(self._c, resp)
+
+  class _Releases(_CatBase):
+    def _r(self, httpm, owner, repo, release_id, **kw):
+      return self._c.request(httpm, f"repos/{owner}/{repo}/releases/{release_id}", **kw)
+
+    def create(self, owner: str, repo: str, tag_name: str,
+               body: str = None,
+               discussion_category_name: str = None,
+               draft=False,
+               generate_release_notes=False,
+               make_latest="true",
+               name: str = None,
+               prerelease=False,
+               target_commitish: str = None,
+               **kw):
+      kw.setdefault("json", {})
+      kw["json"]["draft"] = bool(draft)
+      kw["json"]["generate_release_notes"] = bool(generate_release_notes)
+      kw["json"]["make_latest"] = make_latest
+      kw["json"]["prerelease"] = bool(prerelease)
+      kw["json"]["tag_name"] = tag_name
+      if body:
+        kw["json"]["body"] = body
+      if discussion_category_name:
+        kw["json"]["discussion_category_name"] = discussion_category_name
+      if name:
+        kw["json"]["name"] = name
+      if target_commitish:
+        kw["json"]["target_commitish"] = target_commitish
+      resp = self._c.request("POST", f"repos/{owner}/{repo}/releases", **kw)
+      return Release(self._c, resp)
+
+    def delete(self, owner: str, repo: str, release_id: int):
+      self._r("DELETE", owner, repo, release_id)
+
+    def get(self, owner: str, repo: str, release_id: int):
+      return Release(self._c, self._r("GET", owner, repo, release_id))
+
+    def get_by_tag_name(self, owner: str, repo: str, tag_name: str):
+      return Release(self._c, self._r("GET", owner, repo, f"tags/{tag_name}"))
+
+    def get_latest(self, owner: str, repo: str):
+      return Release(self._c, self._r("GET", owner, repo, "latest"))
+
+    def list(self, owner: str, repo: str, per_page=30, page=1, **kw):
+      resp: list = self._c.request("GET", f"repos/{owner}/{repo}/releases", params={"per_page": per_page, "page": page})
+      return [Release(self._c, i) for i in resp]
+
+    def update(self, owner: str, repo: str, release_id: int,
+               body: str = None,
+               discussion_category_name: str = None,
+               draft: bool = None,
+               make_latest: str = None,
+               name: str = None,
+               prerelease: bool = None,
+               tag_name: str = None,
+               target_commitish: str = None,
+               **kw):
+      kw.setdefault("json", {})
+      if body is not None:
+        kw["json"]["body"] = body
+      if discussion_category_name is not None:
+        kw["json"]["discussion_category_name"] = discussion_category_name
+      if draft is not None:
+        kw["json"]["draft"] = bool(draft)
+      if make_latest is not None:
+        kw["json"]["make_latest"] = make_latest
+      if name is not None:
+        kw["json"]["name"] = name
+      if prerelease is not None:
+        kw["json"]["prerelease"] = bool(prerelease)
+      if tag_name is not None:
+        kw["json"]["tag_name"] = tag_name
+      if target_commitish is not None:
+        kw["json"]["target_commitish"] = target_commitish
+      if not kw["json"]:
+        return self.get(owner, repo, release_id)
+      return Release(self._c, self._r("PATCH", owner, repo, release_id, **kw))
+
+  class _Users(_CatBase):
+    _n = "users"
+
+    def get(self, username: str):
+      return User(self._c, self._r("GET", username))
+
+  def __init__(self, token: str = None, **kw):
+    self._init(**kw)
+    self._headers["Accept"] = "application/vnd.github+json"
+    self._headers["X-GitHub-Api-Version"] = "2022-11-28"
+    self._url = "https://api.github.com/{method}"
+    self.token = token
+    # Категории запросов
+    self.release_assets = self._ReleaseAssets(self)
+    self.releases = self._Releases(self)
+    self.users = self._Users(self)
+
+  @property
+  def token(self) -> str | None:
+    return self.__dict__.get("token")
+
+  @token.setter
+  def token(self, v):
+    if v is None:
+      self.__dict__.pop("token", None)
+      self._headers.pop("Authorization", None)
+    elif isinstance(v, str):
+      if not v:
+        self.token = None
+        return
+      self.__dict__["token"] = v
+      self._headers["Authorization"] = "Bearer " + v
+    else:
+      raise TypeError("Token must be str")
+
+  @classmethod
+  def from_env(cls, allow_no_token=False, **kw):
+    """Создать клиент, взяв токен из переменной среды если он не указан аргументом"""
+    if kw.get("token"):
+      return cls(**kw)  # Токен указан в аргументах
+    if allow_no_token:
+      return cls(os.environ.get("GITHUB_TOKEN"), **kw)  # Может быть без токена
+    return cls(os.environ["GITHUB_TOKEN"], **kw)  # Токен обязателен
+
+  def request(self, httpm, apim, raw=False, **kw) -> dict | list | requests.Response:
+    if raw:
+      return self._request(httpm, apim, **kw)
+    with self._request(httpm, apim, **kw) as resp:
+      return resp.json()

mainshortcuts2-2.7.2/src/MainShortcuts2/ex/aiohttp_ex/web.py

@@ -0,0 +1,158 @@
+import sys
+import typing
+import warnings
+from aiohttp import BasicAuth, hdrs, web
+from aiohttp.typedefs import Handler
+from aiohttp.web import FileResponse, Request, Response, StreamResponse
+from logging import DEBUG
+from MainShortcuts2 import ms
+from pathlib import Path
+warnings.filterwarnings("ignore", "Inheritance class .* from web.Application is discouraged", DeprecationWarning)
+
+
+def wrap_handler(app: "Application", handler: Handler):
+  async def wrapper(req: Request) -> StreamResponse | typing.Any:
+    try:
+      resp = await handler(req)
+      if isinstance(resp, int):
+        resp = Response(status=resp)
+      elif isinstance(resp, Path):
+        resp = FileResponse(resp)
+    except Exception as exc:
+      app.logger.exception("Failed to process request", exc_info=exc)
+      resp = Response(status=500, reason="Internal server error")
+    if app.logger.isEnabledFor(DEBUG):
+      remote = req.remote or "unknown"
+      if "X-Real-IP" in req.headers:
+        remote += " (real IP: %s)" % req.headers["X-Real-IP"]
+      status = resp.status if isinstance(resp, StreamResponse) else repr(resp)
+      app.logger.debug("Request %s %s from %s, return %s", req.method, req.raw_path, remote, status)
+    return resp
+  return wrapper
+
+
+class Application(web.Application):
+  def run(self, **kw):
+    """Запустить приложение"""
+    kw.setdefault("print", self.logger.info)
+    web.run_app(self, **kw)
+
+  def run_local(self, port: int, **kw):
+    """Запустить локально на указанном порту"""
+    self.run(host="127.0.0.1", port=port, **kw)
+
+  def on_request(self, methods: str | list[str], paths: str | list[str], add_slash=True, **kw):
+    """Зарегистрировать обработчик запросов"""
+    if isinstance(methods, str):
+      methods = [methods]
+    if isinstance(paths, str):
+      paths = [paths]
+
+    def deco(func: Handler):
+      wrapper = wrap_handler(self, func)
+      for m in methods:
+        for p in paths:
+          self._on_request(wrapper, m, p, add_slash, **kw)
+      return func
+    return deco
+
+  def _on_request(self, func: Handler, method: str, path: str, add_slash=True, **kw):
+    if path == "/":
+      add_slash = False
+    if add_slash:
+      path = path.rstrip("/")
+    self.router.add_route(method, path, func, **kw)
+    if add_slash:
+      self.router.add_route(method, path + "/", func, **kw)
+
+  def on_any_path_request(self, methods: str | list[str], **kw):
+    """Зарегистрировать обработчик запросов на любой путь"""
+    return self.on_request(methods, "/{tail:.*}", False, **kw)
+
+
+def auth_header(header=hdrs.AUTHORIZATION, value=None):
+  """Простая авторизация заголовком. Если не указать требуемое значение, будет проверять только наличие заголовка"""
+  def deco(func: Handler):
+    async def wrapper(req: Request):
+      if header in req.headers:
+        if value is not None:
+          if req.headers[header] != value:
+            return Response(status=403)  # Заголовок не совпадает
+        return await func(req)  # Заголовок совпадает или значение не указано
+      return Response(status=401)  # Заголовок отсутствует
+    return wrapper
+  return deco
+
+
+basic_unauthorized_headers = {"WWW-Authenticate": 'Basic realm="Basic Auth"'}
+
+
+def auth_basic(header=hdrs.AUTHORIZATION, filter: typing.Callable[[BasicAuth], bool] = ms.utils.return_True):
+  """Авторизация `Basic`. Если не указать фильтр, только проверяет наличие заголовка"""
+  def deco(func: typing.Callable[[Request, BasicAuth], typing.Awaitable[StreamResponse]]):
+    async def wrapper(req: Request):
+      if header in req.headers:
+        try:
+          auth = BasicAuth.decode(req.headers[header])
+        except Exception:
+          return Response(status=400, headers=basic_unauthorized_headers)  # Неправильный заголовок
+        if filter(auth):
+          return await func(req, auth)  # Одобрено
+        return Response(status=403)  # Запрещено
+      return Response(status=401, headers=basic_unauthorized_headers)  # Заголовок отсутствует
+    return wrapper
+  return deco
+
+
+@ms.utils.main_func(__name__)
+def main(args=None, **kw):
+  if args is None:
+    from argparse import ArgumentParser
+    argp = ArgumentParser()
+    argp.add_argument("--backlog", default=128, type=int)
+    argp.add_argument("--handler-cancellation", action="store_true")
+    argp.add_argument("--handler", help="функция для обработки всех запросов (module:variable)")
+    argp.add_argument("--keepalive-timeout", default=75, type=int)
+    argp.add_argument("--no-handle-signals", action="store_true")
+    argp.add_argument("--no-print", action="store_true", help="отключить вывод запросов")
+    argp.add_argument("--shutdown-timeout", default=60, type=int)
+    argp.add_argument("-H", "--host", default="127.0.0.1", help="IP для прослушивания")
+    argp.add_argument("-p", "--port", default=8080, type=int, help="порт для прослушивания")
+    argp.description = "Простой HTTP сервер, выводящий содержимое всех запросов"
+    args = argp.parse_args()
+  app = Application()
+  log = ms.utils.mini_log
+  if args.handler:
+    import importlib
+    m_name, f_name = args.handler.split(":", 1)
+    custom_handler = getattr(importlib.import_module(m_name), f_name)
+  else:
+    async def custom_handler(req: Request):
+      return 200
+  do_print = not args.no_print
+
+  @app.on_any_path_request(["DELETE", "GET", "HEAD", "OPTIONS", "PATCH", "POST", "PUT"])
+  async def _(req: Request):
+    if do_print:
+      log("Request %s %s from %s", req.method, req.raw_path, req.remote)
+      log("Headers:")
+      for k, v in req.headers.items():
+        log("- %s: %s", k, v)
+      has_content = False
+      async for chunk, _ in req.content.iter_chunks():
+        if chunk:
+          if not has_content:
+            has_content = True
+            log("Content: ")
+          sys.stderr.buffer.write(chunk)
+      log("")
+    return await custom_handler(req)
+  kw["backlog"] = args.backlog
+  kw["handle_signals"] = not args.no_handle_signals
+  kw["handler_cancellation"] = args.handler_cancellation
+  kw["host"] = args.host
+  kw["keepalive_timeout"] = args.keepalive_timeout
+  kw["port"] = args.port
+  kw["print"] = log
+  kw["shutdown_timeout"] = args.shutdown_timeout
+  app.run(**kw)

{mainshortcuts2-2.7.0 → mainshortcuts2-2.7.2}/src/MainShortcuts2/term.py

@@ -299,3 +299,131 @@ def countful_countdown(time: float, interval: float = 1, format: str = None, rou
 
 
 cls = clear
+
+
+class Choice(ms.ObjectBase):
+  """Промпт пользователю на выбор опций"""
+
+  def __init__(self, choices: dict[str, str | None],
+               aliases: dict[str, str] = None,
+               default: str | set[str] = None,
+               multiple=False,
+               values_in_prompt=True,
+               ):
+    self.choices: dict[str, str | None] = {}
+    for k, v in choices.items():
+      self.add_choice(k, v)
+    self.aliases = aliases or {}
+    if default is None:
+      self.default = None
+    elif isinstance(default, str):
+      self.default = set([default])
+    elif isinstance(default, (list, set, tuple)):
+      self.default = set(default)
+    else:
+      raise TypeError("Default choice must be str, set[str] or None")
+    self.multiple = bool(multiple)
+    self.values_in_prompt = bool(values_in_prompt)
+
+  def add_choice(self, value: str, desc: str | None, override=False):
+    """Добавить пункт для выбора. Описание может быть пустым"""
+    if not isinstance(value, str):
+      raise TypeError("Value must be str")
+    if (desc is not None) and (not isinstance(desc, str)):
+      raise TypeError("The description must be None or str")
+    if (not override) and (value in self.choices):
+      raise ValueError(f"Choice already exists: {value}")
+    self.choices[value] = desc or None
+
+  def _print_choices(self):
+    if not any(self.choices.values()):
+      return
+    for value, desc in self.choices.items():
+      if not desc:
+        desc = "{no description}"
+      print(f"{value}: {desc}")
+
+  def _make_prompt(self):
+    parts = ["Enter choice"]
+    if self.multiple:
+      parts.append("s")
+    if self.values_in_prompt:
+      parts.append(" (")
+      parts.append("/".join(self.choices))
+      parts.append(")")
+    parts.append(": ")
+    return "".join(parts)
+
+  def _prompt(self):
+    result: set[str] = set()
+    split = [i.strip() for i in input(self._make_prompt()).split(",")]
+    for i in split:
+      if i:
+        result.add(i)
+    return result
+
+  def run(self):
+    self._print_choices()
+    while True:
+      print()
+      results = self._prompt()
+      if len(results) == 0:
+        if self.default is None:
+          print("Error: enter the value")
+          continue
+        results = self.default
+      elif (not self.multiple) and len(results) > 1:
+        print("Error: only one choice is allowed")
+        continue
+      completed_results: set[str] = set()
+      not_exist: set[str] = set()
+      for i in results:
+        while i in self.aliases:
+          i = self.aliases[i]
+        if i not in self.choices:
+          not_exist.add(i)
+        completed_results.add(i)
+      if len(not_exist) == 1:
+        print("Error: value %s do not exist" % not_exist.pop())
+        continue
+      elif len(not_exist) > 1:
+        print("Error: values %s do not exist" % ", ".join(not_exist))
+        continue
+      return completed_results
+
+  @classmethod
+  def simple_yes_no(cls, **kw):
+    """Спросить `y` или `n`"""
+    self = cls({"n": None, "y": None}, multiple=False, **kw)
+    for func in (str, str.lower, str.upper):
+      self.aliases[func("Д")] = "y"
+      self.aliases[func("Да")] = "y"
+      self.aliases[func("Н")] = "n"
+      self.aliases[func("Нет")] = "n"
+      self.aliases[func("No")] = "n"
+      self.aliases[func("Yes")] = "y"
+    return self.run().pop() == "y"
+
+  @classmethod
+  def simple_list(cls, choices: set[str], **kw):
+    """Спросить номер пункта"""
+    c = {}
+    for n, i in enumerate(choices):
+      c[str(n + 1)] = i
+    self = cls(c, **kw)
+    return {int(i) for i in self.run()}
+
+  @classmethod
+  def simple_ynAN(cls, **kw):
+    """`yes`/`no`/`All`/`Never`"""
+    self = cls({}, multiple=False, **kw)
+    self.add_choice("y", "Yes")
+    self.add_choice("n", "No")
+    self.add_choice("A", "All")
+    self.add_choice("N", "Never")
+    for func in (str, str.lower, str.upper):
+      self.aliases[func("All")] = "A"
+      self.aliases[func("Never")] = "N"
+      self.aliases[func("No")] = "n"
+      self.aliases[func("Yes")] = "y"
+    return self.run().pop()

{mainshortcuts2-2.7.0 → mainshortcuts2-2.7.2}/src/MainShortcuts2/utils.py

@@ -585,10 +585,7 @@ def disable_warnings():
 
 def is_instance_of_one(obj, *classes: type) -> bool:
   """Это экземпляр одного из классов?"""
-  for i in classes:
-    if isinstance(obj, i):
-      return True
-  return False
+  return isinstance(obj, classes)
 
 
 def is_instance_of_all(obj, *classes: type) -> bool:
@@ -881,14 +878,14 @@ class TempFlag(ms.types.BoolFlag):
 
 class SimpleLogger(logging.Logger):
   """Простой логгер"""
-  CRITICAL: int = logging.CRITICAL
-  DEBUG: int = logging.DEBUG
-  ERROR: int = logging.ERROR
-  FATAL: int = logging.FATAL
-  INFO: int = logging.INFO
-  NOTSET: int = logging.NOTSET
-  WARN: int = logging.WARN
-  WARNING: int = logging.WARNING
+  CRITICAL = logging.CRITICAL
+  DEBUG = logging.DEBUG
+  ERROR = logging.ERROR
+  FATAL = logging.FATAL
+  INFO = logging.INFO
+  NOTSET = logging.NOTSET
+  WARN = logging.WARN
+  WARNING = logging.WARNING
 
   def __init__(self, name: str, level: int = logging.INFO, full_global=False, init_msg=True):
     # Выбрать случайное название
@@ -1064,3 +1061,43 @@ def iter_caller_modules():
       frame = frame.f_back
   finally:
     del frame
+
+
+def parse_shaXsums_hex(lines: str | list[str]):
+  """Парсить файлы в формате `sha256sums.txt`"""
+  if isinstance(lines, str):
+    lines = lines.splitlines()
+  result: dict[str, str] = {}  # filename: hex value
+  for line in lines:
+    line = line.strip()
+    if not line or line.startswith('#'):
+      continue
+    parts = line.replace("  ", " ").split(None, 1)
+    if len(parts) == 2:
+      hex_value, filename = parts
+      result[filename] = hex_value.lower()
+  return result
+
+
+def parse_shaXsums_bytes(lines: str | list[str]):
+  """Парсить файлы в формате `sha256sums.txt`, декодируя хеш"""
+  return {k: bytes.fromhex(v) for k, v in parse_shaXsums_hex(lines).items()}
+
+
+def guess_checksum_alg(digest_len: int):
+  """Найти алгоритм хеширования по длине хеша"""
+  if not "hash_len" in cache:
+    import hashlib
+    c = {}
+    for alg in hashlib.algorithms_available:
+      try:
+        c[alg] = len(hashlib.new(alg).digest())
+      except Exception:
+        pass
+    cache["hash_len"] = c
+  c: dict[str, int] = cache["hash_len"]
+  result: set[str] = set()
+  for k, v in c.items():
+    if digest_len == v:
+      result.add(k)
+  return result