Added and updated repositories 2026-01-30 01:21:56

.github/workflows/ci.yml

@@ -137,8 +137,9 @@ jobs:
           python3 -m venv venv
           source venv/bin/activate
           pip install --upgrade pip
-          pip install requests
+          pip install requests scikit-learn tqdm
           python3 parse.py
+          python3 categories.py
           git add modules.json
           git commit -m "Updated modules.json after parse $(date +'%Y-%m-%d %H:%M:%S')" || echo "No changes for modules.json"
           git remote set-url origin "https://x-access-token:${GITHUB_TOKEN}@${REPO_URL}"
@@ -205,53 +206,61 @@ jobs:
             echo "Branch ${{ env.BRANCH_NAME }} does not exist in remote repository, skipping PR creation."
           fi
 
-  notify_diffs:
-    runs-on: ubuntu-latest
-    if: |
-      (github.event_name == 'push' && github.ref == 'refs/heads/main') ||
-      (github.event_name == 'pull_request' && github.event.action == 'closed' && github.event.pull_request.merged == true)
-    needs: parse
-    steps:
-      - name: Checkout repository
-        uses: actions/checkout@v4
-        with:
-          fetch-depth: ${{ env.GIT_DEPTH }}
-      - name: Configure Git for github-actions[bot]
-        run: |
-          git config --global user.email "github-actions[bot]@users.noreply.github.com"
-          git config --global user.name "github-actions[bot]"
-      - name: Set up Python 3.9
-        uses: actions/setup-python@v5
-        with:
-          python-version: '3.9'
-      - name: Install Python dependencies
-        run: pip install aiohttp
-      - name: Send module diffs to channel
-        env:
-          TELEGRAM_BOT_TOKEN: ${{ secrets.TELEGRAM_BOT_TOKEN }}
-          TELEGRAM_CHAT_ID: ${{ secrets.TELEGRAM_CHAT_ID_UPDATE }}
-        run: |
-          git fetch origin main
-          python3 update_diffs.py --token ${{ secrets.TELEGRAM_BOT_TOKEN }} --chat_id ${{ secrets.TELEGRAM_CHAT_ID_UPDATE }} --base_commit HEAD~1
-
   backup:
     runs-on: ubuntu-latest
     if: github.ref == 'refs/heads/main' || github.event_name == 'workflow_dispatch'
     needs: parse
     steps:
+      - name: Configure Git for github-actions[bot]
+        run: |
+          git config --global user.email "github-actions[bot]@users.noreply.github.com"
+          git config --global user.name "github-actions[bot]"
+          git config --global --list
       - name: Checkout repository
         uses: actions/checkout@v4
         with:
           fetch-depth: ${{ env.GIT_DEPTH }}
-      - name: Set up Python 3.9
-        uses: actions/setup-python@v5
-        with:
-          python-version: '3.9'
-      - name: Install Python dependencies
-        run: pip install aiohttp
-      - name: Run backup script
+      - name: Create and send backup to Telegram
         env:
           TELEGRAM_BOT_TOKEN: ${{ secrets.TELEGRAM_BOT_TOKEN }}
           TELEGRAM_CHAT_ID: ${{ secrets.TELEGRAM_CHAT_ID }}
         run: |
-          python backup.py --token ${{ secrets.TELEGRAM_BOT_TOKEN }} --chat_id ${{ secrets.TELEGRAM_CHAT_ID }}
+          echo "Creating .zip file of the repository with maximum compression..."
+          git archive --format=zip --output=repository-original.zip HEAD
+          zip -9 repository.zip repository-original.zip
+          rm repository-original.zip
+          echo "File size of the created .zip file:"
+          du -sh repository.zip
+          echo "Splitting the .zip file into 8 parts..."
+          split -b 49M repository.zip repository-part-
+          echo "Files created after split:"
+          ls repository-part-*
+          COMMIT_MESSAGE="$(git log -1 --pretty=%B)"
+          COMMIT_DATE="$(date --date="$(git log -1 --pretty=%ci)" +'%Y-%m-%d %H:%M:%S')"
+          COMMIT_HASH="$(git rev-parse --short=6 HEAD)"
+          COMMIT_URL="https://${REPO_URL}/commit/$(git rev-parse HEAD)"
+          MESSAGE="Commit Date: $COMMIT_DATE, Commit Message: $COMMIT_MESSAGE, Commit Hash: [\`$COMMIT_HASH\`]($COMMIT_URL)"
+          
+          echo "Sending .zip file parts to Telegram..."
+          
+          FIRST_PART=true
+          for part in $(ls repository-part-* | sort); do
+            if $FIRST_PART; then
+              TELEGRAM_API_URL="https://api.telegram.org/bot$TELEGRAM_BOT_TOKEN/sendDocument"
+              echo "Sending first file to Telegram: $TELEGRAM_API_URL"
+              curl -X POST "$TELEGRAM_API_URL" \
+                -F chat_id=$TELEGRAM_CHAT_ID \
+                -F document=@$part \
+                -F caption="$MESSAGE" \
+                -F parse_mode="Markdown"
+              FIRST_PART=false
+            else
+              TELEGRAM_API_URL="https://api.telegram.org/bot$TELEGRAM_BOT_TOKEN/sendDocument"
+              echo "Sending file to Telegram: $TELEGRAM_API_URL"
+              curl -X POST "$TELEGRAM_API_URL" \
+                -F chat_id=$TELEGRAM_CHAT_ID \
+                -F document=@$part
+            fi
+          done
+          
+          echo "Files sent to Telegram successfully!"

backup.py

@@ -1,74 +0,0 @@
-import asyncio
-import aiohttp
-import argparse
-import subprocess
-import os
-import glob
-
-parser = argparse.ArgumentParser(description="Backup Script")
-parser.add_argument(
-    "--token",
-    type=str,
-    required=True,
-    help="Token of Telegram bot",
-)
-parser.add_argument(
-    "--api_url",
-    type=str,
-    default="https://api.telegram.org",
-    help="API URL of Telegram API",
-)
-parser.add_argument(
-    "--chat_id",
-    type=str,
-    required=True,
-    help="Chat ID to send backup message to",
-)
-
-arguments = parser.parse_args()
-
-async def send_file(session, file_path, caption=None):
-    url = f"{arguments.api_url}/bot{arguments.token}/sendDocument"
-    with open(file_path, 'rb') as f:
-        data = aiohttp.FormData()
-        data.add_field('chat_id', arguments.chat_id)
-        data.add_field('document', f, filename=os.path.basename(file_path))
-        if caption:
-            data.add_field('caption', caption)
-            data.add_field('parse_mode', 'Markdown')
-        async with session.post(url, data=data) as response:
-            return await response.json()
-
-async def main():
-    # Get commit info
-    commit_message = subprocess.check_output(['git', 'log', '-1', '--pretty=%B']).decode().strip()
-    commit_date = subprocess.check_output(['git', 'log', '-1', '--pretty=%ci']).decode().strip()
-    commit_hash = subprocess.check_output(['git', 'rev-parse', '--short=6', 'HEAD']).decode().strip()
-    commit_url = f"https://github.com/MuRuLOSE/limoka/commit/{subprocess.check_output(['git', 'rev-parse', 'HEAD']).decode().strip()}"
-    message = f"Commit Date: {commit_date}, Commit Message: {commit_message}, Commit Hash: [`{commit_hash}`]({commit_url})"
-
-    # Create zip
-    subprocess.run(['git', 'archive', '--format=zip', '--output=repository-original.zip', 'HEAD'])
-    subprocess.run(['zip', '-9', 'repository.zip', 'repository-original.zip'])
-    os.remove('repository-original.zip')
-
-    # Split zip
-    subprocess.run(['split', '-b', '49M', 'repository.zip', 'repository-part-'])
-
-    # Send parts
-    async with aiohttp.ClientSession() as session:
-        parts = sorted(glob.glob('repository-part-*'))
-        first = True
-        for part in parts:
-            caption = message if first else None
-            result = await send_file(session, part, caption)
-            print(f"Sent {part}: {result}")
-            first = False
-
-    # Cleanup
-    os.remove('repository.zip')
-    for part in parts:
-        os.remove(part)
-
-if __name__ == "__main__":
-    asyncio.run(main())

categories.py

@@ -0,0 +1,126 @@
+import json
+from sklearn.feature_extraction.text import TfidfVectorizer
+from sklearn.linear_model import LogisticRegression
+from sklearn.multiclass import OneVsRestClassifier
+from sklearn.preprocessing import MultiLabelBinarizer
+from tqdm import tqdm
+import numpy as np
+
+# Тренировочные данные (48 модулей)
+training_data = {
+    "MuRuLOSE/HikkaModulesRepo/filters.py": ["Tools", "Chat"],
+    "MuRuLOSE/HikkaModulesRepo/autogiveawayjoin.py": ["Automation", "Social"],
+    "MuRuLOSE/HikkaModulesRepo/HTTPCat.py": ["Fun"],
+    "MuRuLOSE/HikkaModulesRepo/CustomPing.py": ["Tools", "Networking"],
+    "MuRuLOSE/HikkaModulesRepo/FuckTagOne.py": ["Moderation"],
+    "MuRuLOSE/HikkaModulesRepo/InlineButtons.py": ["Tools", "Chat"],
+    "MuRuLOSE/HikkaModulesRepo/YoutubeDL.py": ["Media"],
+    "MuRuLOSE/HikkaModulesRepo/youtubesearcher.py": ["Media", "Tools"],
+    "MuRuLOSE/HikkaModulesRepo/INumber.py": ["Fun", "Info"],
+    "MuRuLOSE/HikkaModulesRepo/RandomDog.py": ["Fun"],
+    "MuRuLOSE/HikkaModulesRepo/RemoveLinks.py": ["Moderation", "Chat"],
+    "MuRuLOSE/HikkaModulesRepo/SteamClient.py": ["Games", "Tools"],
+    "MuRuLOSE/HikkaModulesRepo/PinMoreChats.py": ["Chat", "Productivity"],
+    "MuRuLOSE/HikkaModulesRepo/MindGameCheat.py": ["Games", "Tools"],
+    "MuRuLOSE/HikkaModulesRepo/NasaImages.py": ["Media", "Info"],
+    "MuRuLOSE/HikkaModulesRepo/autoreader.py": ["Automation", "Chat"],
+    "MuRuLOSE/HikkaModulesRepo/K.py": ["Fun"],
+    "MuRuLOSE/HikkaModulesRepo/Genshin.py": ["Games"],
+    "MuRuLOSE/HikkaModulesRepo/compliments.py": ["Social", "Fun"],
+    "MuRuLOSE/HikkaModulesRepo/AutoLeave.py": ["Automation", "Chat"],
+    "MuRuLOSE/HikkaModulesRepo/ToTHosting.py": ["Tools", "Admin"],
+    "MuRuLOSE/HikkaModulesRepo/PasswordUtils.py": ["Security", "Tools"],
+    "MuRuLOSE/HikkaModulesRepo/FuckJoins.py": ["Security", "Chat"],
+    "MuRuLOSE/HikkaModulesRepo/SpyEVO.py": ["Tools", "Info"],
+    "MuRuLOSE/HikkaModulesRepo/FindID.py": ["Tools", "Admin"],
+    "MuRuLOSE/HikkaModulesRepo/ChannelCheck.py": ["Tools", "Social"],
+    "MuRuLOSE/HikkaModulesRepo/controlspam.py": ["Chat", "Tools"],
+    "MuRuLOSE/HikkaModulesRepo/VKMusic.py": ["Media"],
+    "MuRuLOSE/HikkaModulesRepo/morse.py": ["Tools", "Fun"],
+    "MuRuLOSE/HikkaModulesRepo/YamiManager.py": ["Chat", "Tools"],
+    "MuRuLOSE/HikkaModulesRepo/SearchersGenQuery.py": ["Tools", "Info"],
+    "MuRuLOSE/HikkaModulesRepo/Limoka.py": ["Utilities", "Tools"],
+    "MuRuLOSE/HikkaModulesRepo/CheckTime.py": ["Productivity", "Info"],
+    "MuRuLOSE/HikkaModulesRepo/ReplaceWords.py": ["Chat", "Customization"],
+    "MuRuLOSE/HikkaModulesRepo/TempJoinChannel.py": ["Chat", "Automation"],
+    "MuRuLOSE/HikkaModulesRepo/timer.py": ["Productivity", "Tools"],
+    "den4ikSuperOstryyPer4ik/astro-modules/astroafk.py": ["Automation", "Customization"],
+    "den4ikSuperOstryyPer4ik/astro-modules/akinator.py": ["Games"],
+    "den4ikSuperOstryyPer4ik/astro-modules/Emotions.py": ["Social", "Fun"],
+    "den4ikSuperOstryyPer4ik/astro-modules/RandomStatuses.py": ["Social", "Fun"],
+    "den4ikSuperOstryyPer4ik/astro-modules/RandomTrack.py": ["Media", "Fun"],
+    "den4ikSuperOstryyPer4ik/astro-modules/minesweeper.py": ["Games"],
+    "den4ikSuperOstryyPer4ik/astro-modules/inline_bot_manager.py": ["Tools", "Automation"],
+    "MuRuLOSE/HikkaModulesRepo/ReplaceWords.py": ["Customization", "Chat"],
+    "MuRuLOSE/HikkaModulesRepo/CheckTime.py": ["Productivity"],
+    "MuRuLOSE/HikkaModulesRepo/SearchersGenQuery.py": ["Utilities", "Info"]
+}
+
+all_categories = [
+    "Utilities", "Fun", "Admin", "Media", "Games", "Tools", "Security", "Social",
+    "Automation", "Info", "Chat", "Moderation", "Productivity", "Customization",
+    "Networking", "Education", "Finance", "Health", "Creative", "Other"
+]
+
+def get_module_text(module_path, module_data):
+    name = module_data.get("name", "").lower()
+    description = (module_data.get("description", "") or module_data.get("meta", {}).get("desc", "")).lower()
+    if not description or description == "desc":
+        description = ""
+    commands_text = " ".join([f"{cmd} {desc}".lower() for func in module_data.get("commands", []) for cmd, desc in func.items()])
+    new_commands_text = " ".join([f"{cmd} {data.get('doc', '')} {data.get('ru_doc', '') or ''}".lower()
+                                 for func in module_data.get("new_commands", []) for cmd, data in func.items()])
+    file_path = module_path.lower()
+    file_name = file_path.split("/")[-1]
+    return f"{file_name} {name} {description} {file_path} {commands_text} {new_commands_text}".strip()
+
+
+with open("modules.json", "r", encoding="utf-8") as f:
+    modules = json.load(f)
+
+# Подготовка тренировочных данных
+train_texts = [get_module_text(path, modules[path]) for path in training_data.keys() if path in modules]
+train_labels = [training_data[path] for path in training_data.keys() if path in modules]
+
+# Векторизация текста
+vectorizer = TfidfVectorizer(max_features=2000)
+X_train = vectorizer.fit_transform(train_texts)
+
+# Преобразование меток
+mlb = MultiLabelBinarizer(classes=all_categories)
+y_train = mlb.fit_transform(train_labels)
+
+# Обучение модели с балансировкой классов
+base_clf = LogisticRegression(class_weight="balanced", max_iter=1000)
+clf = OneVsRestClassifier(base_clf)
+clf.fit(X_train, y_train)
+
+# Обработка всех модулей
+print("Classifying all modules...")
+texts = [get_module_text(path, data) for path, data in modules.items()]
+X_all = vectorizer.transform(texts)
+
+# Предсказание вероятностей
+probs = clf.predict_proba(X_all)
+
+# Присваивание категорий
+threshold = 0.2  # Снижаем порог для большего разнообразия
+for module_path, prob_vector in tqdm(zip(modules.keys(), probs), total=len(modules), desc="Assigning categories"):
+    module_data = modules[module_path]
+    sorted_indices = np.argsort(prob_vector)[::-1]
+    sorted_probs = prob_vector[sorted_indices]
+    sorted_labels = mlb.classes_[sorted_indices]
+    
+    selected_categories = [label for label, prob in zip(sorted_labels, sorted_probs) if prob >= threshold][:2]
+    
+    if not selected_categories:
+        selected_categories = ["Other"]
+    
+    module_data["category"] = selected_categories
+    print(f"Module: {module_path} -> Categories: {selected_categories} (top probs: {[f'{p:.2f}' for p in sorted_probs[:3]]})")
+
+# Сохранение результата
+with open("modules.json", "w", encoding="utf-8") as f:
+    json.dump(modules, f, ensure_ascii=False, indent=2)
+
+print("Done! Check modules_categorized.json.")

parse.py

@@ -1,353 +1,171 @@
+import os
 import ast
 import json
-import os
-import logging
-from typing import Dict, Any, Optional, List
 
-logging.basicConfig(level=logging.WARNING, format="%(message)s")
-logger = logging.getLogger(__name__)
+from clone_repos import repos
+from typing import Dict
 
-def safe_unparse(node: ast.AST) -> str:
-    try:
-        return ast.unparse(node)
-    except AttributeError:
-        return getattr(node, 'id', str(type(node).__name__))
+# TODO: ADD VENV IGNORE
 
-def load_blacklist(file_path):
-    with open(file_path, "r", encoding="utf-8") as f:
-        data = json.load(f)
-        repositories = data.get("repositories", [])
-        blacklisted_modules = {}
 
-        for i in repositories:
-            path = i.get("path", "")
-            blacklist = i.get("blacklist", [])
-            if path and blacklist:
-                blacklisted_modules[path] = blacklist
+def get_module_info(module_path):
+    """Парсит Python-модуль и извлекает информацию о нем."""
+    with open(module_path, "r", encoding="utf-8") as f:
+        module_content = f.read()
 
-    return blacklisted_modules
+    meta_info = {"pic": None, "banner": None}
+    for line in module_content.split("\n"):
+        if line.startswith("# meta"):
+            key, value = line.replace("# meta ", "").split(": ")
+            meta_info[key] = value
 
-def extract_string_value(node: ast.AST) -> Optional[str]:
-    try:
-        if isinstance(node, ast.Constant) and isinstance(node.value, str):
-            return node.value
-        if isinstance(node, ast.Str):
-            return node.s
-        if isinstance(node, ast.Name):
-            return node.id
-        if isinstance(node, ast.Attribute):
-            return f"{safe_unparse(node.value)}.{node.attr}"
-        return str(node)
-    except Exception:
-        return None
+    tree = ast.parse(module_content)
 
-def extract_loader_command_args(decorator: ast.Call) -> Dict[str, Any]:
-    args = {"lang_docs": {}, "aliases": [], "usage": None}
-    try:
-        for kw in decorator.keywords:
-            arg_name = kw.arg
-            if not arg_name:
-                continue
-            if arg_name.endswith("_doc"):
-                lang = arg_name[:-4]
-                args["lang_docs"][lang] = extract_string_value(kw.value)
-            elif arg_name == "aliases":
-                try:
-                    val = ast.literal_eval(kw.value)
-                    if isinstance(val, (list, tuple)):
-                        args["aliases"] = list(val)
-                except (ValueError, SyntaxError):
-                    pass
-            elif arg_name == "usage":
-                args["usage"] = extract_string_value(kw.value)
-    except Exception:
-        pass
-    return args
+    def get_decorator_names(decorator_list):
+        return [ast.unparse(decorator) for decorator in decorator_list]
 
-def get_module_info(module_path: str) -> Optional[Dict[str, Any]]:
-    try:
-        with open(module_path, "r", encoding="utf-8") as f:
-            source = f.read()
-    except Exception as e:
-        logger.warning(f"Skipping {module_path}: read failed — {e}")
-        return None
-
-    source = source.lstrip('\ufeff')
-    source = ''.join(c for c in source if ord(c) >= 32 or c in '\n\r\t') if source else source
-
-    meta = {"pic": None, "banner": None, "developer": None}
-    for line in source.splitlines():
-        line = line.strip()
-        if line.startswith("# meta "):
-            try:
-                key, val = line[len("# meta "):].split(":", 1)
-                meta[key.strip()] = val.strip()
-            except ValueError:
-                pass
-
-    try:
-        tree = ast.parse(source, filename=module_path)
-    except SyntaxError as e:
-        logger.warning(f"Skipping {module_path}: syntax error — {e}")
-        return {
-            "name": module_path.split(os.sep)[-1].replace(".py", ""),
-            "description": "",
-            "cls_doc": {},
-            "meta": meta,
-            "commands": [],
-            "new_commands": [],
-            "inline_handlers": [],
-            "strings": {},
-            "has_on_load": False,
-            "has_on_unload": False,
-            "class_cmd_names": {},
-        }
-
-    module_data = None
+    def extract_loader_command_args(decorator):
+        """Извлекает аргументы `ru_doc` и `en_doc` из `@loader.command`."""
+        if (
+            isinstance(decorator, ast.Call)
+            and hasattr(decorator.func, "attr")
+            and decorator.func.attr == "command"
+        ):
+            ru_doc = None
+            en_doc = None
+            for keyword in decorator.keywords:
+                if keyword.arg == "ru_doc":
+                    ru_doc = ast.literal_eval(keyword.value)
+                elif keyword.arg == "en_doc":
+                    en_doc = ast.literal_eval(keyword.value)
+            return ru_doc, en_doc
+        return None, None
 
+    result = {}
     for node in ast.walk(tree):
-        if not isinstance(node, ast.ClassDef):
-            continue
-
-        is_module_class = (
-            "Mod" in node.name or
-            any(isinstance(d, ast.Attribute) and safe_unparse(d).startswith("loader.tds") for d in node.decorator_list) or
-            any(isinstance(d, ast.Name) and d.id == "loader" for d in node.decorator_list)
-        )
-
-        if not is_module_class:
-            continue
-
-        info = {
-            "name": node.name,
-            "description": ast.get_docstring(node) or "",
-            "cls_doc": {},
-            "meta": meta,
-            "commands": [],
-            "new_commands": [],
-            "inline_handlers": [],
-            "strings": {},
-            "has_on_load": False,
-            "has_on_load": False,
-            "has_on_unload": False,
-            "class_cmd_names": {},
-        }
-
-        for item in node.body:
-            if isinstance(item, ast.Assign):
-                for target in item.targets:
-                    if isinstance(target, ast.Name) and (target.id == "strings" or target.id.startswith("strings_")):
-                        try:
-                            lit = ast.literal_eval(item.value)
-                            if isinstance(lit, dict):
-                                if target.id == "strings":
-                                    info["strings"].update(lit)
-                                    if "_cls_doc" in lit:
-                                        info["cls_doc"]["default"] = lit["_cls_doc"]
-                                else:
-                                    lang = target.id.split("_", 1)[1] if "_" in target.id else None
-                                    if lang:
-                                        for k, v in lit.items():
-                                            if isinstance(k, str) and isinstance(v, str):
-                                                if k == "_cls_doc":
-                                                    info["cls_doc"][lang] = v
-                                                elif k.startswith("_cmd_doc_"):
-                                                    rest = k[len("_cmd_doc_"):]
-                                                    info["strings"][f"_cmd_doc_{lang}_{rest}"] = v
-                                                    info["strings"][f"_cmd_doc_{rest}_{lang}"] = v
-                                                elif k.startswith("_ihandle_doc_"):
-                                                    rest = k[len("_ihandle_doc_"):]
-                                                    info["strings"][f"_ihandle_doc_{lang}_{rest}"] = v
-                                                    info["strings"][f"_ihandle_doc_{rest}_{lang}"] = v
-                                                elif k.startswith("_cls_cmd_"):
-                                                    info["class_cmd_names"][lang] = v
-                                                else:
-                                                    info["strings"][f"{k}_{lang}"] = v
-                        except Exception:
-                            pass
-
-        if "_cls_doc" in info["strings"]:
-            info["cls_doc"]["default"] = info["strings"]["_cls_doc"]
-
-        for func in node.body:
-            if not isinstance(func, (ast.FunctionDef, ast.AsyncFunctionDef)):
+        if isinstance(node, ast.ClassDef):
+            decorators = get_decorator_names(node.decorator_list)
+            is_tds_mod = [d for d in decorators if "loader.tds" in d]
+            if "Mod" not in node.name and not is_tds_mod:
                 continue
 
-            name = func.name
-            if name == "on_load":
-                info["has_on_load"] = True
-                continue
-            if name == "on_unload":
-                info["has_on_unload"] = True
-                continue
-
-            is_decorated = any(
-                isinstance(d, ast.Call) and hasattr(d.func, 'attr') and 
-                d.func.attr in ("command", "inline_handler", "unrestricted", "owner")
-                for d in func.decorator_list
-            )
-            
-            if name.startswith("_") and not is_decorated:
-                continue
-
-            cmd = {
-                "name": name,
-                "doc": ast.get_docstring(func) or "",
-                "lang_docs": {},
-                "aliases": [],
-                "usage": None,
-                "inline": False,
-                "is_inline_handler": False,
-                "decorators": [],
-                "cmd_names": {},
+            class_docstring = ast.get_docstring(node)
+            class_info = {
+                "name": node.name,
+                "description": class_docstring,
+                "meta": meta_info,
+                "commands": [],
+                "new_commands": [],
             }
 
-            for dec in func.decorator_list:
-                if isinstance(dec, ast.Call) and hasattr(dec.func, 'attr'):
-                    attr = dec.func.attr
-                    if attr == "command":
-                        cmd.update(extract_loader_command_args(dec))
-                    elif attr == "inline_handler":
-                        cmd["inline"] = True
-                        cmd["is_inline_handler"] = True
-                    elif attr in ("unrestricted", "owner", "support"):
-                        cmd["decorators"].append(attr)
+            for class_body_node in node.body:
+                if isinstance(class_body_node, (ast.FunctionDef, ast.AsyncFunctionDef)):
+                    decorators = get_decorator_names(class_body_node.decorator_list)
+                    is_loader_command = [d for d in decorators if "command" in d]
+                    if not is_loader_command and "cmd" not in class_body_node.name:
+                        continue
 
-            for stmt in func.body:
-                if isinstance(stmt, ast.Assign):
-                    for target in stmt.targets:
-                        if isinstance(target, ast.Attribute):
-                            attr = target.attr
-                            val = extract_string_value(stmt.value)
-                            if not val:
-                                continue
-                            if attr == "_cmd":
-                                cmd["name"] = val
-                            elif attr == "_doc":
-                                cmd["doc"] = val
-                            elif attr == "_cls_doc":
-                                info["cls_doc"]["default"] = val
-                            elif attr.startswith("_cls_doc_"):
-                                lang = attr[len("_cls_doc_"):]
-                                info["cls_doc"][lang] = val
-                            elif attr.startswith("_cmd_"):
-                                lang = attr[len("_cmd_"):]
-                                cmd["cmd_names"][lang] = val
+                    method_docstring = ast.get_docstring(class_body_node)
+                    command_name = class_body_node.name
+                    ru_doc, en_doc = None, None
 
-            is_command_name = "cmd" in name and not name.startswith("__")
-            if not (is_decorated or is_command_name):
-                continue
+                    for decorator in class_body_node.decorator_list:
+                        ru_doc_tmp, en_doc_tmp = extract_loader_command_args(decorator)
+                        if ru_doc_tmp:
+                            ru_doc = ru_doc_tmp
+                        if en_doc_tmp:
+                            en_doc = en_doc_tmp
 
-            clean_name = cmd["name"].replace("cmd", "").replace("_", "")
-            
-            descs = []
-            legacy_key = f"_cmd_doc_{clean_name}"
-            legacy_doc = info["strings"].get(legacy_key)
-            base_doc = legacy_doc if legacy_doc else cmd["doc"]
-            if base_doc:
-                descs.append(base_doc)
-            
-            for lang, text in cmd["lang_docs"].items():
-                if text:
-                    descs.append(f"({lang.upper()}) {text}")
-            
-            for k, v in info["strings"].items():
-                if k.startswith("_cmd_doc_") and clean_name in k and v:
-                    if k.endswith(f"_{clean_name}"):
-                        lang_part = k[len("_cmd_doc_"):-len(f"_{clean_name}")-1]
-                        if lang_part:
-                            descs.append(f"({lang_part.upper()}) {v}")
-                    elif k.startswith(f"_cmd_doc_{clean_name}_"):
-                        lang_part = k[len(f"_cmd_doc_{clean_name}_"):]
-                        if lang_part:
-                            descs.append(f"({lang_part.upper()}) {v}")
+                    descriptions = []
+                    if method_docstring:
+                        descriptions.append(method_docstring)
+                    if ru_doc:
+                        descriptions.append(ru_doc)
+                    if en_doc:
+                        descriptions.append(en_doc)
 
-            full_desc = " | ".join(filter(None, descs))
-            info["commands"].append({clean_name: full_desc})
+                    class_info["commands"].append(
+                        {command_name: ' '.join(descriptions)}
+                    )
 
-            desc_map = {"default": legacy_doc or cmd["doc"]}
-            desc_map.update(cmd["lang_docs"])
-            
-            for k, v in info["strings"].items():
-                if k.startswith("_cmd_doc_") and clean_name in k and v:
-                    if k.endswith(f"_{clean_name}"):
-                        lang_part = k[len("_cmd_doc_"):-len(f"_{clean_name}")-1]
-                        if lang_part:
-                            desc_map[lang_part] = v
-                    elif k.startswith(f"_cmd_doc_{clean_name}_"):
-                        lang_part = k[len(f"_cmd_doc_{clean_name}_"):]
-                        if lang_part:
-                            desc_map[lang_part] = v
+                    command_name = command_name.replace('cmd', '')
 
-            info["new_commands"].append({
-                "name": clean_name,
-                "original_name": cmd["name"],
-                "description": desc_map,
-                "cmd_names": cmd["cmd_names"],
-                "aliases": cmd["aliases"],
-                "usage": cmd["usage"],
-                "inline": cmd["inline"],
-                "is_inline_handler": cmd["is_inline_handler"],
-                "decorators": cmd["decorators"],
-            })
+                    class_info["new_commands"].append(
+                        {
+                            command_name: {
+                                "ru_doc": ru_doc,
+                                "en_doc": en_doc,
+                                "doc": method_docstring,
+                            }
+                        }
+                    )
 
-            if cmd["is_inline_handler"]:
-                inline_desc_map = {"default": cmd["doc"]}
-                inline_desc_map.update(cmd["lang_docs"])
-                
-                for k, v in info["strings"].items():
-                    if k.startswith("_ihandle_doc_") and clean_name in k and v:
-                        if k.endswith(f"_{clean_name}"):
-                            lang_part = k[len("_ihandle_doc_"):-len(f"_{clean_name}")-1]
-                            if lang_part:
-                                inline_desc_map[lang_part] = v
-                        elif k.startswith(f"_ihandle_doc_{clean_name}_"):
-                            lang_part = k[len(f"_ihandle_doc_{clean_name}_"):]
-                            if lang_part:
-                                inline_desc_map[lang_part] = v
-                
-                info["inline_handlers"].append({
-                    "name": clean_name,
-                    "description": inline_desc_map,
-                    "decorators": cmd["decorators"],
-                })
+            result = class_info
 
-        module_data = info
-        break
+    return result
 
-    return module_data
-
-def main():
-    base_dir = os.getcwd()
-    modules = {}
-    blacklisted_modules = load_blacklist("repositories.json")
-
-    for root, dirs, files in os.walk(base_dir):
-        dirs[:] = [d for d in dirs if d not in ("venv", ".venv", "env", ".env", ".git")]
+def parse_developers(base_dir: str) -> Dict[str, list]:
+    developers = {
+        "repo": set(),  # используем set внутри функции
+        "channel": set()
+    }
+    
+    for repo_url in repos:
+        repo_path = repo_url.replace("https://github.com/", "")
+        try:
+            owner, repo_name = repo_path.split("/")
+            developers["repo"].add(owner)
+        except ValueError:
+            print(f"Incorrect URL of repository: {repo_url}")
+            continue
 
+    for root, _, files in os.walk(base_dir):
         for file in files:
-            if file.endswith(".py") and not file.startswith("_") and file not in blacklisted_modules.get(os.path.relpath(root, base_dir), []):
-                path = os.path.join(root, file)
+            if file.endswith(".py"):
+                file_path = os.path.join(root, file)
                 try:
-                    data = get_module_info(path)
-                    if data:
-                        rel = os.path.relpath(path, base_dir).replace("\\", "/")
-                        modules[rel] = data
+                    module_info = get_module_info(file_path)
+                    if module_info and "meta" in module_info:
+                        developer = module_info["meta"].get('developer')
+                        if developer:  # Проверяем, что developer не None
+                            # Разделяем строки с запятыми, &, | и пробелами
+                            for dev in developer.replace(',', ' ').replace('&', ' ').replace('|', ' ').split():
+                                # Добавляем только элементы, начинающиеся с @
+                                if dev.startswith('@'):
+                                    developers["channel"].add(dev.strip())
                 except Exception as e:
-                    logger.error(f"Error processing {path}: {e}")
+                    print(f"Ошибка при парсинге файла {file_path}: {e}")
 
-    output = {
-        "modules": modules,
-        "meta": {
-            "total_modules": len(modules),
-            "generated_at": __import__("datetime").datetime.now().isoformat(),
-        }
+    # Преобразуем set в list перед возвратом
+    return {
+        "repo": list(developers["repo"]),
+        "channel": list(developers["channel"])
     }
 
-    with open("modules.json", "w", encoding="utf-8") as f:
-        json.dump(output, f, ensure_ascii=False, indent=2)
 
-    print(f"modules.json written ({len(modules)} modules)")
+modules_data = {}
+base_dir = os.getcwd()
 
-if __name__ == "__main__":
-    main()
+for root, _, files in os.walk(base_dir):
+    for file in files:
+        if file.endswith(".py"):
+            file_path = os.path.join(root, file)
+            try:
+                module_info = get_module_info(file_path)
+                if module_info:
+                    relative_path = os.path.relpath(file_path, base_dir)
+                    modules_data[relative_path] = module_info
+            except Exception as e:
+                print(f"Ошибка при парсинге файла {file_path}: {e}")
+
+developers = parse_developers(base_dir)
+
+with open("modules.json", "w", encoding="utf-8") as json_file:
+   json.dump(modules_data, json_file, ensure_ascii=False, indent=2)
+
+print("Файл modules.json создан!")
+
+with open("developers.json", "w", encoding="utf-8") as json_file:
+   json.dump(developers, json_file, ensure_ascii=False, indent=2)
+
+print("Файл developers.json создан!")

repositories.json

@@ -2,238 +2,191 @@
     "repositories": [
         {
             "path": "DziruModules/hikkamods",
-            "tags": [],
-            "blacklist": []
+            "tags": []
         },
         {
             "path": "kamolgks/Hikkamods",
-            "tags": [],
-            "blacklist": []
+            "tags": []
         },
         {
             "path": "thomasmod/hikkamods",
-            "tags": [],
-            "blacklist": []
+            "tags": []
         },
         {
             "path": "SkillsAngels/Modules",
-            "tags": [],
-            "blacklist": []
+            "tags": []
         },
         {
             "path": "Sad0ff/modules-ftg",
-            "tags": [],
-            "blacklist": []
+            "tags": []
         },
         {
             "path": "Yahikoro/Modules-for-FTG",
-            "tags": [],
-            "blacklist": []
+            "tags": []
         },
         {
             "path": "KeyZenD/modules",
-            "tags": [],
-            "blacklist": []
+            "tags": []
         },
         {
             "path": "AlpacaGang/ftg-modules",
-            "tags": [],
-            "blacklist": []
+            "tags": []
         },
         {
             "path": "trololo65/Modules",
-            "tags": [],
-            "blacklist": []
+            "tags": []
         },
         {
             "path": "Ijidishurka/modules",
-            "tags": [],
-            "blacklist": []
+            "tags": []
         },
         {
             "path": "Fl1yd/FTG-Modules",
-            "tags": [],
-            "blacklist": []
+            "tags": []
         },
         {
             "path": "D4n13l3k00/FTG-Modules",
-            "tags": [],
-            "blacklist": []
+            "tags": []
         },
         {
             "path": "iamnalinor/FTG-modules",
-            "tags": ["hikkatrusted", "nonactive"],
-            "blacklist": []
+            "tags": ["hikkatrusted", "nonactive"]
         },
         {
             "path": "SekaiYoneya/modules",
-            "tags": [],
-            "blacklist": []
+            "tags": []
         },
         {
             "path": "GeekTG/FTG-Modules",
-            "tags": [],
-            "blacklist": []
+            "tags": []
         },
         {
             "path": "Den4ikSuperOstryyPer4ik/Astro-modules",
-            "tags": ["hikkatrusted", "herokutrusted"],
-            "blacklist": []
+            "tags": ["hikkatrusted", "herokutrusted"]
         },
         {
             "path": "vsecoder/hikka_modules",
-            "tags": ["hikkatrusted", "herokutrusted"],
-            "blacklist": []
+            "tags": ["hikkatrusted", "herokutrusted"]
         },
         {
             "path": "sqlmerr/hikka_mods",
-            "tags": ["hikkatrusted", "herokutrusted"],
-            "blacklist": []
+            "tags": ["hikkatrusted", "herokutrusted"]
         },
         {
             "path": "N3rcy/modules",
-            "tags": ["hikkatrusted", "herokutrusted"],
-            "blacklist": []
+            "tags": ["hikkatrusted", "herokutrusted"]
         },
         {
             "path": "KorenbZla/HikkaModules",
-            "tags": ["hikkatrusted", "herokutrusted"],
-            "blacklist": []
+            "tags": ["hikkatrusted", "herokutrusted"]
         },
         {
             "path": "MuRuLOSE/HikkaModulesRepo",
-            "tags": [],
-            "blacklist": []
+            "tags": []
         },
         {
             "path": "coddrago/modules",
-            "tags": ["herokutrusted", "hikkatrusted"],
-            "blacklist": []
+            "tags": ["herokutrusted", "hikkatrusted"]
         },
         {
             "path": "1jpshiro/hikka-modules",
-            "tags": [],
-            "blacklist": []
+            "tags": []
         },
         {
             "path": "MoriSummerz/ftg-mods",
-            "tags": ["hikkatrusted", "nonactive"],
-            "blacklist": []
+            "tags": ["hikkatrusted", "nonactive"]
         },
         {
             "path": "anon97945/hikka-mods",
-            "tags": ["hikkatrusted", "nonactive"],
-            "blacklist": []
+            "tags": ["hikkatrusted", "nonactive"]
         },
         {
             "path": "dorotorothequickend/DorotoroModules",
-            "tags": ["hikkatrusted", "nonlongermaintained"],
-            "blacklist": []
+            "tags": ["hikkatrusted", "nonlongermaintained"]
         },
         {
             "path": "AmoreForever/amoremods",
-            "tags": [],
-            "blacklist": []
+            "tags": []
         },
         {
             "path": "idiotcoders/idiotmodules",
-            "tags": ["hikkatrusted", "herokutrusted", "nonactive"],
-            "blacklist": []
+            "tags": ["hikkatrusted", "herokutrusted", "nonactive"]
         },
         {
             "path": "CakesTwix/Hikka-Modules",
-            "tags": ["hikkatrusted", "nonactive"],
-            "blacklist": []
+            "tags": ["hikkatrusted", "nonactive"]
         },
         {
             "path": "archquise/H.Modules",
-            "tags": ["hikkatrusted", "nonactive"],
-            "blacklist": []
+            "tags": ["hikkatrusted", "nonactive"]
         },
         {
             "path": "GD-alt/mm-hikka-mods",
-            "tags": ["hikkatrusted", "herokutrusted", "nonactive"],
-            "blacklist": []
+            "tags": ["hikkatrusted", "herokutrusted", "nonactive"]
         },
         {
             "path": "HitaloSama/FTG-modules-repo",
-            "tags": [],
-            "blacklist": []
+            "tags": []
         },
         {
             "path": "SekaiYoneya/Friendly-telegram",
-            "tags": [],
-            "blacklist": []
+            "tags": []
         },
         {
             "path": "blazedzn/ftg-modules",
-            "tags": [],
-            "blacklist": []
+            "tags": []
         },
         {
             "path": "hikariatama/ftg",
-            "tags": ["hikkatrusted", "nonactive"],
-            "blacklist": []
+            "tags": ["hikkatrusted", "nonactive"]
         },
         {
             "path": "m4xx1m/FTG",
-            "tags": [],
-            "blacklist": []
+            "tags": []
         },
         {
             "path": "skillzmeow/skillzmods_hikka",
-            "tags": [],
-            "blacklist": []
+            "tags": []
         },
         {
             "path": "fajox1/famods",
-            "tags": ["hikkatrusted", "herokutrusted"],
-            "blacklist": []
+            "tags": ["hikkatrusted", "herokutrusted"]
         },
         {
             "path": "TheKsenon/MyHikkaModules",
-            "tags": ["hikkatrusted", "herokutrusted"],
-            "blacklist": []
+            "tags": ["hikkatrusted", "herokutrusted"]
         },
         {
             "path": "cryptexctl/modules-mirror",
-            "tags": [],
-            "blacklist": []
+            "tags": []
         },
         {
             "path": "Ruslan-Isaev/modules",
-            "tags": ["herokutrusted"],
-            "blacklist": []
+            "tags": ["herokutrusted"]
         },
         {
             "path": "shadowhikka/sh.modules",
-            "tags": [],
-            "blacklist": []
+            "tags": []
         },
         {
             "path": "fiksofficial/python-modules",
-            "tags": ["herokutrusted"],
-            "blacklist": []
+            "tags": ["herokutrusted"]
         },
         {
             "path": "mead0wsss/mead0wsMods",
-            "tags": ["herokutrusted"],
-            "blacklist": []
+            "tags": ["herokutrusted"]
         },
         {
             "path": "SenkoGuardian/SenModules",
-            "tags": ["herokutrusted"],
-            "blacklist": []
+            "tags": ["herokutrusted"]
         },
         {
             "path": "ZetGoHack/nullmod",
-            "tags": ["herokutrusted"],
-            "blacklist": []
+            "tags": ["herokutrusted"]
         },
         {
             "path": "yummy1gay/limoka",
-            "tags": [],
-            "blacklist": []
+            "tags": []
         }
     ]
 }

update_diffs.py

@@ -1,193 +0,0 @@
-import asyncio
-import aiohttp
-import argparse
-import subprocess
-import os
-import tempfile
-from pathlib import Path
-
-
-parser = argparse.ArgumentParser(description="Update Diffs Script")
-parser.add_argument(
-    "--token",
-    type=str,
-    required=True,
-    help="Token of Telegram bot",
-)
-parser.add_argument(
-    "--api_url",
-    type=str,
-    default="https://api.telegram.org",
-    help="API URL of Telegram API",
-)
-parser.add_argument(
-    "--chat_id",
-    type=str,
-    required=True,
-    help="Chat ID to send updates to",
-)
-parser.add_argument(
-    "--base_commit",
-    type=str,
-    default="HEAD~1",
-    help="Base commit to compare against",
-)
-
-arguments = parser.parse_args()
-
-async def send_message(session, text):
-    """Send a text message to the channel"""
-    url = f"{arguments.api_url}/bot{arguments.token}/sendMessage"
-    data = {
-        'chat_id': arguments.chat_id,
-        'text': text,
-        'parse_mode': 'Markdown',
-    }
-    async with session.post(url, data=data) as response:
-        return await response.json()
-
-async def send_document(session, file_path, caption=None):
-    """Send a document to the channel"""
-    url = f"{arguments.api_url}/bot{arguments.token}/sendDocument"
-    with open(file_path, 'rb') as f:
-        data = aiohttp.FormData()
-        data.add_field('chat_id', arguments.chat_id)
-        data.add_field('document', f, filename=os.path.basename(file_path))
-        if caption:
-            data.add_field('caption', caption)
-            data.add_field('parse_mode', 'Markdown')
-        async with session.post(url, data=data) as response:
-            return await response.json()
-
-def get_changed_files(base_commit):
-    """Get list of changed files between commits"""
-    try:
-        result = subprocess.check_output(
-            ['git', 'diff', '--name-only', base_commit, 'HEAD'],
-            cwd=os.getcwd()
-        ).decode().strip().split('\n')
-        return [f for f in result if f]
-    except subprocess.CalledProcessError:
-        return []
-
-def get_file_diff(file_path, base_commit):
-    """Get diff for a specific file"""
-    try:
-        diff = subprocess.check_output(
-            ['git', 'diff', base_commit, 'HEAD', '--', file_path],
-            cwd=os.getcwd()
-        ).decode()
-        return diff
-    except subprocess.CalledProcessError:
-        return ""
-
-def is_module_file(file_path):
-    """Check if file is a Python module in a modules directory"""
-    # Check if it's a .py file and in a modules-like directory
-    return file_path.endswith('.py') and any(
-        part in file_path.lower() for part in [
-            'modules', 'mods', 'ftg', 'hikka'
-        ]
-    )
-
-def extract_module_name(file_path):
-    """Extract module name from file path"""
-    return Path(file_path).stem
-
-async def main():
-    changed_files = get_changed_files(arguments.base_commit)
-    
-    if not changed_files:
-        print("No changes detected")
-        return
-    
-    # Filter for module files only
-    module_files = [f for f in changed_files if is_module_file(f)]
-    
-    if not module_files:
-        print("No module changes detected")
-        return
-    
-    async with aiohttp.ClientSession() as session:
-        for file_path in module_files:
-            try:
-                module_name = extract_module_name(file_path)
-                
-                # Create message with raw GitHub URL
-                github_url = f"https://raw.githubusercontent.com/MuRuLOSE/limoka/refs/heads/main/{file_path}"
-                try:
-                    new_hash = subprocess.check_output(
-                        ['git', 'rev-list', '-n', '1', 'HEAD', '--', file_path],
-                        cwd=os.getcwd()
-                    ).decode().strip()
-                except Exception:
-                    new_hash = 'HEAD'
-
-                try:
-                    old_hash = subprocess.check_output(
-                        ['git', 'rev-list', '-n', '1', arguments.base_commit, '--', file_path],
-                        cwd=os.getcwd()
-                    ).decode().strip()
-                except Exception:
-                    old_hash = arguments.base_commit
-
-                diff_url = f"https://github.com/MuRuLOSE/limoka/compare/{old_hash}...{new_hash}.diff"
-                message = (
-                    f"🪼 Module {module_name} changes approved\n\n"
-                    f"[File URL]({github_url}) | [Diff URL]({diff_url})\n\n"
-                )
-                
-                # Get diff
-                diff = get_file_diff(file_path, arguments.base_commit)
-                
-                if not diff:
-                    print(f"Skipping {file_path} - no diff content")
-                    continue
-                
-                # Create temporary file with diff using only module name
-                diff_filename = f"{module_name}.diff"
-                with tempfile.NamedTemporaryFile(
-                    mode='w',
-                    suffix='',
-                    prefix='',
-                    delete=False,
-                    encoding='utf-8',
-                    dir=tempfile.gettempdir()
-                ) as tmp_file:
-                    tmp_file.write(diff)
-                    tmp_file_path = tmp_file.name
-                
-                try:
-                    # Rename temp file to have proper name
-                    final_path = os.path.join(tempfile.gettempdir(), diff_filename)
-                    os.rename(tmp_file_path, final_path)
-                    
-                    # Send diff as document with full message as caption
-                    doc_result = await send_document(
-                        session,
-                        final_path,
-                        caption=message
-                    )
-                    print(f"Sent diff for {module_name}: {doc_result}")
-                    
-                except Exception as e:
-                    print(f"Error sending {module_name}: {e}")
-                finally:
-                    # Cleanup temp files
-                    if os.path.exists(tmp_file_path):
-                        try:
-                            os.remove(tmp_file_path)
-                        except:
-                            pass
-                    final_path = os.path.join(tempfile.gettempdir(), diff_filename)
-                    if os.path.exists(final_path):
-                        try:
-                            os.remove(final_path)
-                        except:
-                            pass
-            
-            except Exception as e:
-                print(f"Error processing {file_path}: {e}")
-
-if __name__ == "__main__":
-    asyncio.run(main())