MainShortcuts2 2.7.3__tar.gz → 2.8.0__tar.gz

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

@@ -1,15 +1,11 @@
 Metadata-Version: 2.4
 Name: MainShortcuts2
-Version: 2.7.3
+Version: 2.8.0
 Summary: Сокращение и улучшение функций + консольные утилиты
 Author: MainPlay TG
 Author-email: xbox.roman6666666666@gmail.com
-Requires-Python: >=3.6,<4.0
+Requires-Python: >=3.10,<4.0
 Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.6
-Classifier: Programming Language :: Python :: 3.7
-Classifier: Programming Language :: Python :: 3.8
-Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12

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

@@ -1,5 +1,5 @@
 [tool.poetry]
-version = "2.7.3"
+version = "2.8.0"
 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"
@@ -21,7 +22,7 @@ nginx-reload = "MainShortcuts2.__main__:nginx_reload"
 nginx-restart = "MainShortcuts2.__main__:nginx_restart"
 
 [tool.poetry.dependencies]
-python = "^3.6"
+python = "^3.10"
 
 [build-system]
 build-backend = "poetry.core.masonry.api"

{mainshortcuts2-2.7.3 → mainshortcuts2-2.8.0}/src/MainShortcuts2/_module_info.py

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

mainshortcuts2-2.8.0/src/MainShortcuts2/_ms2dat_auto.py

@@ -0,0 +1,28 @@
+import typing
+from . import ms2dat1
+from io import BytesIO
+# Использовать последнюю версию для сохранения
+dump = ms2dat1.dump
+dumps = ms2dat1.dumps
+write_file = ms2dat1.write_file
+# Авто определение версии при загрузке
+
+
+def load(file: typing.BinaryIO, **kw):
+  """Загрузить объект из IO"""
+  header = ms2dat1.FileHeader.from_file(file)
+  if header.version == 1:
+    return ms2dat1.load(file, _h=header, **kw)
+  raise Exception(f"Unsupported version {header.version}")
+
+
+def loads(data: bytes, **kw):
+  """Загрузить объект из `bytes`"""
+  with BytesIO(data) as f:
+    return load(f, **kw)
+
+
+def read_file(path, **kw):
+  """Загрузить объект из локального файла"""
+  with open(path, "rb") as f:
+    return load(f, **kw)

{mainshortcuts2-2.7.3 → mainshortcuts2-2.8.0}/src/MainShortcuts2/core.py

@@ -192,29 +192,40 @@ class MS2:
       return cls(**kw)
 
   @property
-  def now(self) -> float:
+  def now(self):
     """Текущее локальное время (`timestamp`)"""
     return time()
 
   @property
-  def now_dt(self) -> datetime:
+  def now_dt(self):
     """Текущее локальное время (`datetime`)"""
     return datetime.fromtimestamp(time())
 
   @property
-  def utcnow(self) -> float:
+  def utcnow(self):
     """Текущее время по UTC (`timestamp`)"""
     return self.utcnow_dt.timestamp()
   if timezone is None:
     @property
-    def utcnow_dt(self) -> datetime:
+    def utcnow_dt(self):
       """Текущее время по UTC (`datetime`)"""
       return datetime.utcfromtimestamp(time())
   else:
     @property
-    def utcnow_dt(self) -> datetime:
+    def utcnow_dt(self):
       """Текущее время по UTC (`datetime`)"""
       return datetime.fromtimestamp(time(), timezone.utc)
 
+  @cached_property
+  def ms2dat_v1(self):
+    from . import ms2dat1
+    return ms2dat1
+
+  @cached_property
+  def ms2dat(self):
+    """Авто выбор при загрузке, последняя версия при сохранении"""
+    from . import _ms2dat_auto
+    return _ms2dat_auto
+
 
 ms = MS2()

{mainshortcuts2-2.7.3 → mainshortcuts2-2.8.0}/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.3 → mainshortcuts2-2.8.0}/src/MainShortcuts2/ex/aiohttp_ex/web/__init__.py

@@ -1,29 +1,41 @@
+import base64
+import json
+import os
 import typing
+import uuid
 import warnings
 from aiohttp import BasicAuth, hdrs, web
 from aiohttp.typedefs import Handler
 from aiohttp.web import FileResponse, Request, Response, StreamResponse
+from datetime import datetime, timedelta
 from logging import DEBUG
 from MainShortcuts2 import ms
-from pathlib import Path
+from pathlib import Path, PurePath
 warnings.filterwarnings("ignore", "Inheritance class .* from web.Application is discouraged", DeprecationWarning)
+PATH_TYPES = os.PathLike, PurePath
 
 
 def wrap_handler(app: "Application", handler: Handler):
+  """Обернуть обработчик запросов"""
   async def wrapper(req: Request) -> StreamResponse | typing.Any:
+    """Обёртка с поддержкой ответов `int`, `ApiResult` и `os.PathLike`"""
     try:
       resp = await handler(req)
-      if isinstance(resp, int):
+      if isinstance(resp, int):  # Код статуса
         resp = Response(status=resp)
-      elif isinstance(resp, Path):
+      elif isinstance(resp, ApiResult):  # Результат API обработчика
+        resp = resp.make_resp(req.content_type)
+      elif isinstance(resp, PATH_TYPES):  # Локальный файл
         resp = FileResponse(resp)
+    except ApiResult as exc:  # Результат API исключения
+      resp = exc.make_resp(req.content_type)
     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"]
+        remote += " (X-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
@@ -97,7 +109,84 @@ def auth_basic(header=hdrs.AUTHORIZATION, filter: typing.Callable[[BasicAuth], b
           return Response(status=400, headers=basic_unauthorized_headers)  # Неправильный заголовок
         if filter(auth):
           return await func(req, auth)  # Одобрено
-        return Response(status=403)  # Запрещено
+        return Response(status=403, headers=basic_unauthorized_headers)  # Запрещено
       return Response(status=401, headers=basic_unauthorized_headers)  # Заголовок отсутствует
     return wrapper
   return deco
+
+
+class ApiResult(BaseException):
+  """Результат для вызова API. Может быть вызван как исключение"""
+
+  def __init__(self, result=None, status=200, **base_dict):
+    super().__init__("This exception should be handled as a response to the request")
+    self.base_dict = base_dict
+    self.result = result
+    self.status = status
+
+  def to_dict(self):
+    r = self.base_dict.copy()
+    r["ok"] = self.status < 400
+    if self.result is not None:
+      r["result"] = self.result
+    return r
+
+  def _serialize_ms2dat(self, obj, other_serializer=None):
+    """Для форматов, не поддерживающих `bytes`, `datetime`, `timedelta` и `UUID`"""
+    if isinstance(obj, bytes):  # Base64
+      return base64.b64encode(obj).decode("utf-8")
+    if isinstance(obj, datetime):  # ISO
+      return obj.isoformat()
+    if isinstance(obj, timedelta):  # секунды
+      return obj.total_seconds()
+    if isinstance(obj, uuid.UUID):  # HEX
+      return str(obj)
+    if other_serializer is None:  # Другого сериализатора нет
+      raise TypeError(f"Object of type {obj.__class__.__name__} is not serializable")
+    return other_serializer(obj)
+
+  def _to_json(self):
+    # Минимальный размер за счёт
+    # коротких разделителей
+    # и отсутвия \uXXXX кодов
+    return "application/json", json.dumps(
+        self.to_dict(),
+        default=self._serialize_ms2dat,
+        ensure_ascii=False,
+        separators=(",", ":"),
+    )
+
+  def _to_yaml(self):
+    import yaml
+    return "application/yaml", yaml.safe_dump(self.to_dict())
+
+  def _to_xml(self):
+    raise NotImplementedError()
+
+  def _to_ms2dat1(self) -> tuple[str, bytes]:
+    from MainShortcuts2 import ms2dat1
+    return "application/x-ms2dat1", ms2dat1.dumps(self.to_dict())
+
+  def make_resp(self, content_type=None):
+    """Создать ответ в указаном формате, по умолчанию JSON"""
+    try:
+      if content_type == "application/x-ms2dat1":
+        ctype, body = self._to_ms2dat1()
+      elif content_type == "application/yaml":
+        ctype, body = self._to_yaml()
+      else:  # Если запрошенный формат не поддерживается
+        ctype, body = self._to_json()
+    except ImportError:  # Если формат не поддерживается
+      ctype, body = self._to_json()  # JSON должен сработать
+    # Клиент должен проверять формат ответа, на случай если он не соответствует запрошенному
+    if isinstance(body, str):
+      return web.Response(status=self.status, text=body, content_type=ctype)
+    return web.Response(status=self.status, body=body, content_type=ctype)
+
+
+class ApiError(ApiResult):
+  """Ошибка API. Можно вызывать как исключение"""
+
+  def __init__(self, message: str, status=400, **base_dict):
+    base_dict["message"] = message
+    super().__init__(status=status, **base_dict)

{mainshortcuts2-2.7.3 → mainshortcuts2-2.8.0}/src/MainShortcuts2/java_ext/__init__.py

@@ -169,12 +169,15 @@ class JavaExtManager(ms.ObjectBase):
 
   def iter_offline_versions(self):
     """Итерация версий из кэша"""
+    info_list: list[InfoDict] = []
     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
+        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"""
@@ -212,10 +215,13 @@ class JavaExtManager(ms.ObjectBase):
 
   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):

mainshortcuts2-2.8.0/src/MainShortcuts2/ms2dat1.py

@@ -0,0 +1,549 @@
+import datetime
+import hashlib
+import math
+import secrets
+import struct
+import typing
+import uuid
+from io import BytesIO
+from MainShortcuts2.utils import int_size_unsigned
+HASH_NAMES = None, "sha256", "sha3-256", "sha512"
+HASH_SIZES = 0, 32, 32, 64
+MAGIC_HEAD = b"MS2D"
+SPECIAL_TYPES = None, False, True, float("-inf"), float("inf"), float("nan")
+
+
+def hash_data(hash_type: int, data: bytes):
+  """Хеширование данных"""
+  if hash_type == 0:
+    return b""
+  return hashlib.new(HASH_NAMES[hash_type], data).digest()
+
+
+def compress_data(compress_type: int, data: bytes):
+  """Сжатие данных, применяется только если результат меньше исходных данных"""
+  if compress_type == 1:
+    import zlib
+    result = zlib.compress(data)
+    if len(result) < len(data):
+      return 1, result
+  elif compress_type == 2:
+    import bz2
+    result = bz2.compress(data)
+    if len(result) < len(data):
+      return 2, result
+  elif compress_type == 3:
+    import lzma  # СУПЕР сжатие
+    result = lzma.compress(data, lzma.FORMAT_ALONE, preset=9 | lzma.PRESET_EXTREME)
+    if len(result) < len(data):
+      return 3, result
+  return 0, data
+
+
+def decompress_data(compress_type: int, data: bytes):
+  if compress_type == 0:
+    return data
+  if compress_type == 1:
+    import zlib
+    return zlib.decompress(data)
+  if compress_type == 2:
+    import bz2
+    return bz2.decompress(data)
+  if compress_type == 3:
+    import lzma
+    return lzma.decompress(data)
+  raise ValueError("Invalid compress type")
+
+
+class FileHeader:
+  """Подходит для всех версий"""
+
+  def __init__(self, version: int):
+    self.version = version
+
+  @classmethod
+  def from_file(cls, f: typing.IO[bytes]):
+    if f.read(4) != MAGIC_HEAD:
+      raise ValueError("Invalid file header")
+    return cls(f.read(1)[0])
+
+  def build(self):
+    return bytes([*MAGIC_HEAD, self.version])
+
+
+class UnknownType(typing.NamedTuple):
+  typename: str
+  body: bytes
+
+
+class Reader:
+  """v1"""
+
+  def __init__(self, ms2dat: "MS2Dat1", f: typing.IO[bytes]):
+    self.f = f
+    self.ms2dat = ms2dat
+    # MAGIC заголовок уже должен быть прочитан и проверен
+    # Флаги
+    flags = self._read1()
+    self.compress_type = flags >> 6  # 0b11000000 0-3
+    self.hash_type = flags >> 4 & 0b11  # 0b00110000 0-3
+    self.encrypted = flags >> 3 & 1  # 0b00001000 0-1
+    bodysize_size = flags & 0b111  # 0b00000111 0-7
+    # Пользовательские типы
+    self.custom_types: list[str] = []
+    for i in range(self._read1()):
+      self.custom_types.append(self._read(self._read1()).decode("utf-8"))
+    # Размер тела
+    self.body_size = int.from_bytes(self._read(bodysize_size), "big")
+
+  def _read(self, n: int):
+    buf = self.f.read(n)
+    if len(buf) != n:
+      raise ValueError(f"Expected {n} bytes, got {len(buf)}")
+    return buf
+
+  def _read1(self):
+    return self._read(1)[0]
+
+  def read_body(self, allow_unknown=False, verify=True) -> typing.Optional[typing.Any]:
+    raw = self._read(self.body_size)
+    if self.encrypted:
+      raw = self.ms2dat.decrypt_body(raw)
+    body = decompress_data(self.compress_type, raw)
+    if verify and self.hash_type:
+      reald = hash_data(self.hash_type, body)
+      saved = self._read(HASH_SIZES[self.hash_type])
+      if reald != saved:
+        raise ValueError("The file is corrupted")
+    with BytesIO(body) as buf:
+      # Чтение словаря
+      d = []
+      for i in range(int.from_bytes(buf.read(3), "big")):
+        d.append(self.decode_obj(buf, d, allow_unknown))
+      # Чтение тела
+      return self.decode_obj(buf, d, allow_unknown)
+
+  def decode_obj(self, buf: typing.IO[bytes], d: list, allow_unknown=False):
+    head = buf.read(1)[0]
+    typeid = head >> 4
+    sizesize = head & 0b1111
+    size = int.from_bytes(buf.read(sizesize), "big")
+    if typeid == 0:  # Специальный тип
+      return SPECIAL_TYPES[size]
+    if typeid == 6:  # dict
+      result = {}
+      for i in range(size):
+        k = self.decode_obj(buf, d, allow_unknown)
+        result[k] = self.decode_obj(buf, d, allow_unknown)
+      return result
+    if typeid in (7, 8, 9):  # list, tuple, set
+      result = [self.decode_obj(buf, d, allow_unknown) for i in range(size)]
+      if typeid == 8:
+        return tuple(result)
+      if typeid == 9:
+        return set(result)
+      return result
+    if typeid == 12:  # datetime + timezone
+      dt: datetime.datetime = self.decode_obj(buf, d)
+      td: datetime.timedelta = self.decode_obj(buf, d)
+      return dt.replace(tzinfo=datetime.timezone(td))
+    if typeid == 14:  # Ссылка на словарь
+      return d[size]
+    if typeid == 15:  # Пользовательский тип
+      ctypename = self.custom_types[buf.read(1)[0]]
+      ctype = self.ms2dat.custom_types.get(ctypename)
+      cbody = buf.read(size)
+      if ctype is None:
+        if allow_unknown:
+          return UnknownType(ctypename, cbody)
+        raise ValueError(f"Unknown custom type: {ctypename}")
+      return ctype.decode_obj(self, cbody, d)
+    body = buf.read(size)
+    if typeid == 1:  # int
+      return int.from_bytes(body, "big")
+    if typeid == 2:  # int
+      return -int.from_bytes(body, "big")
+    if typeid == 3:  # float
+      return struct.unpack("d", body)[0]
+    if typeid == 4:  # bytes
+      return body
+    if typeid == 5:  # str
+      return body.decode("utf-8")
+    if typeid == 10:  # datetime
+      return datetime.datetime.fromtimestamp(struct.unpack("d", body)[0])
+    if typeid == 11:  # timedelta
+      return datetime.timedelta(seconds=struct.unpack("d", body)[0])
+    if typeid == 13:  # UUID
+      return uuid.UUID(bytes=body)
+    raise Exception("Эта ошибка никогда не вылезет")
+
+
+class Writer:
+  """v1"""
+
+  def __init__(self, ms2dat: "MS2Dat1", f: typing.IO[bytes], obj):
+    self.f = f
+    self.ms2dat = ms2dat
+    self.obj = obj
+    self.obj_dict: list[bytes] = []
+    self.used_ctypes: list[CustomType] = []
+
+  def _write(self, data: bytes):
+    return self.f.write(data)
+
+  def _write1(self, byte: int):
+    return self._write(bytes([byte]))
+
+  def _addget_dict(self, typeid: int, size: int, body: bytes):
+    if typeid == 14:
+      # Если дана ссылка на словарь, то вернуть ее
+      return typeid, size, b""
+    # В словаре только уже собранные объекты
+    buf = bytes(self._build_obj(typeid, size, body))
+    if buf in self.obj_dict:
+      # Объект уже есть в словаре
+      return 14, self.obj_dict.index(buf), b""
+    if len(self.obj_dict) >= 0xffffff:
+      # Словарь переполнен
+      return typeid, size, body
+    # Добавить объект в словарь
+    self.obj_dict.append(buf)
+    return 14, len(self.obj_dict) - 1, b""
+
+  def _encode_obj(self, data, sort_keys: bool, use_dict: bool) -> tuple[int, int, bytes | bytearray]:
+    for m, n in enumerate(SPECIAL_TYPES):
+      if m < 3:  # None, bool
+        if data is n:
+          return 0, m, b""
+      else:  # float
+        if data == n:
+          return 0, m, b""
+    if isinstance(data, int):
+      typeid = 1
+      if data < 0:
+        data = -data
+        typeid = 2
+      size = int_size_unsigned(data)
+      return typeid, size, data.to_bytes(size, "big")
+    if isinstance(data, float):
+      if math.isnan(data):
+        return 0, 5, b""
+      result = struct.pack("d", data)
+      return 3, len(result), result
+    if isinstance(data, bytes):
+      if use_dict:
+        return self._addget_dict(4, len(data), data)
+      return 4, len(data), data
+    if isinstance(data, str):
+      result = data.encode("utf-8")
+      if use_dict:
+        return self._addget_dict(5, len(result), result)
+      return 5, len(result), result
+    if isinstance(data, dict):
+      items = list(data.items())
+      if sort_keys:
+        try:
+          items.sort()
+        except Exception:
+          pass
+      buf = bytearray()
+      for k, v in items:
+        buf.extend(self.encode_obj(k, sort_keys, use_dict))
+        buf.extend(self.encode_obj(v, sort_keys, use_dict))
+      return 6, len(items), buf
+    if isinstance(data, (list, tuple, set)) and not isinstance(data, UnknownType):
+      typeid = 7
+      if isinstance(data, tuple):
+        typeid = 8
+      elif isinstance(data, set):
+        typeid = 9
+        if sort_keys:
+          try:
+            data = sorted(data)
+          except Exception:
+            pass
+      buf = bytearray()
+      for v in data:
+        buf.extend(self.encode_obj(v, sort_keys, use_dict))
+      return typeid, len(data), buf
+    if isinstance(data, datetime.datetime):
+      if data.tzinfo is None:
+        result = struct.pack("d", data.timestamp())
+        return 10, len(result), result
+      td = data.tzinfo.utcoffset(data)
+      if td is None:
+        return self._encode_obj(data.replace(tzinfo=None))
+      buf = bytearray()
+      buf.extend(self.encode_obj(data.replace(tzinfo=None)))
+      buf.extend(self.encode_obj(td))
+      return 12, len(buf), buf
+    if isinstance(data, datetime.timedelta):
+      result = struct.pack("d", data.total_seconds())
+      return 11, len(result), result
+    if isinstance(data, uuid.UUID):
+      result = data.bytes
+      return 13, len(result), result
+    # Пользовательский тип
+    if isinstance(data, UnknownType):
+      handler = UnknownTypeHandler(self.ms2dat, data.typename)
+    else:
+      handler = self.ms2dat.find_handler(type(data))
+    if handler is None:
+      raise Exception(f"Unknown type: {type(data)}")
+    if handler in self.used_ctypes:
+      ctypeid = self.used_ctypes.index(handler)
+    else:
+      ctypeid = len(self.used_ctypes)
+      self.used_ctypes.append(handler)
+    body = handler.encode_obj(data, sort_keys)
+    result = 15, len(body), bytes([ctypeid]) + body
+    if use_dict and getattr(handler, "allow_dict", False):
+      return self._addget_dict(*result)
+    return result
+
+  def _build_obj(self, typeid: int, size: int, body: bytes):
+    sizesize = int_size_unsigned(size)
+    if sizesize > 0b1111:
+      raise Exception("Too big size")
+    buf = bytearray()
+    buf.append((typeid << 4) | sizesize)
+    buf.extend(size.to_bytes(sizesize, "big"))
+    buf.extend(body)
+    return buf
+
+  def encode_obj(self, data, sort_keys=False, use_dict=True):
+    typeid, size, body = self._encode_obj(data, sort_keys, use_dict)
+    return self._build_obj(typeid, size, body)
+
+  def write_all(self, compress_type=0, encrypted=0, hash_type=1, sort_keys=False, use_dict=True):
+    self._write(MAGIC_HEAD)
+    self._write1(1)
+    # Сохранение объекта
+    raw_obj = self.encode_obj(self.obj, sort_keys, use_dict)
+    # Тело
+    raw_body = bytearray()
+    raw_body.extend(len(self.obj_dict).to_bytes(3, "big"))
+    for i in self.obj_dict:
+      raw_body.extend(i)
+    raw_body.extend(raw_obj)
+    # Сжатие
+    compress_type, body = compress_data(compress_type, raw_body)
+    # Шифрование
+    encrypted = 1 if encrypted else 0  # Если дадут bool
+    if encrypted:
+      body = self.ms2dat.encrypt_body(body)
+    size = len(body)
+    sizesize = int_size_unsigned(size)
+    if sizesize > 0b111:
+      raise Exception("Too big body")
+    # Запись
+    # Флаги
+    self._write1((compress_type << 6) | (hash_type << 4) | (encrypted << 3) | sizesize)
+    # Пользовательские типы
+    self._write1(len(self.used_ctypes))
+    for i in self.used_ctypes:
+      name = i.typename.encode("utf-8")
+      self._write1(len(name))
+      self._write(name)
+    # Тело
+    self._write(size.to_bytes(sizesize, "big"))
+    self._write(body)
+    # Хеш
+    self._write(hash_data(hash_type, body))
+
+
+class CustomType:
+  allow_dict: bool
+  handled_types: set[type]
+  typename: str
+
+  def __init__(self, ms2dat: "MS2Dat1"):
+    self.ms2dat = ms2dat
+
+  def __eq__(self, other):
+    if isinstance(other, CustomType):
+      return (self.ms2dat is other.ms2dat) and (self.typename == other.typename)
+
+  def encode_obj(self, data: object, sort_keys=False) -> bytes:
+    raise NotImplementedError()
+
+  def decode_obj(self, reader: Reader, body: bytes, d: list) -> object:
+    raise NotImplementedError()
+
+
+class UnknownTypeHandler(CustomType):
+  def __init__(self, ms2dat: "MS2Dat1", typename: str):
+    super().__init__(ms2dat)
+    self.allow_dict = True
+    self.handled_types = set()
+    self.typename = typename
+
+  def encode_obj(self, data: UnknownType, sort_keys=False):
+    return data.body
+
+
+class MS2Dat1:
+  VERSION = 1
+  COMPRESS_NONE = 0
+  COMPRESS_ZLIB = 1
+  COMPRESS_BZ2 = 2
+  COMPRESS_LZMA = 3
+  HASH_NONE = 0
+  HASH_SHA256 = 1
+  HASH_SHA3_256 = 2
+  HASH_SHA512 = 3
+
+  def __init__(self):
+    self._dump_kw = {}
+    self._load_kw = {}
+    self.custom_types: dict[str, CustomType] = {}
+
+  def set_allow_unknown(self, value: bool):
+    """Разрешить загрузку неизвестных пользовательских типов? Такие объекты будут загружены в виде `UnknownType`"""
+    self._load_kw["allow_unknown"] = bool(value)
+
+  def set_compress(self, value: int):
+    """Уровень сжатия (см. константы класса)"""
+    self._dump_kw["compress_type"] = value
+
+  def set_encrypt(self, value: bool):
+    """Включить шифрование? Шифрование должно быть реализовано подклассом"""
+    self._dump_kw["encrypted"] = 1 if value else 0
+
+  def set_hash(self, value: int):
+    """Алгоритм хеширования (см. константы класса)"""
+    self._dump_kw["hash_type"] = value
+
+  def set_sort_keys(self, value: bool):
+    """Сортировать ключи `dict` и `set`?"""
+    self._dump_kw["sort_keys"] = bool(value)
+
+  def set_use_dict(self, value: bool):
+    """Использовать словарь? Словарь уменьшает объём данных при наличии одинаковых объектов"""
+    self._dump_kw["use_dict"] = bool(value)
+
+  def set_verify(self, value: bool):
+    """Проверять хеш данных (если есть) при загрузке?"""
+    self._load_kw["verify"] = bool(value)
+
+  def profile_fast(self):
+    """Отключение сжатия, хеширования, сортировки, и словаря для быстрейшей работы"""
+    self.set_compress(self.COMPRESS_NONE)
+    self.set_hash(self.HASH_NONE)
+    self.set_sort_keys(False)
+    self.set_use_dict(False)
+
+  def profile_fastest(self):
+    """Быстрый профиль + отключение проверки данных"""
+    self.profile_fast()
+    self.set_verify(False)
+
+  def profile_safe(self):
+    """Лучшее хеширование"""
+    self.set_hash(self.HASH_SHA512)
+    self.set_verify(True)
+
+  def profile_smaller_size(self):
+    """Максимальное сжатие, но медленная работа"""
+    self.set_compress(self.COMPRESS_LZMA)
+
+  def profile_minimum_size(self):
+    """Максимальное сжатие без хеширования и с включенным словарём"""
+    self.set_compress(self.COMPRESS_LZMA)
+    self.set_hash(self.HASH_NONE)
+    self.set_use_dict(True)
+
+  def reg_custom_type(self, obj: CustomType, replace=False):
+    """Зарегистрировать пользовательский тип"""
+    if (obj.typename in self.custom_types) and not replace:
+      raise Exception(f"Type {obj.typename} already registered")
+    self.custom_types[obj.typename] = obj
+
+  def reg_custom_type_deco(self, replace=False):
+    """Регистрация пользовательского типа в виде декоратора над классом"""
+    def deco(cls: type[CustomType]):
+      self.reg_custom_type(cls(self), replace)
+      return cls
+    return deco
+
+  def find_handler(self, cls: type) -> CustomType | None:
+    """Найти обработчик для типа данных (только пользовательские типы)"""
+    for i in self.custom_types.values():
+      if cls in i.handled_types:
+        return i
+
+  def decrypt_body(self, data: bytes) -> bytes:
+    """Расшифровать тело. Должен быть переопределен для работы"""
+    raise NotImplementedError("This class cannot work with encryption")
+
+  def encrypt_body(self, data: bytes) -> bytes:
+    """Зашифровать тело. Должен быть переопределен для работы"""
+    raise NotImplementedError("This class cannot work with encryption")
+
+  def dump(self, obj, file: typing.BinaryIO, **kw):
+    """Сохранить объект в IO"""
+    writer = Writer(self, file, obj)
+    for k, v in self._dump_kw.items():
+      kw.setdefault(k, v)
+    writer.write_all(**kw)
+
+  def dumps(self, obj, **kw):
+    """Сохранить объект в `bytes`"""
+    with BytesIO() as f:
+      self.dump(obj, f, **kw)
+      return f.getvalue()
+
+  def load(self, file: typing.BinaryIO, *, _h: FileHeader = None, **kw):
+    """Загрузить объект из IO"""
+    if _h is None:
+      _h = FileHeader.from_file(file)
+    if _h.version != self.VERSION:
+      raise Exception(f"Unsupported version {_h.version}")
+    reader = Reader(self, file)
+    for k, v in self._load_kw.items():
+      kw.setdefault(k, v)
+    return reader.read_body(**kw)
+
+  def loads(self, data: bytes, **kw):
+    """Загрузить объект из `bytes`"""
+    with BytesIO(data) as f:
+      return self.load(f, **kw)
+
+  def read_file(self, path, **kw):
+    """Загрузить объект из локального файла"""
+    with open(path, "rb") as f:
+      return self.load(f, **kw)
+
+  def write_file(self, obj, path, **kw):
+    """Сохранить объект в локальный файл"""
+    with open(path, "wb") as f:
+      self.dump(obj, f, **kw)
+
+
+class MS2Dat1EncryptExample(MS2Dat1):
+  """Пример реализации шифрования через XOR. Ненадёжное шифрование!"""
+
+  def __init__(self, key: bytes):
+    super().__init__()
+    self.encrypt_key = key
+
+  @classmethod
+  def create_with_random_key(cls, keysize=32):
+    return cls(secrets.token_bytes(keysize))
+
+  def decrypt_body(self, data: bytes):
+    """Зашифровать/расшифровать данные, используя XOR-шифрование"""
+    key = self.encrypt_key
+    lkey = len(key)
+    return bytes([b ^ key[i % lkey] for i, b in enumerate(data)])
+  encrypt_body = decrypt_body
+
+
+inst = MS2Dat1()
+"""Настройки по умолчанию"""
+dump = inst.dump
+dumps = inst.dumps
+load = inst.load
+loads = inst.loads
+read_file = inst.read_file
+write_file = inst.write_file

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

@@ -142,3 +142,19 @@ def hash_check(args: argparse.Namespace = None):
     else:
       print("Ошибка: файл " + shlex.quote(file) + " изменён")
     completed.append(file)
+
+
+def run_java_ext(argv: list[str] = None):
+  if argv is None:
+    argv = sys.argv[1:]
+  from MainShortcuts2 import java_ext
+  mgr = java_ext.JavaExtManager("MainPlay-TG", "MS2Hash.java")
+  ver = None
+  for i in mgr.iter_all_versions(1):
+    ver = i
+    break
+  if ver is None:
+    ms.utils.mini_log("Ошибка: не удалось найти версию MS2Hash. Проверьте соединение с GitHub")
+    sys.exit(1)
+  p = ver.run(argv, check=False)
+  sys.exit(p.returncode)

{mainshortcuts2-2.7.3 → mainshortcuts2-2.8.0}/src/MainShortcuts2/types.py

@@ -1,4 +1,5 @@
 """Различные объекты и исключения"""
+from typing import NamedTuple
 
 
 class Base:
@@ -468,6 +469,97 @@ class ThreadsFlag(BoolFlag):
       self.value.remove(t)
 
 
+class BitsTuple(NamedTuple):
+  b0: int
+  b1: int
+  b2: int
+  b3: int
+  b4: int
+  b5: int
+  b6: int
+  b7: int
+
+  def __int__(self):
+    return self.to_byte()
+
+  def __index__(self):
+    return self.to_byte()
+  # Возможны баги
+
+  def __and__(self, other):
+    return int(self) & other
+
+  def __or__(self, other):
+    return int(self) | other
+
+  def __xor__(self, other):
+    return int(self) ^ other
+
+  def __lshift__(self, other):
+    return int(self) << other
+
+  def __rshift__(self, other):
+    return int(self) >> other
+
+  def __invert__(self):
+    return (~int(self)) & 0xFF
+
+  def __rand__(self, other):
+    return other & int(self)
+
+  def __ror__(self, other):
+    return other | int(self)
+
+  def __rxor__(self, other):
+    return other ^ int(self)
+
+  def __rlshift__(self, other):
+    return other << int(self)
+
+  def __rrshift__(self, other):
+    return other >> int(self)
+  # ---
+
+  @classmethod
+  def from_byte(cls, b: int):
+    """Разбить **один** байт на биты"""
+    return cls(*[(b >> i) & 1 for i in range(7, -1, -1)])
+
+  @classmethod
+  def from_bytes_iter(cls, b: bytes):
+    """Разбить **несколько** байт на группы битов (итерация)"""
+    return map(cls.from_byte, b)
+
+  @classmethod
+  def from_bytes(cls, b: bytes):
+    """Разбить **несколько** байт на группы битов"""
+    return list(cls.from_bytes_iter(b))
+
+  def to_byte(self):
+    """Соединить биты в байт"""
+    b = 0
+    for i in self:
+      b = (b << 1) | i
+    return b
+
+  def replace(self, *args: bool | int, **kw: bool | int):
+    for n, bit in enumerate(args):
+      kw[f"b{n}"] = bit
+    fields = set(self._fields)
+    for k in list(kw):
+      if k not in fields:
+        raise ValueError(f"Invalid field: {k}, must be one of {sorted(fields)}")
+      kw[k] = 1 if kw[k] else 0
+    return self._replace(**kw)
+
+  def to_bool_list(self):
+    return list(map(bool, self))
+
+  @classmethod
+  def from_bool_list(cls, l):
+    return cls(*l)
+
+
 COLORS = _COLORS()
 Error401 = AccessDeniedError
 Error403 = AccessDeniedError

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

@@ -1102,3 +1102,109 @@ def guess_checksum_alg(digest_len: int):
     if digest_len == v:
       result.add(k)
   return result
+
+
+def int_size_unsigned(n: int):
+  """Минимальное количество байт для неотрицательного `int`"""
+  if n == 0:
+    return 1
+  return (n.bit_length() + 7) // 8
+
+
+def int_size_signed(n: int) -> int:
+  """Минимальное количество байт для `int` с поддержкой отрицательных"""
+  if n == 0:
+    return 1
+  return (n.bit_length() + 8) // 8
+
+
+def int2bytes(n: int, byteorder='big', signed=False) -> bytes:
+  """Конвертировать `int` в `bytes` минимального размера"""
+  f = int_size_signed if signed else int_size_unsigned
+  return n.to_bytes(f(n), byteorder=byteorder, signed=signed)
+
+
+class SyncSignal(list):
+  def __init__(self, ignore_errors=False):
+    super().__init__()
+    self.ignore_errors = bool(ignore_errors)
+
+  def send(self, *args, **kw):
+    """Отправить сигнал всем подписчикам"""
+    e = not self.ignore_errors
+    for func in list(self):
+      try:
+        func(*args, **kw)
+      except Exception:
+        if e:
+          raise
+
+
+class AsyncSignal(SyncSignal):
+  async def send(self, *args, **kw):
+    e = not self.ignore_errors
+    for func in list(self):
+      try:
+        await func(*args, **kw)
+      except Exception:
+        if e:
+          raise
+
+
+class Filter:
+  # Спасибо Pyrogram за идею
+  def __call__(self, *a, **b):
+    raise NotImplementedError
+
+  def __invert__(self):
+    return _InvertedFilter(self)
+
+  def __and__(self, other):
+    return _AndFilter(self, other)
+
+  def __or__(self, other):
+    return _OrFilter(self, other)
+
+
+class _InvertedFilter(Filter):
+  def __init__(self, f1: Filter):
+    self.f1 = f1
+
+  def __call__(self, *a, **b):
+    return not self.f1(*a, **b)
+
+
+class _AndFilter(Filter):
+  def __init__(self, f1: Filter, f2: Filter):
+    self.f1 = f1
+    self.f2 = f2
+
+  def __call__(self, *a, **b):
+    return self.f1(*a, **b) and self.f2(*a, **b)
+
+
+class _OrFilter(_AndFilter):
+  def __call__(self, *a, **b):
+    return self.f1(*a, **b) or self.f2(*a, **b)
+
+
+def create_filter(func: Callable, name: str = None, **d) -> Filter:
+  d["__call__"] = func
+  return type(name or func.__name__ or "CustomFilter", (Filter,), d)()
+
+
+filter_all = create_filter(return_True)
+filter_none = create_filter(return_False)
+
+
+class FilterGetAttr(Filter):
+  def __init__(self, name: str):
+    self.name = name
+
+  def __call__(self, obj):
+    return getattr(obj, self.name, False)
+
+
+class FilterGetItem(FilterGetAttr):
+  def __call__(self, obj):
+    return obj[self.name]