MainShortcuts2 2.7.2__tar.gz → 2.7.4__tar.gz

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

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

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

@@ -1,5 +1,5 @@
 [tool.poetry]
-version = "2.7.2"
+version = "2.7.4"
 name = "MainShortcuts2"
 description = "Сокращение и улучшение функций + консольные утилиты"
 authors = ["MainPlay TG <xbox.roman6666666666@gmail.com>"]
@@ -13,6 +13,7 @@ packages = [
 ms2-app = "MainShortcuts2.ms2app:main"
 ms2-hash_check = "MainShortcuts2.ms2hash:hash_check"
 ms2-hash_gen = "MainShortcuts2.ms2hash:hash_gen"
+ms2-hash_java = "MainShortcuts2.ms2hash:run_java_ext"
 ms2-import_example = "MainShortcuts2.__main__:import_example"
 ms2-ln = "MainShortcuts2.__main__:ln"
 ms2-which_real = "MainShortcuts2.__main__:which_real"

mainshortcuts2-2.7.4/src/MainShortcuts2/_module_info.py

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

{mainshortcuts2-2.7.2 → mainshortcuts2-2.7.4}/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 → mainshortcuts2-2.7.4}/src/MainShortcuts2/core_config.py

@@ -43,11 +43,7 @@ class CoreConfig(cfg):
 
   def _cu_thread(self):
     try:
-      import requests
-      url = "https://github.com/MainPlay-TG/MainShortcuts2.py/raw/refs/heads/master/src/MainShortcuts2/_module_info.py"
-      with requests.get(url) as resp:
-        resp.raise_for_status()
-        version = self._parse_version(resp.text)
+      version = self._get_github_version()
       if version != _module_info.version:
         mini_log("New MainShortcuts2 version available: %s", version)
         mini_log("Please update by running:")
@@ -57,13 +53,12 @@ class CoreConfig(cfg):
     except:
       return
 
-  def _parse_version(self, code) -> str:
-    import ast
-    tree = ast.parse(code)
-    for node in ast.walk(tree):
-      if isinstance(node, ast.Assign):
-        for target in node.targets:
-          if isinstance(target, ast.Name):
-            if target.id == "version":
-              return ast.literal_eval(node.value)
+  def _get_github_version(self) -> str:
+    from MainShortcuts2.api.github import Client
+    gh = Client.from_env(True)
+    rel = gh.releases.get_latest("MainPlay-TG", "MainShortcuts2.py")
+    for asset in rel.assets:
+      if asset.name == "changelog.json":
+        with gh.http.get(asset.browser_download_url) as resp:
+          return resp.json()["version"]
     return _module_info.version

mainshortcuts2-2.7.2/src/MainShortcuts2/ex/aiohttp_ex/web.py → mainshortcuts2-2.7.4/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.4/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.4/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.4/src/MainShortcuts2/java_ext/__init__.py

@@ -0,0 +1,339 @@
+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):
+    """Итерация версий из кэша"""
+    info_list: list[InfoDict] = []
+    for file in self.dir.iterdir():
+      if file.suffix == ".json" and file.is_file():
+        info_list.append(InfoDict(file.read_json()))
+    info_list.sort(key=lambda i: i.version_id)
+    for info in info_list[::-1]:
+      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):
+    """Скачать последнюю версию (если не скачана)"""
+    results: list[JavaExtVersion] = []
+    for ver in self.iter_online_versions(count):
+      ver.info  # Скачать файл JSON
+      if download_jar:
+        ver.jar_path  # Скачать файл JAR
+      results.append(ver)
+    return results
+
+
+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)