moonlib 1.0.0__py3-none-any.whl

main.py

@@ -0,0 +1,789 @@
+r"""
+ __  __                   _     _ _
+|  \/  | ___   ___  _ __ | |   (_) |__
+| |\/| |/ _ \ / _ \| '_ \| |   | | '_ \
+| |  | | (_) | (_) | | | | |___| | |_) |
+|_|  |_|\___/ \___/|_| |_|_____|_|_.__/
+
+   ____  __  __ _     ____  _             _
+  / __ \|  \/  | |   |  _ \| |_   _  __ _(_)_ __  ___
+ / / _` | |\/| | |   | |_) | | | | |/ _` | | '_ \/ __|
+| | (_| | |  | | |___|  __/| | |_| | (_| | | | | \__ \
+ \ \__,_|_|  |_|_____|_|   |_|\__,_|\__, |_|_| |_|___/
+  \____/                            |___/
+
+MoonLib - либа для удобной работы с java классами
+В основном для разрабов и тех кто хочет юзать мои плагины где эта либа нужна
+
+Код для своего плагина/либы можно брать, но только с указанием @MLPlugins в __author__
+Например: __author__ = "@username & @MLPlugins"
+При использовании либы в своих плагинах указывать авторство не нужно
+
+Также небольшой совет: проверять импорты
+Пример:
+try: from moonlib import Fortune, Browser
+except ImportError:
+    # Код для ошибки типа "Требуется установить либу MoonLib для работы плагина"
+    # Либо можно юзать fallback с ограниченными функциями
+
+Остальное можно почитать в документации: @MLDocumentation
+
+Gift dataclass я взял у @binbash_0, и немного отредактировал
+
+Если есть вопросы, пиши в лс тгк: @MLPlugins
+Но советую перед этим прочитать документацию чтобы избежать бана за глупый вопрос
+Бан будет за вопросы типа "А как импортировать", "Где тут ваще классы?", и т.п
+
+HookRouter класс взял из плагина AntiScam от @binbash_0
+
+Некоторый код писал на скорую руку, так что может быть говнокод
+"""
+
+__id__ = "moonlib"
+__name__ = "MoonLib"
+__description__ = "Мини либа для работы с java классами, и т.д\nВ основном для разрабов плагинов или для тех, кто хочет юзать мои плагины\nДокументация: @MLDocumentation"
+__author__ = "@MLPlugins & @MLDocumentation"
+__version__ = "1.0.1"
+__min_version__ = "12.5.1"
+__priority__ = 1
+
+MOONLIB_VERSION = __version__
+
+from base_plugin import BasePlugin, HookResult, HookStrategy
+from java import jclass
+from android_utils import (copy_to_clipboard, run_on_ui_thread)
+from android_utils import log as _log
+from client_utils import get_last_fragment, run_on_queue
+from dataclasses import dataclass
+from ui.settings import (
+        Header,
+        Switch,
+        Custom
+        )
+from ui.alert import AlertDialogBuilder
+from ui.bulletin import BulletinHelper
+from typing import (
+        Any,
+        Union,
+        List,
+        )
+from typing_extensions import deprecated
+from file_utils import (get_cache_dir, list_dir, get_plugins_dir)
+
+from decimal import(Decimal, getcontext)
+
+getcontext().prec = 2
+
+import threading
+import pathlib
+import subprocess
+import requests
+import functools
+import os
+import shutil
+import json
+
+def find_class(c: str) -> Any:
+    loader = jclass("org.telegram.messenger.ApplicationLoader")
+    ctx = loader.applicationContext
+    cl = loader.getClassLoader()
+    if (
+        loader and
+        ctx and
+        cl
+    ): return cl.loadClass(c)
+    return None
+
+@deprecated("useless")
+def _get_tg_classes() -> dict:
+    tg = {
+            "browser.Browser": jclass("org.telegram.messenger.browser.Browser"),
+            "ApplicationLoader": jclass("org.telegram.messenger.ApplicationLoader"),
+            "tgnet.TLRPC": jclass("org.telegram.tgnet.TLRPC"),
+            "AndroidUtilities": jclass("org.telegram.messenger.AndroidUtilities"),
+            "LocaleController": jclass("org.telegram.messenger.LocaleController")
+            }
+    return tg
+
+@deprecated("useless")
+def _get_java_classes() -> dict:
+    java = {
+            "util.ArrayList": jclass("java.util.ArrayList"),
+            "lang.String": jclass("java.lang.String"),
+            "security.SecureRandom": jclass("java.security.SecureRandom"),
+            "util.Locale": jclass("java.util.Locale")
+            }
+    return java
+
+@deprecated("useless")
+def _get_android_classes() -> dict:
+    android = {
+            "os.VibrationEffect": jclass("android.os.VibrationEffect"),
+            "os.Process": jclass("android.os.Process"),
+            "widget.TextView": jclass("android.widget.TextView"),
+            "widget.LinearLayout": jclass("android.widget.LinearLayout"),
+            "media.AudioManager": jclass("android.media.AudioManager"),
+            "media.ToneGenerator": jclass("android.media.ToneGenerator"),
+            "view.WindowManager": jclass("android.view.WindowManager"),
+            "webkit.WebView": jclass("android.webkit.WebView"),
+            "webkit.WebViewClient": jclass("android.webkit.WebViewClient")
+            }
+    return android
+
+@deprecated("useless")
+def _err(msg: str):
+    android = _get_android_classes()
+    process = android["os.Process"]
+    pid = process.myPid()
+    copy_to_clipboard(msg)
+    process.killProcess(pid)
+
+@deprecated("useless")
+def err(msg: str):
+    if msg: _err(msg)
+
+def _xor(_str: str, key: int) -> str:
+    xor_str = ""
+    for char in _str: xor_str += "".join(chr(ord(char) ^ key))
+    return xor_str
+
+@deprecated("useless")
+def _get_ctx() -> Any:
+    tg = _get_tg_classes()
+    loader = tg["ApplicationLoader"]
+    ctx = loader.applicationContext
+    return ctx
+
+def _settings_label(text: str) -> Any:
+    ctx = _get_ctx()
+    android = _get_android_classes()
+    _text_view = android["widget.TextView"]
+    textView = _text_view(ctx)
+    textView.setText(text)
+    _label = Custom(view=textView)
+    return _label
+
+def _find_su() -> str:
+    su_dir = [
+            "/bin",
+            "/sbin",
+            "/system/bin",
+            "/vendor/bin"
+            ]
+    _su_dir = ""
+    for _dir in su_dir:
+        file = pathlib.Path(f"{_dir}/su")
+        if file.exists(): _su_dir = f"{_dir}/su"
+    return _su_dir
+
+def _create_text(text: list) -> str:
+    _text = ""
+    for line in text:
+        _text += line
+        index = text.index(_text)
+        length = text.__len__()
+        if length is not index: _text += "\n"
+    return _text
+
+@dataclass
+class Point:
+    x: int
+    y: int
+
+@dataclass
+class Size:
+    width: int
+    height: int
+
+@dataclass
+class Output:
+    stdout: str
+    stderr: str
+
+@dataclass
+class Gift:
+    _id: int
+    price: int
+    sticker: int
+
+@deprecated("TaskManager дает больше контроля и ленивый запуск, в отличии от PartRun")
+class PartRun:
+    def __init__(self, init, start, main, _continue, end):
+        self.init = init
+        self.start = start
+        self.main = main
+        self._continue = _continue
+        self.end = end
+        self.init()
+        self.start()
+        self.main()
+        self._continue()
+        self.end()
+
+# Хз зачем, пусть будет...
+# Все таки помечу как deprecated
+@deprecated("TaskManager дает больше контроля и ленивый запуск, в отличии от LoadClass")
+class LoadClass:
+    def __init__(self, load, unload):
+        self.load = load
+        self.unload = unload
+    def _load(self): self.load()
+    def _unload(self): self.unload()
+
+"""
+Использование TaskManager:
+manager = TaskManager()
+
+@manager.Task("foo")
+def foo(): print("bar")
+
+@manager.Task("bar")
+def bar(): print("foo")
+
+manager.Run("foo")
+manager.Run("bar")
+
+# Тута запуск задач по порядку создания
+manager.RunAll()
+"""
+class TaskManager:
+    def __init__(self): self.tasks = {}
+    def Task(self, name: str):
+        def decorator(function):
+            self.tasks[name] = {"function": function}
+            return function
+        return decorator
+    def Run(self, name: str):
+        task = self.tasks.get(name)
+        if task:
+            function = task.get("function")
+            if function: function()
+    def RunAll(self):
+        for name in self.tasks:
+            task = self.tasks.get(name)
+            if task:
+                function = task.get("function")
+                if function: function()
+
+# В отличии от класса в других моих плагинах, тута я поменял получение сервиса, должно работать везде
+class VibBlink:
+    def vib(self):
+        ctx = _get_ctx()
+        android = _get_android_classes()
+        vibration = ctx.getSystemService(ctx.VIBRATOR_SERVICE)
+        if vibration:
+            try:
+                effect = android["os.VibrationEffect"]
+                vibration.vibrate(effect.createOneShot(1000, 500))
+            except:
+                vibration.vibrate(1000)
+    def blink(self):
+        thread = threading.Thread(target=self.vib, daemon=True)
+        thread.start()
+
+class File:
+    @staticmethod
+    def Read(path: str, encoding: str) -> str:
+        with open(path, "r", encoding=encoding) as file:
+            data = file.read()
+            return data
+    @staticmethod
+    def Write(path: str, encoding: str, data: str):
+        with open(path, "w", encoding=encoding) as file:
+            file.write(data)
+    @staticmethod
+    def Exists(path: str) -> bool:
+        file = pathlib.Path(path)
+        return file.exists()
+    @staticmethod
+    def ReadLine(path: str, encoding: str) -> Any:
+        with open(path, "r", encoding=encoding) as file:
+            for line in file.readlines(): yield line
+
+class TelegramBrowser:
+    browser = None
+    context = None
+
+    def OpenUrl(self, url: str):
+        tg = _get_tg_classes()
+        self.browser = tg["browser.Browser"]
+        self.context = _get_ctx()
+        self.browser.openUrl(self.context, url)
+
+class FileDownload:
+    @staticmethod
+    def Download(url: str, path: str):
+        response = requests.get(url, timeout=30)
+        response.raise_for_status()
+
+        with open(path, "wb") as file:
+            file.write(response.content)
+
+def _get_args(text: str) -> list:
+    args = text.split(" ")
+    return args
+
+def _get_args_str(text: str) -> str:
+    space_index = text.find(" ")
+    if space_index is -1: return ""
+    args = text[space_index + 1:].strip()
+    return args
+
+def log(prefix: str, msg: str):
+    _str = f"[{prefix}] {msg}"
+    _log(_str)
+
+# Не юзайте там, где нужны esc codes, zero, ZWNJ, BOM, и т.д
+def _clear_str(_str: str) -> str:
+    string = _str.replace("\0", "") # Zero
+    string = string.replace("\x00", "") # Zero
+    string = string.replace("\a", "") # Beep
+    string = string.replace("\u200C", "") # ZWNJ
+    string = string.replace("\r", "") # Это уже конвертация DOS в UNIX, но похуй
+    string = string.replace("\b", "") # Backspace
+    string = string.replace("\xEF\xBB\xBF", "") # BOM
+    return string
+
+class Fortune:
+    def parse_fortunes(self, path: str) -> list:
+        file = File()
+        data = file.Read(path, "UTF-8")
+        fortunes = self.parse_fortunes_with_data(data)
+        return fortunes
+    def parse_fortunes_with_data(self, data: str) -> list:
+        fortunes = []
+        lines = []
+        _data = _clear_str(data)
+
+        for line in _data.splitlines():
+            if line.strip() is "%":
+                if lines:
+                    fortune = "\n".join(lines).strip()
+                    fortunes.append(fortune)
+                    lines = []
+                else: lines.append(line)
+        return fortunes
+
+@deprecated("useless")
+def _get_activity() -> Any:
+    ctx = _get_ctx()
+    fragment = ctx.get("fragment") or get_last_fragment()
+    activity = fragment.getParentActivity()
+    return activity
+
+@deprecated("not working")
+def _alert_dialog(title: str, msg: str, positive_str: str, negative_str: str, on_positive_click, on_negative_click):
+    activity = _get_activity()
+    builder = AlertDialogBuilder(activity)
+    builder.set_title(title)
+    builder.set_message(msg)
+    builder.set_positive_button(positive_str, on_positive_click)
+    builder.set_negative_button(negative_str, on_negative_click)
+    builder.create()
+    builder.set_cancelable(True)
+    builder.show()
+
+class Subprocess:
+    @staticmethod
+    def Run(args: list) -> Output:
+        output = Output(stdout="", stderr="")
+        if args:
+            process = subprocess.run(args, text=True, capture_output=True)
+            output = Output(stdout=process.stdout, stderr=process.stderr)
+        return output
+    @staticmethod
+    def ShellRun(cmd: str) -> Output:
+        output = Output(stdout="", stderr="")
+        if cmd:
+            process = subprocess.run(cmd, text=True, capture_output=True, shell=True)
+            output = Output(stdout=process.stdout, stderr=process.stderr)
+        return output
+
+@dataclass
+class Command:
+    name: str
+    command: str
+    prefix: str
+    function: Any
+
+class PhysicsUtils:
+    CELSIUS = 0x0000
+    KELVIN = 0x1FFF
+
+    def __init__(self):
+        getcontext().prec = 2
+
+    # address - адрес к единице измерения в которую нужно конвертировать
+    # В классе есть константы с адресами
+    def convert(self, address: int, value: Decimal) -> Decimal:
+        _value: Decimal = value
+        match address:
+            case self.CELSIUS: _value -= Decimal("273.15")
+            case self.KELVIN: _value += Decimal("273.15")
+        return _value
+
+# HookRouter взял из плагина AntiScam от @binbash_0
+class HookRouter:
+    def __init__(self):
+        self.handlers = {}
+
+    def hook(self, name: Union[str, List[str]]):
+        names = frozenset([name] if isinstance(name, str) else name)
+
+        def decorator(func):
+            @functools.wraps(func)
+            def wrapper(calling_name, *args, **kwargs):
+                if calling_name not in names:
+                    return HookResult(strategy=HookStrategy.DEFAULT)
+                return func(*args, **kwargs)
+
+            for n in names:
+                self.handlers.setdefault(n, []).append(wrapper)
+            return func
+
+        return decorator
+
+def _stop_plugin(_id: str):
+    def stop():
+        PluginsController = find_class("com.exteragram.messenger.plugins.PluginsController")
+        instance = PluginsController.getInstance()
+        plugin = instance.plugins.get(_id)
+        plugin.setEnabled(False)
+    run_on_queue(stop, delay=50)
+
+class JavaExceptions:
+    def __init__(self):
+        self.JavaException = jclass("java.lang.Exception")
+        self.RuntimeException = jclass("java.lang.RuntimeException")
+        self.SecurityException = jclass("java.lang.SecurityException")
+        self.IllegalStateException = jclass("java.lang.IllegalStateException")
+        self.NullPointerException = jclass("java.lang.NullPointerException")
+        self.AccessViolationException = jclass("java.lang.AccessViolationException")
+        self.IllegalArgumentException = jclass("java.lang.IllegalArgumentException")
+        self.IOException = jclass("java.lang.IOException")
+        self.SocketException = jclass("java.lang.SocketException")
+        self.ConnectException = jclass("java.lang.ConnectException")
+        not_exceptions_1 = not self.JavaException and not self.RuntimeException
+        not_exceptions_2 = not self.SecurityException and not self.IllegalStateException
+        not_exceptions_3 = not self.NullPointerException and not self.AccessViolationException
+        not_exceptions_4 = not self.IllegalArgumentException and not self.IOException
+        not_exceptions_5 = not self.SocketException and not self.ConnectException
+        not_exceptions = (
+                not_exceptions_1 and
+                not_exceptions_2 and
+                not_exceptions_3 and
+                not_exceptions_4 and
+                not_exceptions_5
+                )
+        if (not_exceptions): _stop_plugin(__id__)
+        self.exceptions = {"java.lang.Exception": self.JavaException}
+        self.exceptions["java.lang.RuntimeException"], self.exceptions["java.lang.SecurityException"], self.exceptions["java.lang.IllegalStateException"], self.exceptions["java.lang.NullPointerException"], self.exceptions["java.lang.AccessViolationException"], self.exceptions["java.lang.IllegalArgumentException"], self.exceptions["java.lang.IOException"], self.exceptions["java.lang.SocketException"], self.exceptions["java.lang.ConnectException"] = (
+            self.RuntimeException,
+            self.SecurityException,
+            self.IllegalStateException,
+            self.NullPointerException,
+            self.AccessViolationException,
+            self.IllegalArgumentException,
+            self.IOException,
+            self.SocketException,
+            self.ConnectException
+        )
+    def _java_raise(self, exception: str):
+        _exception = self.exceptions.get(exception)
+        if _exception: raise _exception()
+    def _get_exception(self, exception: str) -> Any:
+        _exception = self.exceptions.get(exception)
+        return _exception
+
+class AdvancedBulletinHelper(BulletinHelper):
+    def __init__(self):
+        self.INFO = 0x1000
+        self.ERROR = 0xFFFF
+        self.SUCCESS = 0x0000
+    # show функция только для info, error, success
+    # Для button юзаем show_with_button из ориг BulletinHelper
+    def show(self, msg: str, status: int):
+        bulletin = BulletinHelper.show_info # Будет show_info как fallback
+        match status:
+            case self.ERROR: bulletin = BulletinHelper.show_error
+            case self.SUCCESS: bulletin = BulletinHelper.show_success
+        run_on_ui_thread(lambda: bulletin(msg))
+
+class Return:
+    @staticmethod
+    def _range(r: list) -> Any:
+        for i in r: yield i
+    @staticmethod
+    def _count(c: int) -> Any:
+        for i in range(c): yield i
+    @staticmethod
+    def _strings(sl: list[str]) -> Any:
+        for s in sl: yield s
+
+class ListImport:
+    def _clear_modules_str(self, modules: str) -> str:
+        _modules = _clear_str(modules)
+        _modules = _modules.replace(" ", "")
+        _modules = _modules.replace("\n", "")
+        return _modules
+    def _import(self, modules: str) -> list:
+        _modules = self._clear_modules_str(modules)
+        _modules_list = []
+        if _modules:
+            index = _modules.find(",")
+            if index is not -1:
+                _names = _modules.split(",")
+                if _names:
+                    for module in _names: _modules_list.append(module)
+        return _modules_list
+
+def _clear_cache():
+    cache_dir = get_cache_dir()
+    if cache_dir:
+        shutil.rmtree(cache_dir, ignore_errors=True)
+        os.mkdir(cache_dir)
+
+# Сразу говорю, это не получение директории, а получение самих плагинов
+def _get_plugins() -> list:
+    plugins_dir = get_plugins_dir()
+    plugins = []
+    if plugins_dir: plugins = list_dir(path=plugins_dir, extensions=[".py", ".plugin"])
+    return plugins
+
+@deprecated("AndroidUtilities.getPropertyString")
+def _verify_getprop_string(s: str) -> bool:
+    deny_chars = [
+        "`", "!", "@", "#", "$", "%", "^", "&", "*", "(", ")", "-", "_", "=", "+", "/", "\\",
+        "?", ",", "\"", "'", "|", "<", ">"
+    ]
+
+    status = []
+    _last_status = True
+
+    for char in deny_chars:
+        status.append(not s.__contains__(char))
+
+    for _status in status:
+        if not _status:
+            _last_status = False
+            break
+
+    return _last_status
+
+@deprecated("Используйте AndroidUtilities.getPropertyString")
+class AndroidUtils:
+    @staticmethod
+    def getprop(s: str) -> dict:
+        if _verify_getprop_string(s):
+            output = Subprocess.Run(["getprop", s])
+            _output = {
+                "stdout": output.stdout,
+                "stderr": output.stderr
+            }
+            return _output
+        output = {
+            "stdout": None,
+            "stderr": None
+        }
+        return output
+
+class LocaleManager:
+    def __init__(self, strings: dict): self.strings = strings
+    def _get_lang(self) -> str:
+        java = _get_java_classes()
+        Locale = java.get("util.Locale")
+        default = Locale.getDefault()
+        lang = default.getLanguage()
+        return lang
+    def _get_string(self, lang: str, _str_id: str) -> str:
+        string = self.strings[lang][_str_id]
+        return string
+    def get_string(self, _str_id: str) -> str:
+        lang = self._get_lang()
+        string = self._get_string(lang, _str_id)
+        return string
+
+# Тута базовый интерпритатор Forth
+class Forth:
+    def __init__(self):
+        self.stack = []
+        self.words = {
+            ".": lambda: _log(self.stack.pop()),
+            "+": lambda: self.stack.append(self.stack.pop() + self.stack.pop()),
+            "-": lambda: self.stack.append(-self.stack.pop() + self.stack.pop()),
+            "*": lambda: self.stack.append(self.stack.pop() * self.stack.pop()),
+            "/": lambda: self.stack.append(1 // self.stack.pop() * self.stack.pop()),
+            "drop": lambda: self.stack.pop(),
+            "swap": lambda: (self.stack.append(self.stack.pop(-2)), self.stack.pop(-2)),
+            "dup": lambda: self.stack.append(self.stack[-1])
+        }
+
+    def _exec(self, code: str):
+        _code = code.lower()
+
+        for i in _code.split():
+            if i in self.words:
+                self.words[i]()
+            else:
+                try:
+                    self.stack.append(int(i))
+                except Exception:
+                    self.stack.append(i)
+
+class Const:
+    def __setattr__(self, name: str, value: Any):
+        if name in self.__dict__:
+            raise Exception("const")
+        super().__setattr__(name, value)
+
+class JSONError(Exception):
+    ...
+
+class TrueString(str):
+    def __bool__(self):
+        return True
+
+class FalseString(str):
+    def __bool__(self):
+        return False
+
+# :)
+class String(TrueString):
+    pass
+
+class MoonLib(BasePlugin):
+    vib_blink = None
+    path = None
+    data = """
+DON'T TOUCH THIS FILE
+
+This is file created for check plugin new install
+
+By MLevankov
+    """
+
+    def __init__(self):
+        super().__init__()
+
+        self.log = _log
+        self.versions = None
+        self.changes = None
+    def on_plugin_load(self):
+        self.log("[MoonLib] Plugin is successfully loaded")
+        self.add_on_send_message_hook()
+        self.log("[MoonLib] Message hook is successfully added")
+        ctx = _get_ctx()
+        self.path = f"{ctx.getFilesDir().getAbsolutePath()}/moonlib.txt"
+        new_install = self.is_new_install()
+        if new_install:
+            self.vib_blink = VibBlink()
+            self.vib_blink.blink()
+            self.log("[MoonLib] Vibrator is successfully called")
+            file = File()
+            file.Write(self.path, "UTF-8", self.data)
+            self.log("[MoonLib] File is successfully created")
+
+    def on_plugin_unload(self):
+        self.log("[MoonLib] Plugin is successfully unloaded")
+
+    def on_send_message_hook(self, account: int, params: Any) -> HookResult:
+        if params.message is ".moon":
+            self.vib_blink = VibBlink()
+            self.vib_blink.blink()
+            params.message = "By MLevankov :3"
+        return HookResult(strategy=HookStrategy.MODIFY, params=params)
+
+    def is_new_install(self) -> bool:
+        if File.Exists(self.path):
+            file_data = File.Read(self.path, "UTF-8")
+            if file_data is self.data:
+                return False
+            return False
+        return True
+
+    def create_settings(self) -> List[Any]:
+        # Ласт этап инициализации будет перед созданием настроек
+        self._end_initialization()
+
+        settings = [
+            Header(text="Настройки"),
+            Switch(key="enable_moon_command", text="Включить команду .moon", default=True)
+        ]
+        return settings
+
+    def _end_initialization(self):
+        def download():
+            try:
+                response = requests.get(
+                    "https://github.com/MLevankov/moonlib/raw/refs/heads/master/changelog.json",
+                    timeout=60
+                )
+                response.raise_for_status()
+                path = f"{self._get_absolute_path()}/changelog.json"
+
+                with open(path, "wb") as file:
+                    file.write(response.content)
+
+                with open(path, "r", encoding="UTF-8") as file:
+                    changelog = json.load(file)
+                    if isinstance(changelog, dict):
+                        self.versions = changelog.get("versions")
+                        self.changes = changelog.get("changes")
+
+                        if (
+                            self.versions and
+                            self.changes
+                        ):
+                            self._changelog()
+                        else:
+                            raise JSONError("version && changes == none")
+            except Exception as ex:
+                self.log(f"[MoonLib] {ex}")
+
+        thread = threading.Thread(target=download, daemon=True)
+        thread.start()
+
+    def _get_absolute_path(self) -> str:
+        ctx = _get_ctx()
+        return ctx.getFilesDir().getAbsolutePath()
+
+    def _changelog(self):
+        from base_plugin import(
+            MenuItemData,
+            MenuItemType
+        )
+
+        self.add_menu_item(
+            MenuItemData(
+                menu_type=MenuItemType.DRAWER_MENU,
+                text="MoonLib ChangeLog",
+                on_click=self._show_changelog
+            )
+        )
+
+    from typing import Dict
+
+    def _show_changelog(self, context: Dict[str, Any]):
+        activity = get_last_fragment().getParentActivity()
+
+        builder = AlertDialogBuilder(activity)
+
+        msg = f"""
+Изменения в либе:
+Версии: {self.versions}
+{self.changes}
+        """
+
+        def on_positive_click(bld: AlertDialogBuilder, which: int):
+            bld.dismiss()
+
+        def on_negative_click(bld: AlertDialogBuilder, which: int):
+            bld.dismiss()
+
+        builder.set_title("ChangeLog")
+        builder.set_message(msg)
+        builder.set_positive_button("OK", on_positive_click)
+        builder.set_negative_button("Cancel", on_negative_click)
+        builder.create()
+        builder.set_cancelable(True)
+        builder.show()

moonlib-1.0.0.dist-info/METADATA

@@ -0,0 +1,11 @@
+Metadata-Version: 2.4
+Name: moonlib
+Version: 1.0.0
+Summary: Мини либа для работы с java классами, и т.д
+Author: @MLPlugins
+License: @MoonLicence
+License-File: LICENCE
+Dynamic: author
+Dynamic: license
+Dynamic: license-file
+Dynamic: summary

moonlib-1.0.0.dist-info/RECORD

@@ -0,0 +1,6 @@
+main.py,sha256=5sOmlQ3liTqpOZW5umEuyJACMd4lv_EZrXTBTWyILhs,26856
+moonlib-1.0.0.dist-info/licenses/LICENCE,sha256=2QA-eWMIwR12hsp2O2S_b1sSyVlNBDWavUgvGPKqO1g,13
+moonlib-1.0.0.dist-info/METADATA,sha256=CVRja6xq6Y6vlNV-dMiMET5mAwpEI-YkB_PHgFcJT6Y,268
+moonlib-1.0.0.dist-info/WHEEL,sha256=K260EYznzXsJYBQGqmI8VTxEdiZYNvDZwW9cBh9-_MA,91
+moonlib-1.0.0.dist-info/top_level.txt,sha256=ZAMgPdWghn6xTRBO6Kc3ML1y3ZrZLnjZlqbboKXc_AE,5
+moonlib-1.0.0.dist-info/RECORD,,

moonlib-1.0.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (83.0.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

moonlib-1.0.0.dist-info/licenses/LICENCE

@@ -0,0 +1 @@
+@MoonLicence

moonlib-1.0.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+main