`Release v1.3.0`

### Features
✨ Add 10 new attractive themes to admin panel
- Includes Crimson Elegance, Coral Bliss, Cyber Neon, Forest Earth, Lavender Dream
- Includes Golden Luxury, Arctic Frost, Cherry Cola, Emerald Tech, Midnight Carbon
- Enhanced theme customization options for better UI/UX

✨ Add genre filter support across all platforms
- Mobile app genre filtering
- Web interface genre filtering
- TV application genre filtering

### Bug Fixes
🐛 Fix missing IMDb ID in TMDb fallback code
- Properly handle IMDb ID extraction when TMDb search fails
- Improved metadata retrieval reliability

🐛 Fix start command behavior
- Resolved minor issues with bot initialization

### Enhancements
♻️ Implement automatic file cleanup on deletion
- Delete Telegram channel files when content is removed from admin panel
- Prevents orphaned files and saves storage space
- Added file deletion for movies, TV shows, episodes, seasons, and quality variants

### Breaking Changes
None

### Dependencies
No new dependencies added

Backend/__init__.py

@@ -11,4 +11,4 @@ StartTime = time()
 USE_DEFAULT_ID: str = None
 db = Database()  
 
-__version__ = "1.2.1"
+__version__ = "1.3.0"

Backend/fastapi/themes.py

@@ -64,11 +64,143 @@ THEMES = {
             "text_secondary": "#CBD5E1"
         },
         "css_classes": "theme-dark-professional"
+    },
+    "crimson_elegance": {
+        "name": "Crimson Elegance",
+        "colors": {
+            "primary": "#DC2626",
+            "secondary": "#991B1B",
+            "accent": "#F87171",
+            "background": "#FEF2F2",
+            "card": "#FFFFFF",
+            "text": "#1F2937",
+            "text_secondary": "#6B7280"
+        },
+        "css_classes": "theme-crimson-elegance"
+    },
+    "coral_bliss": {
+        "name": "Coral Bliss",
+        "colors": {
+            "primary": "#FF6B6B",
+            "secondary": "#EE5A6F",
+            "accent": "#FFB347",
+            "background": "#FFF5F5",
+            "card": "#FFFFFF",
+            "text": "#2D3748",
+            "text_secondary": "#718096"
+        },
+        "css_classes": "theme-coral-bliss"
+    },
+    "cyber_neon": {
+        "name": "Cyber Neon",
+        "colors": {
+            "primary": "#00FFF0",
+            "secondary": "#FF00FF",
+            "accent": "#00FF88",
+            "background": "#0A0E27",
+            "card": "#1A1F3A",
+            "text": "#FFFFFF",
+            "text_secondary": "#A0AEC0"
+        },
+        "css_classes": "theme-cyber-neon"
+    },
+    "forest_earth": {
+        "name": "Forest Earth",
+        "colors": {
+            "primary": "#2D5016",
+            "secondary": "#50623A",
+            "accent": "#86A789",
+            "background": "#F5F5DC",
+            "card": "#FFFFFF",
+            "text": "#1C1C1C",
+            "text_secondary": "#5C5C5C"
+        },
+        "css_classes": "theme-forest-earth"
+    },
+    "lavender_dream": {
+        "name": "Lavender Dream",
+        "colors": {
+            "primary": "#B08BBB",
+            "secondary": "#9370DB",
+            "accent": "#DDA0DD",
+            "background": "#FAF5FF",
+            "card": "#FFFFFF",
+            "text": "#2D3748",
+            "text_secondary": "#718096"
+        },
+        "css_classes": "theme-lavender-dream"
+    },
+    "golden_luxury": {
+        "name": "Golden Luxury",
+        "colors": {
+            "primary": "#D4AF37",
+            "secondary": "#B8860B",
+            "accent": "#FFD700",
+            "background": "#FFFEF7",
+            "card": "#FFFFFF",
+            "text": "#1A202C",
+            "text_secondary": "#4A5568"
+        },
+        "css_classes": "theme-golden-luxury"
+    },
+    "arctic_frost": {
+        "name": "Arctic Frost",
+        "colors": {
+            "primary": "#B0E0E6",
+            "secondary": "#4682B4",
+            "accent": "#87CEEB",
+            "background": "#F0F8FF",
+            "card": "#FFFFFF",
+            "text": "#1E3A5F",
+            "text_secondary": "#5B7C99"
+        },
+        "css_classes": "theme-arctic-frost"
+    },
+    "cherry_cola": {
+        "name": "Cherry Cola",
+        "colors": {
+            "primary": "#BF1922",
+            "secondary": "#8B0000",
+            "accent": "#DC143C",
+            "background": "#FFF0F0",
+            "card": "#FFFFFF",
+            "text": "#1F2937",
+            "text_secondary": "#6B7280"
+        },
+        "css_classes": "theme-cherry-cola"
+    },
+    "emerald_tech": {
+        "name": "Emerald Tech",
+        "colors": {
+            "primary": "#047857",
+            "secondary": "#065F46",
+            "accent": "#10B981",
+            "background": "#ECFDF5",
+            "card": "#FFFFFF",
+            "text": "#1F2937",
+            "text_secondary": "#4B5563"
+        },
+        "css_classes": "theme-emerald-tech"
+    },
+    "midnight_carbon": {
+        "name": "Midnight Carbon",
+        "colors": {
+            "primary": "#3B82F6",
+            "secondary": "#1E40AF",
+            "accent": "#60A5FA",
+            "background": "#111827",
+            "card": "#1F2937",
+            "text": "#F9FAFB",
+            "text_secondary": "#D1D5DB"
+        },
+        "css_classes": "theme-midnight-carbon"
     }
 }
 
+
 def get_theme(theme_name: str = "purple_gradient"):
     return THEMES.get(theme_name, THEMES["purple_gradient"])
 
+
 def get_all_themes():
     return THEMES

Backend/helper/database.py

@@ -654,10 +654,40 @@ class Database:
     # Delete a Movie or Tvshow completely
     async def delete_document(self, media_type: str, tmdb_id: int, db_index: int) -> bool:
         db_key = f"storage_{db_index}"
+
         if media_type == "Movie":
+            doc = await self.dbs[db_key]["movie"].find_one({"tmdb_id": tmdb_id})
+            if doc and "telegram" in doc:
+                for quality in doc["telegram"]:
+                    try:
+                        old_id = quality.get("id")
+                        if old_id:
+                            decoded_data = await decode_string(old_id)
+                            chat_id = int(f"-100{decoded_data['chat_id']}")
+                            msg_id = int(decoded_data['msg_id'])
+                            create_task(delete_message(chat_id, msg_id))
+                    except Exception as e:
+                        LOGGER.error(f"Failed to queue file for deletion: {e}")
+            
             result = await self.dbs[db_key]["movie"].delete_one({"tmdb_id": tmdb_id})
         else:
+            doc = await self.dbs[db_key]["tv"].find_one({"tmdb_id": tmdb_id})
+            if doc and "seasons" in doc:
+                for season in doc["seasons"]:
+                    for episode in season.get("episodes", []):
+                        for quality in episode.get("telegram", []):
+                            try:
+                                old_id = quality.get("id")
+                                if old_id:
+                                    decoded_data = await decode_string(old_id)
+                                    chat_id = int(f"-100{decoded_data['chat_id']}")
+                                    msg_id = int(decoded_data['msg_id'])
+                                    create_task(delete_message(chat_id, msg_id))
+                            except Exception as e:
+                                LOGGER.error(f"Failed to queue file for deletion: {e}")
+            
             result = await self.dbs[db_key]["tv"].delete_one({"tmdb_id": tmdb_id})
+        
         if result.deleted_count > 0:
             LOGGER.info(f"{media_type} with tmdb_id {tmdb_id} deleted successfully.")
             return True
@@ -669,12 +699,29 @@ class Database:
     async def delete_movie_quality(self, tmdb_id: int, db_index: int, quality: str) -> bool:
         db_key = f"storage_{db_index}"
         movie = await self.dbs[db_key]["movie"].find_one({"tmdb_id": tmdb_id})
+        
         if not movie or "telegram" not in movie:
             return False
+
+        for q in movie["telegram"]:
+            if q.get("quality") == quality:
+                try:
+                    old_id = q.get("id")
+                    if old_id:
+                        decoded_data = await decode_string(old_id)
+                        chat_id = int(f"-100{decoded_data['chat_id']}")
+                        msg_id = int(decoded_data['msg_id'])
+                        create_task(delete_message(chat_id, msg_id))
+                except Exception as e:
+                    LOGGER.error(f"Failed to queue file for deletion: {e}")
+                break
+        
         original_len = len(movie["telegram"])
         movie["telegram"] = [q for q in movie["telegram"] if q.get("quality") != quality]
+        
         if len(movie["telegram"]) == original_len:
-            return False  
+            return False
+        
         movie['updated_on'] = datetime.utcnow()
         result = await self.dbs[db_key]["movie"].replace_one({"tmdb_id": tmdb_id}, movie)
         return result.modified_count > 0
@@ -683,17 +730,35 @@ class Database:
     async def delete_tv_episode(self, tmdb_id: int, db_index: int, season_number: int, episode_number: int) -> bool:
         db_key = f"storage_{db_index}"
         tv = await self.dbs[db_key]["tv"].find_one({"tmdb_id": tmdb_id})
+        
         if not tv or "seasons" not in tv:
             return False
+        
         found = False
         for season in tv["seasons"]:
             if season.get("season_number") == season_number:
+                for ep in season["episodes"]:
+                    if ep.get("episode_number") == episode_number:
+                        for quality in ep.get("telegram", []):
+                            try:
+                                old_id = quality.get("id")
+                                if old_id:
+                                    decoded_data = await decode_string(old_id)
+                                    chat_id = int(f"-100{decoded_data['chat_id']}")
+                                    msg_id = int(decoded_data['msg_id'])
+                                    create_task(delete_message(chat_id, msg_id))
+                            except Exception as e:
+                                LOGGER.error(f"Failed to queue file for deletion: {e}")
+                        break
+                
                 original_len = len(season["episodes"])
                 season["episodes"] = [ep for ep in season["episodes"] if ep.get("episode_number") != episode_number]
                 found = original_len > len(season["episodes"])
                 break
+        
         if not found:
             return False
+        
         tv['updated_on'] = datetime.utcnow()
         result = await self.dbs[db_key]["tv"].replace_one({"tmdb_id": tmdb_id}, tv)
         return result.modified_count > 0
@@ -702,12 +767,31 @@ class Database:
     async def delete_tv_season(self, tmdb_id: int, db_index: int, season_number: int) -> bool:
         db_key = f"storage_{db_index}"
         tv = await self.dbs[db_key]["tv"].find_one({"tmdb_id": tmdb_id})
+        
         if not tv or "seasons" not in tv:
             return False
+        
+        for season in tv["seasons"]:
+            if season.get("season_number") == season_number:
+                for episode in season.get("episodes", []):
+                    for quality in episode.get("telegram", []):
+                        try:
+                            old_id = quality.get("id")
+                            if old_id:
+                                decoded_data = await decode_string(old_id)
+                                chat_id = int(f"-100{decoded_data['chat_id']}")
+                                msg_id = int(decoded_data['msg_id'])
+                                create_task(delete_message(chat_id, msg_id))
+                        except Exception as e:
+                            LOGGER.error(f"Failed to queue file for deletion: {e}")
+                break
+        
         original_len = len(tv["seasons"])
         tv["seasons"] = [s for s in tv["seasons"] if s.get("season_number") != season_number]
+        
         if len(tv["seasons"]) == original_len:
-            return False  
+            return False
+        
         tv['updated_on'] = datetime.utcnow()
         result = await self.dbs[db_key]["tv"].replace_one({"tmdb_id": tmdb_id}, tv)
         return result.modified_count > 0
@@ -716,23 +800,40 @@ class Database:
     async def delete_tv_quality(self, tmdb_id: int, db_index: int, season_number: int, episode_number: int, quality: str) -> bool:
         db_key = f"storage_{db_index}"
         tv = await self.dbs[db_key]["tv"].find_one({"tmdb_id": tmdb_id})
+        
         if not tv or "seasons" not in tv:
             return False
+        
         found = False
         for season in tv["seasons"]:
             if season.get("season_number") == season_number:
                 for episode in season["episodes"]:
                     if episode.get("episode_number") == episode_number and "telegram" in episode:
+                        for q in episode["telegram"]:
+                            if q.get("quality") == quality:
+                                try:
+                                    old_id = q.get("id")
+                                    if old_id:
+                                        decoded_data = await decode_string(old_id)
+                                        chat_id = int(f"-100{decoded_data['chat_id']}")
+                                        msg_id = int(decoded_data['msg_id'])
+                                        create_task(delete_message(chat_id, msg_id))
+                                except Exception as e:
+                                    LOGGER.error(f"Failed to queue file for deletion: {e}")
+                                break
+                        
                         original_len = len(episode["telegram"])
                         episode["telegram"] = [q for q in episode["telegram"] if q.get("quality") != quality]
                         found = original_len > len(episode["telegram"])
                         break
+        
         if not found:
             return False
         tv['updated_on'] = datetime.utcnow()
         result = await self.dbs[db_key]["tv"].replace_one({"tmdb_id": tmdb_id}, tv)
         return result.modified_count > 0
 
+
     # Get per-DB statistics (movies, tv shows, used size, etc.)
     async def get_database_stats(self):
         stats = []

Backend/helper/metadata.py

@@ -158,7 +158,7 @@ async def fetch_tv_metadata(title, season, episode, encoded_string, year=None, q
     if use_tmdb and tv_details:
         return {
             "tmdb_id": tv_details.id,
-            "imdb_id": "",
+            "imdb_id": tv_details.external_ids.imdb_id,
             "title": tv_details.name,
             "year": getattr(tv_details.first_air_date, "year", 0),
             "rate": getattr(tv_details, "vote_average", 0) or 0,
@@ -234,7 +234,7 @@ async def fetch_movie_metadata(title, encoded_string, year=None, quality=None, d
     if use_tmdb and movie_details:
         return {
             "tmdb_id": movie_details.id,
-            "imdb_id": "",
+            "imdb_id": movie_details.external_ids.imdb_id,
             "title": movie_details.title,
             "year": getattr(movie_details.release_date, "year", 0),
             "rate": getattr(movie_details, "vote_average", 0) or 0,

Backend/pyrofork/plugins/start.py

@@ -2,17 +2,11 @@ from pyrogram import filters, Client, enums
 from Backend.helper.custom_filter import CustomFilters
 from pyrogram.types import Message
 from Backend.config import Telegram
-from urllib.parse import urlparse
 
 @Client.on_message(filters.command('start') & filters.private & CustomFilters.owner, group=10)
 async def send_start_message(client: Client, message: Message):
     try:
-        parsed_url = urlparse(Telegram.BASE_URL)
         base_url = Telegram.BASE_URL
-
-        if parsed_url.hostname.replace('.', '').isdigit() and Telegram.PORT:
-            base_url = f"{parsed_url.scheme}://{parsed_url.hostname}:{Telegram.PORT}"
-
         addon_url = f"{base_url}/stremio/manifest.json"
 
         await message.reply_text(

pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "Telegram-Stremio"
-version = "1.2.1"
+version = "1.3.0"
 description = "A powerful, self-hosted Telegram Stremio Media Server built with FastAPI, MongoDB, and PyroFork seamlessly integrated with Stremio for automated media streaming and discovery."
 readme = "README.md"
 requires-python = ">=3.11"

uv.lock

@@ -901,7 +901,7 @@ wheels = [
 
 [[package]]
 name = "telegram-stremio"
-version = "1.2.0"
+version = "1.2.1"
 source = { virtual = "." }
 dependencies = [
     { name = "aiofiles" },