AbhiCalls 1.0.0__py3-none-any.whl

AbhiCalls/__init__.py

@@ -0,0 +1,5 @@
+from AbhiCalls.vc import VoiceEngine
+from AbhiCalls.runtime import idle
+from .player import Player
+
+__all__ = ["VoiceEngine", "idle"]

AbhiCalls/controller.py

@@ -0,0 +1,96 @@
+from AbhiCalls.yt import resolve_query
+from AbhiCalls.models import Song
+from AbhiCalls.player import Player
+
+class VoiceController:
+    def __init__(self, engine):
+        self.engine = engine
+        self.player = Player(engine)
+        self.engine.on_end = self._on_end
+        self.plugins = []
+
+    def load_plugin(self, plugin):
+        self.plugins.append(plugin)
+
+    async def _hook(self, name, *args):
+        for p in self.plugins:
+            fn = getattr(p, name, None)
+            if fn:
+                try:
+                    await fn(*args)
+                except Exception as e:
+                    print(f"[Plugin:{p.name}] {name} error:", e)
+
+    async def play(self, chat_id, query, requested_by):
+        results = await resolve_query(query)
+        if not results:
+            return None, None
+
+        first_pos = None
+        last_song = None
+
+        for data in results:
+            song = Song(
+                title=data["title"],
+                url=data["url"],
+                duration=data["duration"],
+                views=data["views"],
+                stream=data["stream"],
+                requested_by=requested_by,
+            )
+
+            pos = await self.player.play(chat_id, song)
+            await self._hook("on_queue_add", chat_id, song, pos)
+
+            if first_pos is None:
+                first_pos = pos
+            last_song = song
+
+        if first_pos == 1:
+            await self._hook("on_song_start", chat_id, last_song)
+
+        return last_song, first_pos
+
+    async def skip(self, chat_id):
+        await self.player.skip(chat_id)
+
+    async def previous(self, chat_id):
+        return await self.player.previous(chat_id)
+
+    async def pause(self, chat_id):
+        await self.player.pause(chat_id)
+
+    async def resume(self, chat_id):
+        await self.player.resume(chat_id)
+
+    async def stop(self, chat_id):
+        await self.player.stop(chat_id)
+
+    async def mute(self, chat_id):
+        await self.player.mute(chat_id)
+
+    async def unmute(self, chat_id):
+        await self.player.unmute(chat_id)
+
+    async def volume(self, chat_id, volume: int):
+        await self.player.volume(chat_id, volume)
+        
+
+    def loop(self, chat_id, count=None):
+        return self.player.set_loop(chat_id, count)
+
+    def eta(self, chat_id):
+        return self.player.eta(chat_id)
+
+    async def _on_end(self, chat_id):
+        q = self.player.queues.get(chat_id)
+        song = q.current() if q else None
+        if song:
+            await self._hook("on_song_end", chat_id, song)
+
+        await self.player.skip(chat_id)
+
+        next_song = q.current() if q else None
+        if next_song:
+            await self._hook("on_song_start", chat_id, next_song)
+          

AbhiCalls/models.py

@@ -0,0 +1,29 @@
+class Song:
+    def __init__(
+        self,
+        title,
+        url,
+        duration,
+        views,
+        stream,
+        requested_by,
+        loop_left=0,
+    ):
+        self.title = title
+        self.url = url
+        self.duration = duration
+        self.views = views
+        self.stream = stream
+        self.requested_by = requested_by
+        self.loop_left = loop_left
+        self.duration_sec = self._to_seconds(duration)
+
+    def _to_seconds(self, d):
+        try:
+            if ":" in d:
+                m, s = map(int, d.split(":"))
+                return m * 60 + s
+            return int(d)
+        except Exception:
+            return 0
+

AbhiCalls/player.py

@@ -0,0 +1,83 @@
+import time
+from AbhiCalls.queue import SongQueue
+
+class Player:
+    def __init__(self, engine):
+        self.engine = engine
+        self.queues = {}
+        self.start_time = {}
+
+    def _queue(self, chat_id):
+        return self.queues.setdefault(chat_id, SongQueue())
+
+    async def play(self, chat_id, song):
+        q = self._queue(chat_id)
+        pos = q.add(song)
+
+        if pos == 1:
+            self.start_time[chat_id] = time.time()
+            await self.engine.play(chat_id, song.stream)
+
+        return pos
+
+    async def skip(self, chat_id):
+        q = self.queues.get(chat_id)
+        if not q:
+            return
+        nxt = q.next()
+        if nxt:
+            self.start_time[chat_id] = time.time()
+            await self.engine.play(chat_id, nxt.stream)
+        else:
+            await self.engine.stop(chat_id)
+
+    async def previous(self, chat_id):
+        q = self.queues.get(chat_id)
+        if not q:
+            return None
+        prev = q.previous()
+        if prev:
+            self.start_time[chat_id] = time.time()
+            await self.engine.play(chat_id, prev.stream)
+        return prev
+
+    async def stop(self, chat_id):
+        if chat_id in self.queues:
+            self.queues[chat_id].clear()
+        await self.engine.stop(chat_id)
+
+    async def pause(self, chat_id):
+        await self.engine.pause(chat_id)
+
+    async def resume(self, chat_id):
+        await self.engine.resume(chat_id)
+
+    async def mute(self, chat_id):
+        await self.engine.mute(chat_id)
+
+    async def unmute(self, chat_id):
+        await self.engine.unmute(chat_id)
+
+    async def volume(self, chat_id, volume: int):
+        await self.engine.change_volume(chat_id, volume)
+        
+
+    def set_loop(self, chat_id, count=None):
+        q = self._queue(chat_id)
+        if count is None:
+            q.infinite_loop = not q.infinite_loop
+            return q.infinite_loop
+
+        cur = q.current()
+        if cur:
+            cur.loop_left = count - 1
+            return count
+        return 0
+
+    def eta(self, chat_id):
+        q = self.queues.get(chat_id)
+        if not q or not q.current():
+            return None
+        elapsed = int(time.time() - self.start_time.get(chat_id, 0))
+        return max(q.current().duration_sec - elapsed, 0)
+      

AbhiCalls/queue.py

@@ -0,0 +1,53 @@
+from collections import deque
+import random
+
+class SongQueue:
+    def __init__(self):
+        self.items = []
+        self.history = deque(maxlen=20)
+        self.infinite_loop = False
+
+    def add(self, song):
+        self.items.append(song)
+        return len(self.items)
+
+    def current(self):
+        return self.items[0] if self.items else None
+
+    def next(self):
+        if not self.items:
+            return None
+
+        current = self.items[0]
+        self.history.appendleft(current)
+
+        if current.loop_left > 0:
+            current.loop_left -= 1
+            return current
+
+        if self.infinite_loop:
+            return current
+
+        self.items.pop(0)
+        return self.current()
+
+    def previous(self):
+        if not self.history:
+            return None
+        prev = self.history.popleft()
+        self.items.insert(0, prev)
+        return prev
+
+    def shuffle(self):
+        if len(self.items) <= 1:
+            return False
+        current = self.items.pop(0)
+        random.shuffle(self.items)
+        self.items.insert(0, current)
+        return True
+
+    def clear(self):
+        self.items.clear()
+        self.history.clear()
+        self.infinite_loop = False
+      

AbhiCalls/runtime.py

@@ -0,0 +1,37 @@
+import logging
+import sys
+import os
+from contextlib import contextmanager
+from pytgcalls import idle as _idle
+
+# ─────────────────────────────
+# Mute pytgcalls logs
+# ─────────────────────────────
+logging.getLogger("pytgcalls").setLevel(logging.CRITICAL)
+logging.getLogger("ntgcalls").setLevel(logging.CRITICAL)
+
+
+@contextmanager
+def _suppress_stdout():
+    """
+    Temporarily suppress stdout/stderr
+    (used to hide pytgcalls banner)
+    """
+    with open(os.devnull, "w") as devnull:
+        old_out = sys.stdout
+        old_err = sys.stderr
+        sys.stdout = devnull
+        sys.stderr = devnull
+        try:
+            yield
+        finally:
+            sys.stdout = old_out
+            sys.stderr = old_err
+
+
+async def idle():
+    """
+    Keep app running (pytgcalls idle hidden)
+    """
+    with _suppress_stdout():
+        await _idle()

AbhiCalls/vc.py

@@ -0,0 +1,11 @@
+from AbhiCalls._engine.native import _NativeEngine
+from AbhiCalls.controller import VoiceController
+
+class VoiceEngine:
+    def __init__(self, app):
+        self._engine = _NativeEngine(app)
+        self.vc = VoiceController(self._engine)
+
+    async def start(self):
+        await self._engine.start()
+      

AbhiCalls/yt.py

@@ -0,0 +1,84 @@
+import re
+from YouTubeMusic.Search import Search
+from YouTubeMusic.Stream import get_stream
+from YouTubeMusic.Playlist import get_playlist_songs
+
+PLAYLIST_REGEX = re.compile(r"(list=)")
+YOUTUBE_REGEX = re.compile(r"(youtube\.com|youtu\.be|music\.youtube\.com)")
+
+def sec_to_mmss(sec):
+    try:
+        sec = int(sec)
+        return f"{sec // 60}:{sec % 60:02d}"
+    except Exception:
+        return "Unknown"
+
+def yt_thumbnail(url: str):
+    """Extract thumbnail from YouTube URL"""
+    try:
+        if "watch?v=" in url:
+            vid = url.split("watch?v=")[1].split("&")[0]
+        elif "youtu.be/" in url:
+            vid = url.split("youtu.be/")[1].split("?")[0]
+        else:
+            return None
+        return f"https://i.ytimg.com/vi/{vid}/hqdefault.jpg"
+    except Exception:
+        return None
+
+
+async def resolve_query(query: str):
+    songs = []
+
+    # 🎵 PLAYLIST
+    if PLAYLIST_REGEX.search(query):
+        playlist = await get_playlist_songs(query)
+        for item in playlist:
+            stream = get_stream(item["url"])
+            if not stream:
+                continue
+
+            songs.append({
+                "title": item.get("title", "Unknown"),
+                "url": item["url"],
+                "duration": sec_to_mmss(item.get("duration", "0")),
+                "views": "Unknown",
+                "thumbnail": yt_thumbnail(item["url"]),
+                "stream": stream,
+            })
+        return songs or None
+
+    # 🔗 DIRECT YT LINK
+    if YOUTUBE_REGEX.search(query):
+        stream = get_stream(query)
+        if not stream:
+            return None
+
+        return [{
+            "title": "YouTube Audio",
+            "url": query,
+            "duration": "Unknown",
+            "views": "Unknown",
+            "thumbnail": yt_thumbnail(query),
+            "stream": stream,
+        }]
+
+    # 🔍 SEARCH
+    res = await Search(query, limit=1)
+    if not res or not res.get("main_results"):
+        return None
+
+    i = res["main_results"][0]
+    stream = get_stream(i["url"])
+    if not stream:
+        return None
+
+    return [{
+        "title": i["title"],
+        "url": i["url"],
+        "duration": i.get("duration", "Unknown"),
+        "views": i.get("views", "Unknown"),
+        # 🔥 thumbnail from search (fallback safe)
+        "thumbnail": i.get("thumbnail") or yt_thumbnail(i["url"]),
+        "stream": stream,
+    }]

abhicalls-1.0.0.dist-info/METADATA

@@ -0,0 +1,40 @@
+Metadata-Version: 2.4
+Name: AbhiCalls
+Version: 1.0.0
+Summary: Telegram Voice Chat Music Engine with Queue, Loop, ETA and Player controls
+Home-page: https://github.com/YouTubeMusicAPI/TgCall
+Author: Abhishek Thakur
+Author-email: Abhishek Thakur <abhishekbanshiwal2005@gmail.com>
+License: MIT
+Project-URL: Homepage, https://github.com/YouTubeMusicAPI/TgCall
+Project-URL: Source, https://github.com/YouTubeMusicAPI/TgCall
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Topic :: Multimedia :: Sound/Audio
+Classifier: Topic :: Software Development :: Libraries
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+Requires-Dist: py-tgcalls>=2.1.1
+Requires-Dist: pyrogram>=2.0.0
+Requires-Dist: telethon>=1.34.0
+Requires-Dist: aiohttp
+Dynamic: author
+Dynamic: home-page
+Dynamic: requires-python
+
+# AbhiCalls
+
+AbhiCalls is a Telegram Voice Chat Music Engine built on top of PyTgCalls.
+
+## Features
+- Play audio in Telegram voice chats
+- Queue management
+- Skip, pause, resume
+- Loop and ETA support
+
+## Installation
+```bash
+pip install abhicalls
+

abhicalls-1.0.0.dist-info/RECORD

@@ -0,0 +1,12 @@
+AbhiCalls/__init__.py,sha256=8Bgye84bSUJVFLhm2HPc2piO3YHZb67EihvJlGZxvDs,134
+AbhiCalls/controller.py,sha256=mdowoTCc6jpDsdljuUWdgbsCMR5NObaw3Jh6LYb-O8I,2739
+AbhiCalls/models.py,sha256=ybRrFbVmlpLyfmmn7lG2DpDz_Z9qcq3g9AD5Krc-UP0,664
+AbhiCalls/player.py,sha256=UlAWmhZqHFjtAplA9-6lXFkVAu4pyEWDGbF8Wj9KYkM,2286
+AbhiCalls/queue.py,sha256=iRrTvt1rU-diarSBCfxjeY-4uJ97oUsvDqtPpbB4UQY,1212
+AbhiCalls/runtime.py,sha256=4_WmHirGwNOyn1Iuzbhecb_ao7qMDh1erFzp0ZaLze0,966
+AbhiCalls/vc.py,sha256=ld3C4-QNDrHBQPrNzIuNTcu7zk1pVOo9rvrQBUsTI8s,309
+AbhiCalls/yt.py,sha256=QnO2LdtgVbEi8XqKEY9ZSp6a6x1AjBYVCFNB2sXFcPU,2386
+abhicalls-1.0.0.dist-info/METADATA,sha256=ubmOdWXkfYhqljgu7YAJDqOc28ENQNYSB5ea-qKxbuU,1216
+abhicalls-1.0.0.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+abhicalls-1.0.0.dist-info/top_level.txt,sha256=3_ZgJEaE0rS9jpmEMi6oIXEtMzIagrn70XtK7H6w2gA,10
+abhicalls-1.0.0.dist-info/RECORD,,

abhicalls-1.0.0.dist-info/WHEEL

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

abhicalls-1.0.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+AbhiCalls