devhubsesion 0.1.0__tar.gz

devhubsesion-0.1.0/NOTICE

@@ -0,0 +1,4 @@
+devhubsesion
+Copyright 2026 Astrea
+
+Uses Telethon (https://github.com/LonamiWebs/Telethon), MIT License.

devhubsesion-0.1.0/PKG-INFO

@@ -0,0 +1,58 @@
+Metadata-Version: 2.4
+Name: devhubsesion
+Version: 0.1.0
+Summary: Telegram account manager with session strings
+Author: Astrea
+License: Apache-2.0
+Project-URL: Homepage, https://github.com/TheDevHubpro/devhubsesion
+Project-URL: Repository, https://github.com/TheDevHubpro/devhubsesion
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: NOTICE
+Requires-Dist: telethon>=1.34
+Requires-Dist: nest-asyncio>=1.6
+Dynamic: license-file
+
+# devhubsesion
+
+Telegram account manager with session strings. No Telethon code needed.
+
+## install
+
+    pip install devhubsesion
+
+## usage
+
+    from devhubsesion import DevHubSession
+
+    with DevHubSession(session_string="...", api_id=123, api_hash="abc") as tg:
+        for c in tg.list_private_chats():
+            print(c["name"], c["id"])
+
+or from .env:
+
+    from devhubsesion import DevHubSession
+
+    with DevHubSession.from_env() as tg:
+        print(tg.list_private_chats())
+
+## methods
+
+- list_private_chats
+- list_groups_channels
+- dump_history(user, limit, save)
+- last_message(user)
+- backup_voices(user=None)
+- backup_photos(user=None)
+- backup_full()
+- watch(user=None, callback=None)
+- list_contacts()
+- extract_numbers(limit_per_chat, save)
+- list_active_sessions()
+- change_bio(text)
+- change_name(first, last)
+- send_message(user, text)
+
+## license
+
+Apache-2.0

devhubsesion-0.1.0/README.md

@@ -0,0 +1,43 @@
+# devhubsesion
+
+Telegram account manager with session strings. No Telethon code needed.
+
+## install
+
+    pip install devhubsesion
+
+## usage
+
+    from devhubsesion import DevHubSession
+
+    with DevHubSession(session_string="...", api_id=123, api_hash="abc") as tg:
+        for c in tg.list_private_chats():
+            print(c["name"], c["id"])
+
+or from .env:
+
+    from devhubsesion import DevHubSession
+
+    with DevHubSession.from_env() as tg:
+        print(tg.list_private_chats())
+
+## methods
+
+- list_private_chats
+- list_groups_channels
+- dump_history(user, limit, save)
+- last_message(user)
+- backup_voices(user=None)
+- backup_photos(user=None)
+- backup_full()
+- watch(user=None, callback=None)
+- list_contacts()
+- extract_numbers(limit_per_chat, save)
+- list_active_sessions()
+- change_bio(text)
+- change_name(first, last)
+- send_message(user, text)
+
+## license
+
+Apache-2.0

devhubsesion-0.1.0/pyproject.toml

@@ -0,0 +1,20 @@
+[build-system]
+requires = ["setuptools>=61", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "devhubsesion"
+version = "0.1.0"
+description = "Telegram account manager with session strings"
+readme = "README.md"
+license = {text = "Apache-2.0"}
+authors = [{name = "Astrea"}]
+requires-python = ">=3.9"
+dependencies = ["telethon>=1.34", "nest-asyncio>=1.6"]
+
+[project.urls]
+Homepage = "https://github.com/TheDevHubpro/devhubsesion"
+Repository = "https://github.com/TheDevHubpro/devhubsesion"
+
+[tool.setuptools.packages.find]
+where = ["src"]

devhubsesion-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

devhubsesion-0.1.0/src/devhubsesion/__init__.py

@@ -0,0 +1,5 @@
+from .client import DevHubSession
+from .exceptions import DevHubError, NotConnectedError, SessionError
+
+__all__ = ["DevHubSession", "DevHubError", "NotConnectedError", "SessionError"]
+__version__ = "0.1.0"

devhubsesion-0.1.0/src/devhubsesion/account.py

@@ -0,0 +1,24 @@
+from telethon.tl.functions.account import GetAuthorizationsRequest
+
+
+async def list_active_sessions(client):
+    r = await client(GetAuthorizationsRequest())
+    out = []
+    for a in r.authorizations:
+        out.append({
+            "device": a.device_model,
+            "ip": a.ip,
+            "country": a.country,
+            "current": bool(getattr(a, "current", False)),
+        })
+    return out
+
+
+async def change_bio(client, new_bio):
+    await client.edit_about(about=new_bio)
+    return {"ok": True, "bio": new_bio}
+
+
+async def change_name(client, first, last=""):
+    await client.edit_profile(first_name=first, last_name=last)
+    return {"ok": True, "first": first, "last": last}

devhubsesion-0.1.0/src/devhubsesion/backup.py

@@ -0,0 +1,71 @@
+import os
+from .utils import clean, mkdir, now
+
+
+async def _targets(client, user):
+    if user is not None:
+        return [await client.get_entity(user)]
+    me = await client.get_me()
+    out = []
+    async for d in client.iter_dialogs():
+        if d.is_user and d.entity.id != me.id:
+            out.append(d.entity)
+    return out
+
+
+async def backup_voices(client, user, save_path):
+    root = mkdir(os.path.join(save_path, f"voices_{now()}"))
+    total = 0
+    for e in await _targets(client, user):
+        n = clean(getattr(e, "first_name", None) or "chat")
+        folder = mkdir(os.path.join(root, f"{n}_{e.id}"))
+        c = 0
+        try:
+            async for m in client.iter_messages(e, limit=500):
+                if m.voice:
+                    c += 1
+                    await client.download_media(m, os.path.join(folder, f"{c}.ogg"))
+        except Exception:
+            continue
+        total += c
+    return {"folder": root, "total": total}
+
+
+async def backup_photos(client, user, save_path):
+    root = mkdir(os.path.join(save_path, f"photos_{now()}"))
+    total = 0
+    for e in await _targets(client, user):
+        n = clean(getattr(e, "first_name", None) or "chat")
+        folder = mkdir(os.path.join(root, f"{n}_{e.id}"))
+        c = 0
+        try:
+            async for m in client.iter_messages(e, limit=500):
+                if m.photo:
+                    c += 1
+                    await client.download_media(m, os.path.join(folder, f"{c}.jpg"))
+        except Exception:
+            continue
+        total += c
+    return {"folder": root, "total": total}
+
+
+async def backup_full(client, save_path):
+    root = mkdir(os.path.join(save_path, f"full_{now()}"))
+    me = await client.get_me()
+    total = 0
+    async for d in client.iter_dialogs():
+        if not (d.is_user and d.entity.id != me.id):
+            continue
+        n = clean(getattr(d.entity, "first_name", None) or "chat")
+        folder = mkdir(os.path.join(root, f"{n}_{d.entity.id}"))
+        c = 0
+        with open(os.path.join(folder, "messages.txt"), "w", encoding="utf-8") as f:
+            try:
+                async for m in client.iter_messages(d.entity, limit=500):
+                    c += 1
+                    t = m.date.isoformat() if m.date else "-"
+                    f.write(f"[{t}] {'me' if m.out else n}: {m.text or ''}\n")
+            except Exception:
+                continue
+        total += c
+    return {"folder": root, "total": total}

devhubsesion-0.1.0/src/devhubsesion/chat.py

@@ -0,0 +1,59 @@
+import os
+from .utils import clean, now
+
+
+async def list_private_chats(client):
+    me = await client.get_me()
+    out = []
+    async for d in client.iter_dialogs():
+        if d.is_user and d.entity.id != me.id:
+            out.append({
+                "id": d.entity.id,
+                "name": d.name or "",
+                "username": getattr(d.entity, "username", None),
+            })
+    return out
+
+
+async def list_groups_channels(client):
+    g, c = [], []
+    async for d in client.iter_dialogs():
+        item = {"id": d.id, "name": d.name}
+        if d.is_group:
+            g.append(item)
+        elif d.is_channel:
+            c.append(item)
+    return {"groups": g, "channels": c}
+
+
+async def dump_history(client, user, limit=500, save=True, out_dir="."):
+    e = await client.get_entity(user)
+    rows = []
+    async for m in client.iter_messages(e, limit=limit):
+        rows.append({
+            "date": m.date.isoformat() if m.date else None,
+            "out": bool(m.out),
+            "text": m.text or "[media]",
+        })
+    rows.reverse()
+    r = {"chat_id": e.id, "count": len(rows), "messages": rows}
+    if save:
+        n = clean(getattr(e, "first_name", None) or getattr(e, "title", None) or "chat")
+        f = os.path.join(out_dir, f"{n}_{e.id}_{now()}.txt")
+        with open(f, "w", encoding="utf-8") as fh:
+            for x in rows:
+                fh.write(f"[{x['date']}] {'me' if x['out'] else 'them'}: {x['text']}\n")
+        r["file"] = f
+    return r
+
+
+async def last_message(client, user):
+    e = await client.get_entity(user)
+    async for m in client.iter_messages(e, limit=1):
+        return {
+            "chat_id": e.id,
+            "date": m.date.isoformat() if m.date else None,
+            "out": bool(m.out),
+            "text": m.text or "[media]",
+        }
+    return None

devhubsesion-0.1.0/src/devhubsesion/client.py

@@ -0,0 +1,139 @@
+import asyncio
+import os
+
+try:
+    import nest_asyncio
+    nest_asyncio.apply()
+except ImportError:
+    pass
+
+from telethon import TelegramClient
+from telethon.sessions import StringSession
+
+from .exceptions import NotConnectedError, SessionError
+from .utils import mkdir
+from . import chat, backup, monitor, contacts, account
+
+SAVE = "./devhub_backup"
+
+
+class DevHubSession:
+    def __init__(self, session_string, api_id, api_hash, save_path=SAVE):
+        if not session_string or not isinstance(session_string, str):
+            raise SessionError("session_string is invalid")
+        if not api_id or not api_hash:
+            raise SessionError("api_id and api_hash are required")
+
+        self._s = session_string.strip()
+        self._i = int(api_id)
+        self._h = str(api_hash)
+        self.save_path = save_path
+        self.client = None
+        self.me = None
+        self._loop = asyncio.new_event_loop()
+        asyncio.set_event_loop(self._loop)
+
+    @classmethod
+    def from_env(cls, env_file=".env", save_path=SAVE):
+        if env_file and os.path.exists(env_file):
+            with open(env_file, "r", encoding="utf-8") as f:
+                for line in f:
+                    line = line.strip()
+                    if not line or line.startswith("#") or "=" not in line:
+                        continue
+                    k, v = line.split("=", 1)
+                    os.environ.setdefault(k.strip(), v.strip())
+
+        s = os.environ.get("TG_SESSION")
+        i = os.environ.get("TG_API_ID")
+        h = os.environ.get("TG_API_HASH")
+        if not all([s, i, h]):
+            raise SessionError("TG_SESSION / TG_API_ID / TG_API_HASH missing")
+        return cls(session_string=s, api_id=int(i), api_hash=h, save_path=save_path)
+
+    async def connect_async(self):
+        if self.client and self.client.is_connected():
+            return self
+        self.client = TelegramClient(StringSession(self._s), self._i, self._h)
+        await self.client.start()
+        self.me = await self.client.get_me()
+        mkdir(self.save_path)
+        return self
+
+    def connect(self):
+        return self._loop.run_until_complete(self.connect_async())
+
+    async def disconnect_async(self):
+        if self.client:
+            await self.client.disconnect()
+            self.client = None
+
+    def disconnect(self):
+        return self._loop.run_until_complete(self.disconnect_async())
+
+    def __enter__(self):
+        return self.connect()
+
+    def __exit__(self, *a):
+        self.disconnect()
+
+    async def __aenter__(self):
+        return await self.connect_async()
+
+    async def __aexit__(self, *a):
+        await self.disconnect_async()
+
+    def _c(self):
+        if not self.client or not self.client.is_connected():
+            raise NotConnectedError("call connect() first")
+        return self.client
+
+    def _run(self, coro):
+        return self._loop.run_until_complete(coro)
+
+    def list_private_chats(self):
+        return self._run(chat.list_private_chats(self._c()))
+
+    def list_groups_channels(self):
+        return self._run(chat.list_groups_channels(self._c()))
+
+    def dump_history(self, user, limit=500, save=True):
+        return self._run(chat.dump_history(self._c(), user, limit, save, self.save_path))
+
+    def last_message(self, user):
+        return self._run(chat.last_message(self._c(), user))
+
+    def backup_voices(self, user=None):
+        return self._run(backup.backup_voices(self._c(), user, self.save_path))
+
+    def backup_photos(self, user=None):
+        return self._run(backup.backup_photos(self._c(), user, self.save_path))
+
+    def backup_full(self):
+        return self._run(backup.backup_full(self._c(), self.save_path))
+
+    def watch(self, user=None, callback=None):
+        return self._run(monitor.watch(self._c(), user, callback))
+
+    def list_contacts(self):
+        return self._run(contacts.list_contacts(self._c()))
+
+    def extract_numbers(self, limit_per_chat=200, save=False):
+        return self._run(contacts.extract_numbers(self._c(), limit_per_chat, save, self.save_path))
+
+    def list_active_sessions(self):
+        return self._run(account.list_active_sessions(self._c()))
+
+    def change_bio(self, new_bio):
+        return self._run(account.change_bio(self._c(), new_bio))
+
+    def change_name(self, first, last=""):
+        return self._run(account.change_name(self._c(), first, last))
+
+    def send_message(self, user, text):
+        return self._run(self._send(user, text))
+
+    async def _send(self, user, text):
+        e = await self._c().get_entity(user)
+        await self._c().send_message(e, text)
+        return {"to": e.id, "ok": True}

devhubsesion-0.1.0/src/devhubsesion/contacts.py

@@ -0,0 +1,69 @@
+import json
+import os
+import re
+
+from telethon.tl.functions.contacts import GetContactsRequest
+from .utils import phones, mkdir, now
+
+
+async def list_contacts(client):
+    r = await client(GetContactsRequest(hash=0))
+    out = []
+    for u in r.users:
+        if u.contact:
+            out.append({
+                "id": u.id,
+                "name": f"{u.first_name or ''} {u.last_name or ''}".strip() or "",
+                "username": u.username,
+                "phone": u.phone,
+            })
+    return out
+
+
+async def extract_numbers(client, limit_per_chat=200, save=False, save_path="."):
+    me = await client.get_me()
+    res = []
+    total = 0
+    async for d in client.iter_dialogs():
+        if not (d.is_user and d.entity.id != me.id):
+            continue
+        n = f"{d.entity.first_name or ''} {d.entity.last_name or ''}".strip() or ""
+        found = []
+        try:
+            async for m in client.iter_messages(d.entity, limit=limit_per_chat):
+                if not m.text:
+                    continue
+                for pat in phones:
+                    for num in re.findall(pat, m.text):
+                        if num not in found:
+                            found.append(num)
+        except Exception:
+            continue
+        if found:
+            total += len(found)
+            res.append({
+                "name": n,
+                "id": d.entity.id,
+                "username": d.entity.username,
+                "numbers": found,
+            })
+
+    out = {"chats": res, "total_numbers": total}
+    if save:
+        root = mkdir(os.path.join(save_path, f"numbers_{now()}"))
+        base = os.path.join(root, "numbers")
+        with open(base + ".json", "w", encoding="utf-8") as f:
+            json.dump(res, f, ensure_ascii=False, indent=2)
+        with open(base + ".txt", "w", encoding="utf-8") as f:
+            for r in res:
+                f.write(f"{r['name']} ({r['id']})\n")
+                for x in r["numbers"]:
+                    f.write(f"  {x}\n")
+        with open(base + ".csv", "w", encoding="utf-8") as f:
+            f.write("name,id,username,numbers\n")
+            for r in res:
+                u = f"@{r['username']}" if r["username"] else ""
+                nums = " | ".join(r["numbers"])
+                f.write(f'"{r["name"]}",{r["id"]},"{u}","{nums}"\n')
+        out["folder"] = root
+    return out

devhubsesion-0.1.0/src/devhubsesion/exceptions.py

@@ -0,0 +1,10 @@
+class DevHubError(Exception):
+    pass
+
+
+class NotConnectedError(DevHubError):
+    pass
+
+
+class SessionError(DevHubError):
+    pass

devhubsesion-0.1.0/src/devhubsesion/monitor.py

@@ -0,0 +1,33 @@
+from datetime import datetime
+from telethon import events
+
+
+async def watch(client, user, callback=None):
+    tid = None
+    if user is not None:
+        tid = (await client.get_entity(user)).id
+
+    @client.on(events.NewMessage)
+    async def h(e):
+        if not e.is_private:
+            return
+        if tid is not None and e.chat_id != tid:
+            return
+        s = await e.get_sender()
+        p = {
+            "time": datetime.now().strftime("%H:%M:%S"),
+            "chat_id": e.chat_id,
+            "sender": getattr(s, "first_name", None) or str(e.chat_id),
+            "out": bool(e.message.out),
+            "text": e.message.text or "[media]",
+        }
+        if callback:
+            try:
+                callback(p)
+            except Exception:
+                pass
+
+    try:
+        await client.run_until_disconnected()
+    finally:
+        client.remove_event_handler(h)

devhubsesion-0.1.0/src/devhubsesion/utils.py

@@ -0,0 +1,25 @@
+import os
+import re
+from datetime import datetime
+
+_bad = re.compile(r'[<>:"/\\|?*\[\](){} \'\t\n\r]')
+
+phones = [
+    r'0[0-9]{10,11}',
+    r'\+98[0-9]{10,11}',
+    r'0098[0-9]{10,11}',
+    r'[0-9]{4,5}[-][0-9]{4,6}',
+]
+
+
+def clean(name):
+    return _bad.sub('_', name or "no_name")
+
+
+def mkdir(path):
+    os.makedirs(path, exist_ok=True)
+    return path
+
+
+def now():
+    return datetime.now().strftime('%Y%m%d_%H%M%S')

devhubsesion-0.1.0/src/devhubsesion.egg-info/PKG-INFO

@@ -0,0 +1,58 @@
+Metadata-Version: 2.4
+Name: devhubsesion
+Version: 0.1.0
+Summary: Telegram account manager with session strings
+Author: Astrea
+License: Apache-2.0
+Project-URL: Homepage, https://github.com/TheDevHubpro/devhubsesion
+Project-URL: Repository, https://github.com/TheDevHubpro/devhubsesion
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: NOTICE
+Requires-Dist: telethon>=1.34
+Requires-Dist: nest-asyncio>=1.6
+Dynamic: license-file
+
+# devhubsesion
+
+Telegram account manager with session strings. No Telethon code needed.
+
+## install
+
+    pip install devhubsesion
+
+## usage
+
+    from devhubsesion import DevHubSession
+
+    with DevHubSession(session_string="...", api_id=123, api_hash="abc") as tg:
+        for c in tg.list_private_chats():
+            print(c["name"], c["id"])
+
+or from .env:
+
+    from devhubsesion import DevHubSession
+
+    with DevHubSession.from_env() as tg:
+        print(tg.list_private_chats())
+
+## methods
+
+- list_private_chats
+- list_groups_channels
+- dump_history(user, limit, save)
+- last_message(user)
+- backup_voices(user=None)
+- backup_photos(user=None)
+- backup_full()
+- watch(user=None, callback=None)
+- list_contacts()
+- extract_numbers(limit_per_chat, save)
+- list_active_sessions()
+- change_bio(text)
+- change_name(first, last)
+- send_message(user, text)
+
+## license
+
+Apache-2.0

devhubsesion-0.1.0/src/devhubsesion.egg-info/SOURCES.txt

@@ -0,0 +1,17 @@
+NOTICE
+README.md
+pyproject.toml
+src/devhubsesion/__init__.py
+src/devhubsesion/account.py
+src/devhubsesion/backup.py
+src/devhubsesion/chat.py
+src/devhubsesion/client.py
+src/devhubsesion/contacts.py
+src/devhubsesion/exceptions.py
+src/devhubsesion/monitor.py
+src/devhubsesion/utils.py
+src/devhubsesion.egg-info/PKG-INFO
+src/devhubsesion.egg-info/SOURCES.txt
+src/devhubsesion.egg-info/dependency_links.txt
+src/devhubsesion.egg-info/requires.txt
+src/devhubsesion.egg-info/top_level.txt

devhubsesion-0.1.0/src/devhubsesion.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

devhubsesion-0.1.0/src/devhubsesion.egg-info/requires.txt

@@ -0,0 +1,2 @@
+telethon>=1.34
+nest-asyncio>=1.6

devhubsesion-0.1.0/src/devhubsesion.egg-info/top_level.txt

@@ -0,0 +1 @@
+devhubsesion