MainShortcuts2 2.7.2__tar.gz → 2.7.3__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: MainShortcuts2
-Version: 2.7.2
+Version: 2.7.3
 Summary: Сокращение и улучшение функций + консольные утилиты
 Author: MainPlay TG
 Author-email: xbox.roman6666666666@gmail.com

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

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

mainshortcuts2-2.7.3/src/MainShortcuts2/_module_info.py

@@ -0,0 +1,2 @@
+name = 'mainshortcuts2'
+version = '2.7.3'

{mainshortcuts2-2.7.2 → mainshortcuts2-2.7.3}/src/MainShortcuts2/api/github.py

@@ -2,6 +2,7 @@ import os
 import requests
 from .base import BaseClient, ObjectBase
 from functools import cached_property
+from MainShortcuts2 import ms
 from pathlib import Path
 from typing import IO
 from urllib.parse import urlparse
@@ -12,6 +13,7 @@ __all__ = [
     "UrlInfo",
     "User",
 ]
+MAX_PER_PAGE = 100
 
 
 class _CatBase:
@@ -149,6 +151,15 @@ class Release(_HasUrl):
     self.upload_url: str = self["upload_url"]
     self.zipball_url: str | None = self["zipball_url"]
 
+  @property
+  def asset_names(self):
+    return {i.name for i in self.assets}
+
+  @property
+  def assets_by_name(self):
+    return {i.name: i for i in self.assets}
+
+  @property
   def delete(self):
     self.client.releases.delete(self.url_info.username, self.url_info.repo, self.id)
 
@@ -158,6 +169,9 @@ class Release(_HasUrl):
   def update(self, **data):
     return self.client.releases.update(self.url_info.username, self.url_info.repo, self.id, **data)
 
+  def iter_online_assets(self, count=MAX_PER_PAGE):
+    return self.client.release_assets.list_iter(self.url_info.username, self.url_info.repo, self.id, count)
+
 
 class ReleaseAsset(_HasUrl):
   """Data related to a release."""
@@ -181,6 +195,22 @@ class ReleaseAsset(_HasUrl):
   def delete(self):
     self.client.release_assets.delete(self.url_info.username, self.url_info.repo, self.id)
 
+  def download(self, path, check=True, **kw):
+    kw.setdefault("session", self.client.http)
+    result = ms.utils.download_file(self.browser_download_url, path, **kw)
+    if check:
+      mpath = ms.path.Path(path)
+      if self.size != mpath.size:
+        mpath.delete()
+        raise RuntimeError("The file is corrupted (size difference)")
+      if self.digest:
+        alg, asset_hex = self.digest.split(":", 1)
+        local_hex = mpath.hash_hex(alg)
+        if asset_hex != local_hex:
+          mpath.delete()
+          raise RuntimeError("The file is corrupted (hash difference)")
+    return result
+
   def reload(self):
     return self.client.release_assets.get(self.url_info.username, self.url_info.repo, self.id)
 
@@ -201,11 +231,23 @@ class Client(BaseClient):
       """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):
+    def list(self, owner: str, repo: str, release_id: int, per_page=MAX_PER_PAGE, 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 list_iter(self, owner: str, repo: str, release_id: int, count=100):
+      page = 1
+      completed = 0
+      while completed < count:
+        per_page = min(count - completed, MAX_PER_PAGE)
+        releases = self.list(owner, repo, release_id, per_page, page)
+        if not releases:
+          break
+        yield from releases
+        completed += len(releases)
+        page += 1
+
     def update(self, owner: str, repo: str, asset_id: int, *,
                label: str = None,
                name: str = None,
@@ -297,10 +339,22 @@ class Client(BaseClient):
     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):
+    def list(self, owner: str, repo: str, per_page=MAX_PER_PAGE, page=1):
       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 list_iter(self, owner: str, repo: str, count=100):
+      page = 1
+      completed = 0
+      while completed < count:
+        per_page = min(count - completed, MAX_PER_PAGE)
+        releases = self.list(owner, repo, per_page, page)
+        if not releases:
+          break
+        yield from releases
+        completed += len(releases)
+        page += 1
+
     def update(self, owner: str, repo: str, release_id: int,
                body: str = None,
                discussion_category_name: str = None,
@@ -373,8 +427,10 @@ class Client(BaseClient):
     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)  # Токен обязателен
+      kw["token"] = os.environ.get("GITHUB_TOKEN")
+    else:
+      kw["token"] = os.environ["GITHUB_TOKEN"]
+    return cls(**kw)
 
   def request(self, httpm, apim, raw=False, **kw) -> dict | list | requests.Response:
     if raw:

mainshortcuts2-2.7.2/src/MainShortcuts2/ex/aiohttp_ex/web.py → mainshortcuts2-2.7.3/src/MainShortcuts2/ex/aiohttp_ex/web/__init__.py

@@ -1,4 +1,3 @@
-import sys
 import typing
 import warnings
 from aiohttp import BasicAuth, hdrs, web
@@ -102,57 +101,3 @@ def auth_basic(header=hdrs.AUTHORIZATION, filter: typing.Callable[[BasicAuth], b
       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.3/src/MainShortcuts2/ex/aiohttp_ex/web/__main__.py

@@ -0,0 +1,56 @@
+import importlib
+import sys
+from MainShortcuts2.ex.aiohttp_ex.web import *
+
+
+@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:
+    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.3/src/MainShortcuts2/ex/urlparse_ex.py

@@ -0,0 +1,24 @@
+from functools import cached_property
+from urllib import parse
+from types import MappingProxyType
+
+
+class ParseResult(parse.ParseResult):
+  @cached_property
+  def path_parts(self):
+    """`path.split('/')`"""
+    return tuple(self.path.split("/"))
+
+  @cached_property
+  def query_dict(self):
+    return MappingProxyType(dict(self.parse_qsl(keep_blank_values=True)))
+
+  @classmethod
+  def from_url(cls, url: str, **kw):
+    return cls(*parse.urlparse(url, **kw))
+
+  def parse_qs(self, **kw):
+    return parse.parse_qs(self.query, **kw)
+
+  def parse_qsl(self, **kw):
+    return parse.parse_qsl(self.query, **kw)

mainshortcuts2-2.7.3/src/MainShortcuts2/java_ext/__init__.py

@@ -0,0 +1,333 @@
+import os
+import re
+import shutil
+import subprocess
+import sys
+from datetime import datetime
+from functools import cached_property
+from MainShortcuts2 import ms
+from MainShortcuts2.api import github
+from MainShortcuts2.ex.pathlib_ex import Path
+JAVA_VERSION_PATTERN = re.compile(r'version\s+"([^"]+)"')
+SEARCH_RELEASE_COUNT = 1000
+
+
+class AssetNotFoundError(Exception):
+  pass
+
+
+class VersionNotFoundError(Exception):
+  pass
+
+
+def find_system_java():
+  plat = ms.advanced.get_platform()
+  suffix = ".exe" if plat.is_mustdie else ""
+  if os.environ.get("JAVA_HOME"):
+    file = (Path(os.environ["JAVA_HOME"]) / f"bin/java{suffix}").resolve()
+  else:
+    str_file = shutil.which("java")
+    if not str_file:
+      raise RuntimeError("System java not found")
+    file = Path(str_file).resolve()
+  if not file.is_file():
+    raise RuntimeError("System java not found")
+  return file
+
+
+def _parse_java_version(text: str):
+  return list(map(int, text.split("_", 1)[0].split(".")))
+
+
+def detect_java_version(file: Path):
+  release_file = file.parent.parent / "release"
+  if release_file.exists():
+    try:
+      for line in release_file.read_lines_iter(True):
+        if "=" in line:
+          k, v = map(str.strip, line.split("=", 1))
+          if k == "JAVA_VERSION":
+            return _parse_java_version(v.strip('"').strip("'"))
+    except Exception:
+      pass
+  try:
+    p = subprocess.run([str(file), "-version"], capture_output=True, check=True, text=True)
+    match = JAVA_VERSION_PATTERN.search(p.stderr + p.stdout)
+    return _parse_java_version(match.group(1))
+  except Exception:
+    raise RuntimeError("Couldn't determine the Java version") from None
+
+
+class IncompatibleJava(Exception):
+  pass
+
+
+class InfoDict(dict):
+  @property
+  def builded_at(self):
+    """Дата сборки релиза (Unix timestamp)"""
+    return self["builded_at"]
+
+  @cached_property
+  def builded_at_dt(self):
+    """Дата сборки релиза (`datetime`)"""
+    return datetime.fromtimestamp(self.builded_at)
+
+  @property
+  def classes(self) -> dict[str, str]:
+    """Словарь классов"""
+    return self.get("classes", {})
+
+  @property
+  def max_java_version(self) -> list[int] | None:
+    """Максимальная версия Java"""
+    return self.get("max_java_version")
+
+  @property
+  def min_java_version(self) -> list[int] | None:
+    """Минимальная версия Java"""
+    return self.get("max_java_version")
+
+  @property
+  def name(self):
+    """Название"""
+    return self["name"]
+
+  @property
+  def version(self):
+    """Название версии"""
+    return self["version"]
+
+  @property
+  def version_id(self):
+    """ID версии"""
+    return self["version_id"]
+
+  def check_java_file(self, file: Path):
+    if (self.max_java_version is None) and (self.min_java_version is None):
+      return True  # Нет информации о версии
+    return self.check_java_version(detect_java_version(file))
+
+  def check_java_version(self, version: list[int]):
+    if self.max_java_version is not None:
+      if version > self.max_java_version:
+        raise IncompatibleJava(f"Incompatible Java version (current: {version}, max: {self.max_java_version})")
+    if self.min_java_version is not None:
+      if self.min_java_version > version:
+        raise IncompatibleJava(f"Incompatible Java version (current: {version}, min: {self.min_java_version})")
+    return True
+
+  def version_id_in_range(self, min_id=0, max_id=sys.maxsize):
+    """Проверить находится ли ID версии в диапазоне"""
+    return bool(min_id <= self.version_id < max_id)
+
+
+class JavaExtManager(ms.ObjectBase):
+  """Менеджер версий JAR файла с кешированием"""
+
+  def __init__(self, repo_owner: str, repo_name: str, github_token=None):
+    self.gh = github.Client.from_env(True, token=github_token)
+    self.repo = repo_owner, repo_name
+    self.version_cache: "dict[str,JavaExtVersion]" = {}
+
+  @cached_property
+  def dir(self):
+    """Папка кеша"""
+    plat = ms.advanced.get_platform()
+    if plat.is_mustdie:
+      if os.environ.get("LOCALAPPDATA"):
+        base = Path(os.environ["LOCALAPPDATA"])
+      else:
+        base = Path.home() / "AppData/Local"
+    else:
+      if os.environ.get("XDG_DATA_HOME"):
+        base = Path(os.environ["XDG_DATA_HOME"])
+      else:
+        base = Path.home() / ".local/share"
+    result = base / "MainPlay_TG/MainShortcuts2/java_ext_cache_v1" / self.repo[0] / self.repo[1]
+    return result.resolve().any_mkdir()
+
+  def get_version(self, version_name: str):
+    """Получить определённую версию (по названию)"""
+    if not version_name in self.version_cache:
+      version = JavaExtVersion(self, version_name)
+      if version.info.version == version_name:
+        self.version_cache[version_name] = version
+    return self.version_cache[version_name]
+
+  def iter_online_releases(self, count=github.MAX_PER_PAGE):
+    """Итерация релизов с GitHub"""
+    return self.gh.releases.list_iter(*self.repo, count)
+
+  def iter_online_versions(self, count=github.MAX_PER_PAGE):
+    """Итерация версий с GitHub"""
+    for rel in self.iter_online_releases(count):
+      if rel.tag_name.startswith("v"):
+        ver = self.get_version(rel.tag_name[1:])
+        ver.__dict__["release"] = rel  # cached_property
+        yield ver
+
+  def iter_offline_versions(self):
+    """Итерация версий из кэша"""
+    for file in self.dir.iterdir():
+      if file.suffix == ".json" and file.is_file():
+        info = InfoDict(file.read_json())
+        ver = self.get_version(info.version)
+        ver.__dict__["info"] = info  # cached_property
+        yield ver
+
+  def iter_all_versions(self, online_count=github.MAX_PER_PAGE):
+    """Итерация версий из кэша и с GitHub"""
+    yield from self.iter_offline_versions()  # Сначала локальные
+    yield from self.iter_online_versions(online_count)
+
+  def search_has_class(self, class_name: str, max_count=SEARCH_RELEASE_COUNT):
+    """Найти версию с указанным классом"""
+    return self.search_has_classes([class_name], max_count)
+
+  def search_has_classes(self, class_names: set[str], max_count=SEARCH_RELEASE_COUNT):
+    """Найти версию, в которой есть все указанные классы"""
+    class_names = set(class_names)
+    for ver in self.iter_all_versions(max_count):
+      classes = ver.info.classes
+      if all(i in classes for i in class_names):
+        return ver
+    if len(class_names) == 1:
+      raise VersionNotFoundError("Has class: " + class_names.pop())
+    raise VersionNotFoundError("Has classes: " + ", ".join(class_names))
+
+  def search_version_id_range(self, min_id: int = 0, max_id=sys.maxsize, max_count=SEARCH_RELEASE_COUNT):
+    """Найти версию с ID в указанном диапазоне"""
+    for ver in self.iter_all_versions(max_count):
+      if ver.info.version_id_in_range(min_id, max_id):
+        return ver
+    raise VersionNotFoundError(f"{min_id} <= version_id <= {max_id}")
+
+  def search_version_id(self, version_id: int, max_count=SEARCH_RELEASE_COUNT):
+    """Найти версию с указанным ID"""
+    for ver in self.iter_all_versions(max_count):
+      if ver.info.version_id == version_id:
+        return ver
+    raise VersionNotFoundError(f"version_id == {version_id}")
+
+  def download_latest(self, count=1, download_jar=True):
+    """Скачать последнюю версию (если не скачана)"""
+    for ver in self.iter_online_versions(count):
+      ver.info  # Скачать файл JSON
+      if download_jar:
+        ver.jar_path  # Скачать файл JAR
+
+
+class JavaExtVersion(ms.ObjectBase):
+  """Версия JAR файла"""
+
+  def __init__(self, mgr: JavaExtManager, version_name: str):
+    self._java_bin = None
+    self._java_checked = True
+    self.mgr = mgr
+    self.version_name = version_name
+
+  @cached_property
+  def release(self):
+    """Релиз этой версии на GitHub"""
+    return self.mgr.gh.releases.get_by_tag_name(*self.mgr.repo, "v" + self.version_name)
+
+  @cached_property
+  def info_asset(self):
+    """Ассет файла информации на GitHub"""
+    return self._get_asset("info.json")
+
+  @cached_property
+  def info(self):
+    """Информация о версии (кэшируется)"""
+    if self.info_path.exists():
+      return InfoDict(self.info_path.read_json())
+    with ms.utils.request("GET", self.info_asset.browser_download_url, session=self.mgr.gh.http) as resp:
+      data = InfoDict(resp.json())
+    self.info_path.write_json(data)
+    return data
+
+  @cached_property
+  def info_path(self):
+    """Путь к файлу информации"""
+    return self.mgr.dir / f"{self.version_name}.json"
+
+  @cached_property
+  def jar_asset(self):
+    """Ассет JAR файла на GitHub"""
+    return self._get_asset(f"{self.info.name}-{self.info.version}.jar")
+
+  @cached_property
+  def _jar_path(self):
+    """Файл JAR (без скачивания)"""
+    return self.mgr.dir / f"{self.version_name}.jar"
+
+  @property
+  def jar_path(self):
+    """Файл JAR (кэшируется)"""
+    if not self._jar_path.exists():
+      ms.utils.mini_log("[MainShortcuts2/java_ext] Downloading %s from %s/%s (%s)", self._jar_path.name, *self.mgr.repo, self.jar_asset.browser_download_url)
+      self.jar_asset.download(self._jar_path)
+    return self._jar_path
+
+  @property
+  def java_bin(self) -> Path:
+    """Путь к исполняемому файлу Java (можно изменить)"""
+    if self._java_bin is None:
+      self._java_bin = find_system_java()
+      self._java_checked = False
+    return self._java_bin
+
+  @java_bin.setter
+  def java_bin(self, v):
+    if v is None:
+      self._java_bin = None
+      return
+    file = Path(v).resolve()
+    if not file.exists():
+      raise FileNotFoundError(file)
+    self._java_bin = file
+    self._java_checked = False
+
+  def _get_asset(self, name: str):
+    for i in self.release.assets:
+      if i.name == name:
+        return i
+    raise AssetNotFoundError(name)
+
+  def delete_cache(self, keep_info=True):
+    """Удалить версию из кэша (будет скачана автоматически при использовании"""
+    self._jar_path.remove()
+    if not keep_info:
+      self.info_path.remove()
+
+  def _popen(self, args, **kw):
+    if not self._java_checked:
+      self.info.check_java_file(self.java_bin)
+      self._java_checked = True
+    return subprocess.Popen([str(self.java_bin), *args], **kw)
+
+  def _run(self, args, **kw) -> subprocess.CompletedProcess:
+    kw.setdefault("check", True)
+    if not self._java_checked:
+      self.info.check_java_file(self.java_bin)
+      self._java_checked = True
+    return subprocess.run([str(self.java_bin), *args], **kw)
+
+  def popen_class_raw(self, class_path: str, args: list[str] = [], **kw):
+    return self._popen(["-cp", str(self.jar_path), class_path, *args], **kw)
+
+  def popen_class(self, class_name: str, args: list[str] = [], **kw):
+    return self.popen_class_raw(self.info.classes[class_name], args, **kw)
+
+  def popen(self, args: list[str], **kw):
+    return self._popen(["-jar", str(self.jar_path), *args], **kw)
+
+  def run_class_raw(self, class_path: str, args: list[str] = [], **kw):
+    return self._run(["-cp", str(self.jar_path), class_path, *args], **kw)
+
+  def run_class(self, class_name: str, args: list[str] = [], **kw):
+    return self.run_class_raw(self.info.classes[class_name], args, **kw)
+
+  def run(self, args: list[str], **kw):
+    return self._run(["-jar", str(self.jar_path), *args], **kw)

mainshortcuts2-2.7.3/src/MainShortcuts2/java_ext/ms2ext.py

@@ -0,0 +1,304 @@
+"""Функции для работы с большими файлами с помощью расширения на Java. При недоступности расширения будут использоваться встроенные функции"""
+import base64
+import hashlib
+import os
+import requests
+import subprocess
+import typing
+from concurrent.futures import ThreadPoolExecutor
+from contextlib import ExitStack
+from MainShortcuts2 import java_ext
+from MainShortcuts2 import ms
+from MainShortcuts2.ex.pathlib_ex import Path
+mgr = java_ext.JavaExtManager("MainPlay-TG", "MS2Ext.java")
+class2version: dict[str, java_ext.JavaExtVersion] = {}
+
+
+def get_ver(class_name):
+  if not class_name in class2version:
+    class2version[class_name] = mgr.search_has_class(class_name)
+  return class2version[class_name]
+
+
+def popen_class(class_name, **kw) -> subprocess.Popen[bytes]:
+  kw["stderr"] = subprocess.PIPE
+  kw["stdin"] = subprocess.PIPE
+  return get_ver(class_name).popen_class(class_name, **kw)
+
+
+class ExtCoreError(subprocess.CalledProcessError):
+  """Ошибка при запуске расширения (повтор через fallback)"""
+  pass
+
+
+class ExtOperationError(subprocess.CalledProcessError):
+  """Ошибка при работе расширения (конечная ошибка)"""
+  pass
+
+
+ErrorsForFallback = (
+    ExtCoreError,  # Не удалось запустить расширение
+    java_ext.IncompatibleJava,  # Несовместимая Java
+    requests.exceptions.RequestException,  # Не удалось скачать расширение
+)
+
+
+def run_class(class_name, config, timeout=None, **kw):
+  with popen_class(class_name) as p:
+    p.stdin.write(ms.json.encode(config).encode("utf-8"))
+    p.stdin.flush()
+    p.stdin.close()
+    if p.wait(timeout):
+      try:
+        stderr = p.stderr.read().decode("utf-8")
+        err_data = ms.json.decode(stderr)
+      except Exception:
+        raise ExtCoreError(p.returncode, p.args, p.stdout, p.stderr)
+      raise ExtOperationError(p.returncode, p.args, p.stdout, err_data)
+    stderr = p.stderr.read()
+  if not stderr:
+    return {}
+  return ms.json.decode(stderr.decode("utf-8"))
+
+
+class configs:
+  class _Base(dict):
+    def __setitem__(self, k, v):
+      if v is None:
+        return
+      dict.__setitem__(self, k, v)
+
+    def get(self, k, d=None):
+      if k in self:
+        return self[k] or d
+      return d
+
+  class FileDownloaderV1(_Base):
+    @property
+    def bufSize(self) -> int:
+      return self.get("bufSize") or 1024 * 32
+
+    @property
+    def checkStatus(self) -> bool:
+      return self.get("checkStatus", True)
+
+    @property
+    def followRedirects(self) -> bool:
+      return self.get("followRedirects", True)
+
+    @property
+    def headers(self) -> dict[str, str]:
+      return self.get("headers") or {}
+
+    @property
+    def method(self) -> str:
+      return self.get("method") or "GET"
+
+    @property
+    def path(self) -> str:
+      return self["path"]
+
+    @property
+    def query(self) -> dict[str, str]:
+      return self.get("query") or {}
+
+    @property
+    def sizeLimit(self) -> int | None:
+      return self.get("sizeLimit")
+
+    @property
+    def url(self) -> str:
+      return self["url"]
+
+    @property
+    def verify(self) -> bool:
+      return self.get("verify", True)
+
+  class _FileHasherBase(_Base):
+    @property
+    def algs(self) -> list[str]:
+      return self["algs"]
+
+    @property
+    def bufSize(self) -> int:
+      return self.get("bufSize") or 1024 * 1024 * 4
+
+  class FileHasherV1(_FileHasherBase):
+    @property
+    def path(self) -> str:
+      return self["path"]
+
+  class FileHasherV2(_FileHasherBase):
+    @property
+    def maxThreads(self) -> int:
+      return self.get("maxThreads") or 8
+
+    @property
+    def paths(self) -> list[str]:
+      return self["paths"]
+
+
+class results:
+  class FileDownloaderV1(dict):
+    @property
+    def downloadedSize(self) -> int:
+      return self["downloadedSize"]
+
+    @property
+    def headers(self) -> dict[str, list[str]]:
+      return self["headers"]
+
+    @property
+    def statusCode(self) -> int:
+      return self["statusCode"]
+
+  class FileHasherV1(dict[str, bytes]):
+    @classmethod
+    def _from_b64(cls, data: dict[str, str]):
+      return cls({k: base64.b64decode(v) for k, v in data.items()})
+  FileHasherV2 = dict[str, FileHasherV1]
+
+
+class real:
+  @classmethod
+  def file_downloader_v1(cls, config: configs.FileDownloaderV1, **kw):
+    return results.FileDownloaderV1(run_class("file_downloader_v1", config, **kw))
+
+  @classmethod
+  def file_hasher_v1(cls, config: configs.FileHasherV1, **kw):
+    if not config.get("algs"):
+      return results.FileHasherV1()
+    return results.FileHasherV1._from_b64(run_class("file_hasher_v1", config, **kw))
+
+  @classmethod
+  def file_hasher_v2(cls, config: configs.FileHasherV2, **kw):
+    if not config.get("paths"):
+      return results.FileHasherV2()
+    if not config.get("algs"):
+      return results.FileHasherV2({i: results.FileHasherV1() for i in config.paths})
+    result = run_class("file_hasher_v2", config, **kw)
+    return results.FileHasherV2({k: results.FileHasherV1._from_b64(v) for k, v in result.items()})
+
+
+class fallback:
+  @classmethod
+  def file_downloader_v1(cls, config: configs.FileDownloaderV1):
+    file = Path(config.path).resolve()
+    with ExitStack() as stack:
+      resp = stack.enter_context(requests.request(config.method, config.url,
+                                                  allow_redirects=config.followRedirects,
+                                                  headers=config.headers,
+                                                  params=config.query,
+                                                  stream=True,
+                                                  verify=config.verify,
+                                                  ))
+      if config.checkStatus:
+        resp.raise_for_status()
+      tmp = stack.enter_context(ms.path.TempFiles(file))  # Авто удаление недокачанного файла
+      f = stack.enter_context(file.open("wb"))  # Открытие файла
+      cls._download_file(resp.iter_content(config.bufSize), f.write, config.sizeLimit)  # Скачивание файла
+      tmp.files.clear()  # Отключить авто удаление
+      result = results.FileDownloaderV1()
+      result["statusCode"] = resp.status_code
+      result["downloadedSize"] = f.tell()
+      result["headers"] = {k: [v] for k, v in resp.headers.items()}
+    return result
+
+  @classmethod
+  def _download_file(cls, stream: typing.Iterable[bytes], write_func: typing.Callable[[bytes], None], sizeLimit: int | None):
+    if sizeLimit is None:
+      for buf in stream:
+        write_func(buf)
+      return
+    downloaded = 0
+    for buf in stream:
+      downloaded += len(buf)
+      if sizeLimit > downloaded:
+        raise OverflowError("The file is too big")
+      write_func(buf)
+
+  @classmethod
+  def file_hasher_v1(cls, config: configs.FileHasherV1):
+    if not config.get("algs"):
+      return results.FileHasherV1()
+    return cls._hash_file(Path(config.path), set(config.algs), config.bufSize)
+
+  @classmethod
+  def file_hasher_v2(cls, config: configs.FileHasherV2):
+    if not config.get("paths"):
+      return results.FileHasherV2()
+    if not config.get("algs"):
+      return results.FileHasherV2({i: results.FileHasherV1() for i in config.paths})
+    algs, bufsize = set(config.algs), config.bufSize
+    with ThreadPoolExecutor(config.maxThreads) as pool:
+      futures = {i: pool.submit(cls._hash_file, Path(i), algs, bufsize) for i in config.paths}
+      return results.FileHasherV2({k: v.result() for k, v in futures.items()})
+
+  @classmethod
+  def _hash_file(cls, file: Path, algs: set[str], bufSize: int):
+    hashmap = {i: hashlib.new(i) for i in algs}
+    update_func = [i.update for i in hashmap.values()]
+    with file.open("rb") as f:
+      read_func = f.read
+      while True:
+        buf = read_func(bufSize)
+        if not buf:
+          break
+        for uf in update_func:
+          uf(buf)
+      return results.FileHasherV1({k: v.digest() for k, v in hashmap.items()})
+
+
+def download_file(url: str, path: os.PathLike, *,
+                  bufSize: int = None,
+                  checkStatus=True,
+                  followRedirects=True,
+                  headers: dict[str, str] = None,
+                  method="GET",
+                  query: dict[str, str] = None,
+                  sizeLimit: int = None,
+                  verify=True,
+                  **kw):
+  """Скачать большой файл по HTTP"""
+  config = configs.FileDownloaderV1()
+  config["bufSize"] = bufSize
+  config["checkStatus"] = checkStatus
+  config["followRedirects"] = followRedirects
+  config["headers"] = headers
+  config["method"] = method
+  config["path"] = os.fspath(path)
+  config["query"] = query
+  config["sizeLimit"] = sizeLimit
+  config["url"] = url
+  config["verify"] = verify
+  if config.sizeLimit:
+    if config.bufSize > config.sizeLimit:
+      return fallback.file_downloader_v1(config)
+  try:
+    return real.file_downloader_v1(config, **kw)
+  except ErrorsForFallback:
+    return fallback.file_downloader_v1(config)
+
+
+def hash_file(path: os.PathLike, algs: set[str], *, bufSize: int = None, **kw):
+  """Хешировать большой файл"""
+  config = configs.FileHasherV1()
+  config["algs"] = list(algs)
+  config["bufSize"] = bufSize
+  config["path"] = os.fspath(path)
+  try:
+    return real.file_hasher_v1(config, **kw)
+  except ErrorsForFallback:
+    return fallback.file_hasher_v1(config)
+
+
+def hash_many_files(paths: set[os.PathLike], algs: set[str], *, bufSize: int = None, **kw):
+  """Хешировать несколько файлов"""
+  config = configs.FileHasherV2()
+  config["algs"] = list(algs)
+  config["bufSize"] = bufSize
+  config["paths"] = [os.fspath(i) for i in paths]
+  try:
+    return real.file_hasher_v2(config, **kw)
+  except ErrorsForFallback:
+    return fallback.file_hasher_v2(config)

{mainshortcuts2-2.7.2 → mainshortcuts2-2.7.3}/src/MainShortcuts2/ms2hash.py

@@ -86,7 +86,8 @@ class Format1:
 
 def hash_gen(args: argparse.Namespace = None):
   if args is None:
-    argp = argparse.ArgumentParser("ms2-hash_gen", description="создание контрольной суммы для файла")
+    argp = argparse.ArgumentParser("ms2-hash_gen", description="Создание контрольной суммы для файла")
+    argp.epilog = "Написано на Python"
     argp.add_argument("files", nargs="+", help="пути к файлам")
     argp.add_argument("-b", "--bar", action="store_true", help="показывать прогрессбар (нужен модуль progressbar2)")
     argp.add_argument("-f", "--force", action="store_true", help="перезаписывать существующие хеши")
@@ -113,7 +114,8 @@ def hash_gen(args: argparse.Namespace = None):
 
 def hash_check(args: argparse.Namespace = None):
   if args is None:
-    argp = argparse.ArgumentParser("ms2-hash_check", description="проверка размера и контрольной суммы файла")
+    argp = argparse.ArgumentParser("ms2-hash_check", description="Проверка размера и контрольной суммы файла")
+    argp.epilog = "Написано на Python"
     argp.add_argument("files", nargs="+", help="пути к файлам")
     argp.add_argument("-b", "--bar", action="store_true", help="показывать прогрессбар (нужен модуль progressbar2)")
     args = argp.parse_args()

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

@@ -7,6 +7,7 @@ import os
 import sys
 import time
 from .core import ms
+from contextlib import ExitStack
 from functools import wraps
 from typing import *
 from warnings import warn
@@ -167,12 +168,12 @@ async def async_download_file(url: str, path: str, *, cb_end=return_None, cb_pro
   """Асинхронная функция для скачивания файла | `aiohttp`"""
   kw.setdefault("method", "GET")
   kw["url"] = url
-  async with async_request(**kw) as resp:  # type: ignore
-    if callable(getattr(path, "write", None)):
-      f: IO[bytes] = path
-    else:
-      f = open(path, "wb")
-    with f:
+  with ExitStack() as stack:
+    async with async_request(**kw) as resp:  # type: ignore
+      if callable(getattr(path, "write", None)):
+        f: IO[bytes] = path
+      else:
+        f = stack.enter_context(open(path, "wb"))
       size = 0
       await cb_start(f, resp, size)
       try:
@@ -311,25 +312,25 @@ def sync_download_file(url: str, path: str, *, cb_end=return_None, cb_progress=r
   kw.setdefault("method", "GET")
   kw["stream"] = True
   kw["url"] = url
-  with sync_request(**kw) as resp:
+  with ExitStack() as stack:
+    resp = stack.enter_context(sync_request(**kw))
     if callable(getattr(path, "write", None)):
       f: IO[bytes] = path
     else:
-      f = open(path, "wb")
-    with f:
-      size = 0
-      cb_start(f, resp, size)
-      try:
-        for chunk in resp.iter_content(chunk_size):
-          size += f.write(chunk)
-          cb_progress(f, resp, size)
-      except:
-        f.close()
-        if delete_on_error:
-          if os.path.isfile(path):
-            os.remove(path)
-        raise
-      cb_end(f, resp, size)
+      f = stack.enter_context(open(path, "wb"))
+    size = 0
+    cb_start(f, resp, size)
+    try:
+      for chunk in resp.iter_content(chunk_size):
+        size += f.write(chunk)
+        cb_progress(f, resp, size)
+    except:
+      f.close()
+      if delete_on_error:
+        if os.path.isfile(path):
+          os.remove(path)
+      raise
+    cb_end(f, resp, size)
   return size
 
 

mainshortcuts2-2.7.2/src/MainShortcuts2/_module_info.py

@@ -1,2 +0,0 @@
-name = "MainShortcuts2"
-version = "2.6.5"