lyrpy 2024.0.4__py3-none-any.whl → 2025.0.1__py3-none-any.whl

SRC/LIB/lyrpy/LUTelegram.py

@@ -0,0 +1,428 @@
+"""LUTelegram.py"""
+# -*- coding: UTF-8 -*-
+__annotations__ = """
+ =======================================================
+ Copyright (c) 2025
+ Author:
+     Lisitsin Y.R.
+ Project:
+     lyrpy
+     
+ Module:
+     LUTelegram.py
+
+ =======================================================
+"""
+
+from fontTools.misc.cython import returns
+#------------------------------------------
+# БИБЛИОТЕКИ python
+#------------------------------------------
+
+#------------------------------------------
+# БИБЛИОТЕКИ сторонние
+#------------------------------------------
+
+#------------------------------------------
+# БИБЛИОТЕКА telethon
+#------------------------------------------
+# import telethon
+import telethon.sync
+import telethon.tl.types
+
+from telethon.sync import TelegramClient
+from telethon.tl.types import PeerUser, PeerChat, PeerChannel
+import re
+import asyncio
+
+# from telethon.tl.functions.messages import GetDialogsRequest
+# from telethon.tl.types import InputPeerEmpty
+# from telethon.tl.types import User
+# # класс, позволяющий нам подключаться к клиенту мессенджера и работать с ним;
+# from telethon.sync import TelegramClient
+# # PeerChannel - специальный тип, определяющий объекты типа «канал/чат»,
+# # с помощью которого можно обратиться к нужному каналу для парсинга сообщений.
+# from telethon.tl.types import Channel, PeerChannel, PeerChat, PeerUser, Message, User, MessageMediaPhoto, MessageMediaDocument
+# # конструктор для работы с InputPeer, который передаётся в качестве аргумента в GetDialogsRequest;
+# from telethon.tl.types import InputMessagesFilterPhotos
+# # функция, позволяющая работать с сообщениями в чате;
+# # метод, позволяющий получить сообщения пользователей из чата и работать с ним;
+# from telethon.tl.functions.messages import GetHistoryRequest
+# from telethon import TelegramClient, events, sync
+# import telethon.errors
+# import telethon.client.messages as messages
+#------------------------------------------
+# БИБЛИОТЕКА pyrogram
+#------------------------------------------
+# from pyrogram import Client
+import pyrogram
+
+#------------------------------------------
+# БИБЛИОТЕКИ LU
+#------------------------------------------
+
+LIB_name = ''
+
+# ------------------------------------------
+# Авторизация в Telegram
+# get_telethon_client (session_name, api_id, api_hash, phone, password) -> telethon.sync.TelegramClient:
+# ------------------------------------------
+def get_telethon_client (session_name, api_id, api_hash, phone, password) -> telethon.sync.TelegramClient:
+    """get_telethon_client"""
+# beginfunction
+    result = telethon.sync.TelegramClient(session_name, api_id, api_hash, system_version="4.16.30-vxNAME ")
+    #   Вместо NAME используйте любое сочетание букв на английском КАПСОМ Пример: vxXYI, vxABC, vxMYNAME
+    #   # (в папке с кодом нет файлика .session, клиент сам его создаст (в нашем случае 'my_session')
+    #   # и будет с ним работать. Поэтому просто вставляем эти параметры в инициализацию и кайфуем:finger_up: )
+
+    # Tclient = TelegramClient (Gsession_name, Gapi_id, Gapi_hash,
+    #                           #         device_model = "iPhone 13 Pro Max",
+    #                           #         app_version = "8.4",
+    #                           #         lang_code = "en",
+    #                           #         system_lang_code = "en-US")
+    #                           system_version='4.16.30-vxABC')
+    # Tclient.start (phone=Gphone, password=Gpassword)
+    result.start (phone=phone, password=password)
+    result.connect ()
+    # print (f'{LIB_name}_user_authorized={result.is_user_authorized()}')
+    return result
+# endfunction
+
+# ------------------------------------------
+# Получить the current User who is logged
+# get_telethon_me (client:telethon.sync.TelegramClient) -> telethon.tl.types.User:
+# ------------------------------------------
+def get_telethon_me (client:telethon.sync.TelegramClient) -> telethon.tl.types.User:
+    """get_telethon_me"""
+# beginfunction
+    result:User = client.get_me ()
+
+    # print (f'{LIB_name}_username={result.username}')
+    # print (f'{LIB_name}_phone={result.phone}')
+
+    # print (f'{LIB_name}_stringify={result.stringify()}')
+    return result
+# endfunction
+
+# ------------------------------------------
+# Получить channel
+# get_telethon_channel (client:telethon.sync.TelegramClient, channel_name_id) -> telethon.tl.types.Channel:
+# ------------------------------------------
+def get_telethon_channel (client:telethon.sync.TelegramClient, channel_name_id) -> telethon.tl.types.Channel:
+    """get_telethon_channel"""
+# beginfunction
+    result = client.get_entity (channel_name_id)
+    # print (result)
+    # print(f'{LIB_name}_Channel.title={result.title}')
+    # print(f'{LIB_name}_Channel.id={result.id}')
+    # print(f'{LIB_name}_Channel.username={result.id}')
+    return result
+# endfunction
+
+# ------------------------------------------
+# Получить message
+# get_telethon_message (client:telethon.sync.TelegramClient, channel:telethon.tl.types.Channel, message_id) -> telethon.tl.types.Message:
+# ------------------------------------------
+def get_telethon_message (client:telethon.sync.TelegramClient, channel:telethon.tl.types.Channel, message_id) -> telethon.tl.types.Message:
+    """get_telethon_message"""
+# beginfunction
+    try:
+        result = client.get_messages (channel.id, ids=message_id)
+        # print(f'{LIB_name}_Message={result}')
+    except:
+        result = None
+
+    return result
+# endfunction
+
+#------------------------------------------
+# Получить мои группы
+# get_telethon_mygroups (client:TelegramClient):
+#------------------------------------------
+def get_telethon_mygroups (client:telethon.sync.TelegramClient):
+    """get_telethon_mygroups"""
+#beginfunction
+    # Получение списка диалогов
+    dialogs = client.get_dialogs()
+    # Отображение списка групп
+    for dialog in dialogs:
+        if dialog.is_group:
+            print(f"{LIB_name}_Группа: {dialog.title} (ID: {dialog.id})")
+#endfunction
+
+#------------------------------------------
+# Получить список groups
+#------------------------------------------
+def get_telethon_groups (client:telethon.sync.TelegramClient) -> list:
+    """get_telethon_groups"""
+#beginfunction
+    chats = []
+    last_date = None
+    size_chats = 200
+    groups = []
+
+    # -----------------------------------------------
+    # Напишем запрос для получения списка групп
+    # -----------------------------------------------
+    # offset_date и offset_peer мы передаём с пустыми значениями.
+    # Обычно они используются для фильтрации полученных данных, но здесь мы
+    # хотим получить весь список. Лимит по количеству элементов в ответе задаём 200,
+    # передавая в параметр limit переменную size_chats.
+    result = client (telethon.tl.functions.messages.GetDialogsRequest (
+        offset_date=last_date,
+        offset_id=0,
+        offset_peer=telethon.tl.types.InputPeerEmpty (),
+        limit=size_chats,
+        hash=0
+    ))
+    chats.extend (result.chats)
+
+    # -----------------------------------------------
+    #
+    # -----------------------------------------------
+    for chat in chats:
+        try:
+            # print (int(chat.megagroup), chat.title)
+
+            # Megagroup в библиотеке Telethon — это свойство объекта Channel,
+            # которое указывает, является ли он мегагруппой (большой группой).
+            # Мегагруппы — это каналы, для которых значение свойства channel.megagroup равно True.
+            # В официальных приложениях Telegram такие группы называются «супергруппами»
+
+            if chat.megagroup == True:
+                groups.append (chat)
+        except:
+            continue
+    return groups
+
+#endfunction
+
+#------------------------------------------
+# Получить список groups
+#------------------------------------------
+def get_telethon_groups (client:telethon.sync.TelegramClient) -> list:
+    """get_telethon_groups"""
+#beginfunction
+    chats = []
+    last_date = None
+    size_chats = 200
+    groups = []
+
+    # -----------------------------------------------
+    # Напишем запрос для получения списка групп
+    # -----------------------------------------------
+    # offset_date и offset_peer мы передаём с пустыми значениями.
+    # Обычно они используются для фильтрации полученных данных, но здесь мы
+    # хотим получить весь список. Лимит по количеству элементов в ответе задаём 200,
+    # передавая в параметр limit переменную size_chats.
+    result = client (telethon.tl.functions.messages.GetDialogsRequest (
+        offset_date=last_date,
+        offset_id=0,
+        offset_peer=telethon.tl.types.InputPeerEmpty (),
+        limit=size_chats,
+        hash=0
+    ))
+    chats.extend (result.chats)
+    # -----------------------------------------------
+    #
+    # -----------------------------------------------
+    for chat in chats:
+        try:
+            # print (int(chat.megagroup), chat.title)
+            # Megagroup в библиотеке Telethon — это свойство объекта Channel,
+            # которое указывает, является ли он мегагруппой (большой группой).
+            # Мегагруппы — это каналы, для которых значение свойства channel.megagroup равно True.
+            # В официальных приложениях Telegram такие группы называются «супергруппами»
+            if chat.megagroup == True:
+                groups.append (chat)
+            else:
+                # groups.append (chat)
+                pass
+        except:
+            continue
+    return groups
+#endfunction
+
+#------------------------------------------
+# Получить список users group
+#------------------------------------------
+def get_telethon_users_group (client:telethon.sync.TelegramClient, group) -> list:
+    """get_telethon_users_group"""
+#beginfunction
+    #-----------------------------------------------
+    # Узнаём пользователей...
+    #-----------------------------------------------
+    all_participants = []
+    try:
+        all_participants = client.get_participants (group, limit=100000)
+        # print (group)
+        # for user in all_participants:
+        #     if user.username:
+        #         username = user.username
+        #     else:
+        #         username = ""
+        #     if user.first_name:
+        #         first_name = user.first_name
+        #     else:
+        #         first_name = ""
+        #     if user.last_name:
+        #         last_name = user.last_name
+        #     else:
+        #         last_name = ""
+        #     name = (first_name + ' ' + last_name).strip ()
+        #     print(f'{username=}, {name=}, {target_group.title=}')
+    except:
+        pass
+    return all_participants
+#endfunction
+
+#------------------------------------------
+# Получить список CHATs
+#------------------------------------------
+def get_telethon_CHATs (client:telethon.sync.TelegramClient):
+    """get_telethon_CHATs"""
+#beginfunction
+    # понять, канал или чат, можно проверяя у диалога параметр "dialog.entity.megagroup
+    for dialog in client.iter_dialogs ():
+        if 'Channel' in str (type (dialog.entity)):  # откидываем юзеров
+            if dialog.entity.megagroup:
+                print (dialog.entity.id, '//', dialog.entity.username,
+                       ' - ', dialog.name, ' is CHAT')
+#endfunction
+
+#------------------------------------------
+# Получить список CHANNELs
+#------------------------------------------
+def get_telethon_CHANNELs (client:telethon.sync.TelegramClient):
+    """get_telethon_CHANNELs"""
+#beginfunction
+    # понять, канал или чат, можно проверяя у диалога параметр "dialog.entity.megagroup
+    for dialog in client.iter_dialogs ():
+        if 'Channel' in str (type (dialog.entity)):  # откидываем юзеров
+            if not dialog.entity.megagroup:
+                print (dialog.entity.id, '//', dialog.entity.username,
+                       ' - ', dialog.name, ' is CHANNEL')
+#endfunction
+
+# ----------------------------------------------
+# Получаем последние 10 сообщений из указанного чата
+# ----------------------------------------------
+def get_telethon_chat (client:telethon.sync.TelegramClient, chat_id):
+    """get_telethon_chat"""
+#beginfunction
+    # ID чата/канала/пользователя, откуда читать сообщения
+    # chat_id = '@GardeZ66'  # или ID (число), или юзернейм (например, '@telegram')
+    for message in client.iter_messages (chat_id, limit=10):
+        print (f"{LIB_name}_message.sender_id:{message.sender_id}: {message.text}")
+#endfunction
+
+
+
+# ----------------------------------------------
+# Функция для парсинга ссылки
+# ----------------------------------------------
+def parse_message_link (link):
+    """parse_message_link"""
+#beginfunction
+    pattern = r'https?://t\.me/([a-zA-Z0-9\_]+|c/(\d+))/(\d+)/(\d+)'
+    match = re.match (pattern, link)
+    if not match:
+        raise ValueError ("Invalid link")
+
+    # print(f'{match.group (1)=}')
+    # print(f'{match.group (2)=}')
+    # print(f'{match.group (3)=}')
+    # print(f'{match.group (4)=}')
+
+    if match.group (1).startswith ('c'):
+        channel_id = int (match.group (3))
+        msg_id = int (match.group (3))
+        return {'channel_id': channel_id, 'msg_id': msg_id}
+    else:
+        username = match.group (1)
+        msg_id = int (match.group (3))
+        return {'username': username, 'msg_id': msg_id}
+#endfunction
+
+# ----------------------------------------------
+# async def get_channel_name (link, TelegramClient):
+# ----------------------------------------------
+def get_channel_name (link, session_name, api_id, api_hash, phone):
+    """get_channel_name"""
+#beginfunction
+    with TelegramClient (session_name, api_id, api_hash) as client:
+        client.start (phone)
+        # print (f'{link=}')
+        parsed = parse_message_link (link)
+        print (f'{parsed=}')
+
+        if 'username' in parsed:
+            entity = client.get_entity (parsed ['username'])
+            # entity = client.get_entity (parsed ['msg_id'])
+        elif 'channel_id' in parsed:
+            entity = client.get_entity (PeerChannel (parsed ['channel_id']))
+        else:
+            raise ValueError ("Could not resolve entity")
+        print (f"Название канала: {entity.title}")
+
+    # client.disconnect ()
+
+    return entity.title
+#endfunction
+
+
+
+
+
+
+
+
+# ------------------------------------------
+# Авторизация в Telegram [pyrogram]
+# ------------------------------------------
+def get_pyrogram_client (api_id, api_hash, login, phone) -> pyrogram.Client:
+    """get_pyrogram_client"""
+# beginfunction
+    result = pyrogram.Client (login, api_id=api_id, api_hash=api_hash, phone_number=phone)
+    result.start ()
+    # result.connect ()
+    # print (f'{LIB_name}_is_connected={result.is_connected}')
+
+    # print(Tclient.export_session_string())
+    # print(result.workdir)
+
+    # result.run ()
+    return result
+# endfunction
+
+# ------------------------------------------
+# Метод client.get_me() в библиотеке Pyrogram возвращает объект pyrogram.User
+# с информацией о текущем зарегистрированном пользователе или боте.
+# ------------------------------------------
+def get_pyrogram_me (client:pyrogram.Client) -> pyrogram.types.User:
+    """get_pyrogram_me"""
+# beginfunction
+    result = client.get_me()
+    # print (f'{LIB_name}_username={result.username}')
+    # print (f'{LIB_name}_phone_number={result.phone_number}')
+    # print (f'pyrogram:stringify={result.stringify()}')
+    return result
+# endfunction
+
+#---------------------------------------------------------
+# main
+#---------------------------------------------------------
+def main ():
+#beginfunction
+    pass
+#endfunction
+
+#---------------------------------------------------------
+#
+#---------------------------------------------------------
+#beginmodule
+if __name__ == "__main__":
+    main()
+#endif
+
+#endmodule

{lyrpy → SRC/LIB/lyrpy}/LUThread.py

@@ -18,6 +18,7 @@ __annotations__ = """
 # БИБЛИОТЕКИ python
 #------------------------------------------
 import threading
+import logging
 
 #------------------------------------------
 # БИБЛИОТЕКИ сторонние
@@ -26,7 +27,7 @@ import threading
 #------------------------------------------
 # БИБЛИОТЕКА LU
 #------------------------------------------
-import lyr.LULog as LULog
+import lyrpy.LULog as LULog
 
 # class ScheduleThread (threading.Thread):
 #     @classmethod
@@ -90,7 +91,7 @@ class TThread (threading.Thread):
         """destructor"""
     #beginfunction
         LClassName = self.__class__.__name__
-        s = '{} уничтожен'.format (LClassName)
+        # s = '{} уничтожен'.format (LClassName)
         # LULog.LoggerTOOLS_AddLevel (LULog.DEBUGTEXT, s)
         #print (s)
     #endfunction
@@ -124,10 +125,10 @@ class TThread (threading.Thread):
         """run - Запуск потока"""
     #beginfunction
         s = 'run - Запуск потока...'
-        LULog.LoggerTOOLS_AddDebug (s)
+        LULog.LoggerAdd (LULog.LoggerTOOLS, logging.DEBUG, s)
         super ().run()
         while not self.__FStopThread:
-            s = 'Выполнение потока...'
+            # s = 'Выполнение потока...'
             # LULog.LoggerTOOLS_AddDebug (s)
             continue
         #endwhile
@@ -140,7 +141,7 @@ class TThread (threading.Thread):
         """StartThread"""
     #beginfunction
         s = 'StartThread...'
-        LULog.LoggerTOOLS_AddDebug (s)
+        LULog.LoggerAdd (LULog.LoggerTOOLS, logging.DEBUG, s)
         self.__FStopThread = False
         self.run()
     #endfunction
@@ -151,7 +152,7 @@ class TThread (threading.Thread):
         """StopThread"""
     #beginfunction
         s = 'StopThread...'
-        LULog.LoggerTOOLS_AddDebug (s)
+        LULog.LoggerAdd (LULog.LoggerTOOLS, logging.DEBUG, s)
         self.__FStopThread = True
     #endfunction
 

{lyrpy → SRC/LIB/lyrpy}/LUTimer.py

@@ -18,6 +18,7 @@ __annotations__ = """
 # БИБЛИОТЕКИ python
 #------------------------------------------
 import threading
+import logging
 
 #------------------------------------------
 # БИБЛИОТЕКИ сторонние
@@ -26,6 +27,7 @@ import threading
 #------------------------------------------
 # БИБЛИОТЕКА LU
 #------------------------------------------
+import lyrpy.LULog as LULog
 
 # Create the Worker Thread
 class TTimer (threading.Timer):
@@ -60,7 +62,7 @@ class TTimer (threading.Timer):
         """destructor"""
     #beginfunction
         LClassName = self.__class__.__name__
-        s = '{} уничтожен'.format (LClassName)
+        # s = '{} уничтожен'.format (LClassName)
         # LULog.LoggerTOOLS_AddLevel (LULog.DEBUGTEXT, s)
         #print (s)
     #endfunction
@@ -94,13 +96,13 @@ class TTimer (threading.Timer):
         """run - Запуск таймера"""
     #beginfunction
         s = 'run - Запуск таймера...'
-        LULog.LoggerTOOLS_AddDebug (s)
+        LULog.LoggerAdd (LULog.LoggerTOOLS, logging.DEBUG, s)
         # super ().run()
 
         # self.Function()
 
         while not self.__FStopTimer:
-            s = 'Выполнение таймера...'
+            # s = 'Выполнение таймера...'
             # LULog.LoggerTOOLS_AddDebug (s)
             continue
         #endwhile

{lyrpy → SRC/LIB/lyrpy}/LUVersion.py

@@ -24,6 +24,9 @@ import platform
 #------------------------------------------
 import datetime
 
+import win32api
+
+
 # if platform.system() == 'Windows':
 #     import win32api
 #     import win32con
@@ -71,7 +74,7 @@ class TVersionInfo:
     def __del__(self):
     #beginfunction
         LClassName = self.__class__.__name__
-        s = '{} уничтожен'.format (LClassName)
+        # s = '{} уничтожен'.format (LClassName)
         #print (s)
     #endfunction
 

{lyrpy → SRC/LIB/lyrpy}/LUYouTube.py

@@ -26,9 +26,8 @@ import sys
 #------------------------------------------
 # БИБЛИОТЕКИ LU
 #------------------------------------------
-# import LUObjectsYT
-# import LUFile
-import lyr
+import lyrpy.LUObjectsYT as LUObjectsYT
+import lyrpy.LUFile as LUFile
 
 # --------------------------------------------
 # TYouTubeObjectsItem
@@ -53,7 +52,7 @@ class TYouTubeObjectsItem (object):
         # удалить объект
         del self.__FYouTubeObject
         LClassName = self.__class__.__name__
-        s = '{} уничтожен'.format (LClassName)
+        # s = '{} уничтожен'.format (LClassName)
         # LULog.LoggerTOOLS_AddLevel (LULog.DEBUGTEXT, s)
     #endfunction
 
@@ -67,7 +66,7 @@ class TYouTubeObjectsItem (object):
         return self.__FYouTubeObject
     #endfunction
     @YouTubeObject.setter
-    def YouTubeObject(self, Value: lyr.LUObjectsYT.TYouTubeObject):
+    def YouTubeObject(self, Value: LUObjectsYT.TYouTubeObject):
     #beginfunction
         self.__FYouTubeObject = Value
     #endfunction
@@ -98,7 +97,7 @@ class TYouTubeObjectsCollection (list):
     #beginfunction
         self.clear()            # удалить все items
         LClassName = self.__class__.__name__
-        s = '{} уничтожен'.format (LClassName)
+        # s = '{} уничтожен'.format (LClassName)
         # LULog.LoggerTOOLS_AddLevel (LULog.DEBUGTEXT, s)
     #endfunction
 
@@ -169,7 +168,7 @@ class TYouTube(object):
     #beginfunction
         del self.__FYouTubeObjectsCollection
         LClassName = self.__class__.__name__
-        s = '{} уничтожен'.format (LClassName)
+        # s = '{} уничтожен'.format (LClassName)
         # LULog.LoggerTOOLS_AddLevel (LULog.DEBUGTEXT, s)
         #print (s)
     #endfunction

{lyrpy → SRC/LIB/lyrpy}/LUos.py

@@ -22,7 +22,7 @@ import sys
 import enum
 import ctypes
 import datetime
-import logging
+import subprocess
 
 """
 Кроссплатформенные функции:
@@ -177,7 +177,7 @@ class TFolders (object):
         """ destructor """
     #beginfunction
         LClassName = self.__class__.__name__
-        s = '{} уничтожен'.format(LClassName)
+        # s = '{} уничтожен'.format(LClassName)
         # LULog.LoggerTOOLS_AddLevel (LULog.DEBUGTEXT, s)
         #print (s)
     #endfunction
@@ -420,7 +420,7 @@ class TOSInfo (object):
         """ destructor """
     #beginfunction
         LClassName = self.__class__.__name__
-        s = '{} уничтожен'.format(LClassName)
+        # s = '{} уничтожен'.format(LClassName)
         #LUConst.LULogger.log (LULog.DEBUGTEXT, s)
     #endfunction
 
@@ -773,6 +773,16 @@ def PrintGeneralTitle ():
     print ('===========================================')
 #endfunction
 
+#------------------------------------------
+# Exec_dir ():
+#------------------------------------------
+def Exec_dir ():
+#beginfunction
+    # Пример: Выполнение команды dir и получение вывода
+    result = subprocess.run(["dir"], shell=True, capture_output=True, text=True)
+    print(result.stdout)  # Вывод команды
+#endfunction
+
 #------------------------------------------------------
 # main
 #------------------------------------------------------

{lyrpy → SRC/LIB/lyrpy}/__init__.py

@@ -1,13 +1,13 @@
 import os
 
-from typing import IO, TYPE_CHECKING, Any, Callable, Optional, Union
+print("import lyrpy")
 
 #-------------------------------------------------------------------------------
 #
 #-------------------------------------------------------------------------------
 def main ():
 #beginfunction
-    print("Hello, **World**")
+    print("Hello, **lyrpy**")
 #endfunction
 
 #------------------------------------------

{lyrpy → SRC/LIB/lyrpy}/__main__.py

@@ -1,19 +1,20 @@
-import io
-
-#-------------------------------------------------------------------------------
-#
-#-------------------------------------------------------------------------------
-def main ():
-#beginfunction
-    print("Hello, **World**")
-#endfunction
-
-#------------------------------------------
-#
-#------------------------------------------
-#beginmodule
-if __name__ == "__main__":
-    main()
-#endif
-
-#endmodule
+import io
+from pathlib import Path
+
+#-------------------------------------------------------------------------------
+#
+#-------------------------------------------------------------------------------
+def main ():
+#beginfunction
+    print("Hello, **World**")
+#endfunction
+
+#------------------------------------------
+#
+#------------------------------------------
+#beginmodule
+if __name__ == "__main__":
+    main()
+#endif
+
+#endmodule