StreamingCommunity 2.5.6__py3-none-any.whl → 2.5.8__py3-none-any.whl

StreamingCommunity/Lib/TMBD/tmdb.py

@@ -6,17 +6,19 @@ from typing import Dict
 
 # External libraries
 import httpx
-from rich.console import Console
 
 
 # Internal utilities
 from .obj_tmbd import Json_film
+from StreamingCommunity.Util.console import console
+from StreamingCommunity.Util._jsonConfig import config_manager
 from StreamingCommunity.Util.table import TVShowManager
 
 
 # Variable
 table_show_manager = TVShowManager()
 api_key = "a800ed6c93274fb857ea61bd9e7256c5"
+MAX_TIMEOUT = config_manager.get_int("REQUESTS", "timeout")
 
 
 
@@ -33,7 +35,7 @@ def get_select_title(table_show_manager, generic_obj):
 
     # Check if the generic_obj list is empty
     if not generic_obj:
-        Console.print("\n[red]No media items available.")
+        console.print("\n[red]No media items available.")
         return None
     
     # Example of available colors for columns
@@ -76,7 +78,7 @@ def get_select_title(table_show_manager, generic_obj):
 
     # Handle user's quit command
     if last_command == "q" or last_command == "quit":
-        Console.print("\n[red]Quit [white]...")
+        console.print("\n[red]Quit [white]...")
         sys.exit(0)
 
     # Check if the selected index is within range
@@ -84,7 +86,7 @@ def get_select_title(table_show_manager, generic_obj):
         return generic_obj[int(last_command)]
     
     else:
-        Console.print("\n[red]Wrong index")
+        console.print("\n[red]Wrong index")
         sys.exit(0)
 
 
@@ -98,8 +100,9 @@ class TheMovieDB:
         """
         self.api_key = api_key
         self.base_url = "https://api.themoviedb.org/3"
-        self.console = Console()
         #self.genres = self._fetch_genres()
+        self._cached_trending_tv = None
+        self._cached_trending_movies = None
 
     def _make_request(self, endpoint, params=None):
         """
@@ -117,7 +120,7 @@ class TheMovieDB:
 
         params['api_key'] = self.api_key
         url = f"{self.base_url}/{endpoint}"
-        response = httpx.get(url, params=params)
+        response = httpx.get(url, params=params, timeout=MAX_TIMEOUT)
         response.raise_for_status()
         
         return response.json()
@@ -132,78 +135,66 @@ class TheMovieDB:
         genres = self._make_request("genre/movie/list")
         return {genre['id']: genre['name'] for genre in genres.get('genres', [])}
 
-    def _process_and_add_tv_shows(self, data, columns):
+    def _display_top_5(self, category: str, data, name_key='title'):
         """
-        Process TV show data and add it to the TV show manager.
+        Display top 5 most popular items in a single line with colors.
         
         Parameters:
-            - data (list): List of dictionaries containing the data to process.
-            - columns (list): A list of tuples, where each tuple contains the column name and the key to fetch the data from the dictionary.
+            - category (str): Category label (e.g., "Trending films", "Trending TV shows")
+            - data (list): List of media items
+            - name_key (str): Key to use for the name ('title' for movies, 'name' for TV shows)
         """
-        # Define column styles with colors
-        tv_show_manager = TVShowManager()
-        column_info = {
-            col[0]: {'color': col[2] if len(col) > 2 else 'white'}
-            for col in columns
-        }
-        tv_show_manager.add_column(column_info)
-
-        # Add each item to the TV show manager, including rank
-        for index, item in enumerate(data):
-            
-            # Convert genre IDs to genre names
-            genre_names = [self.genres.get(genre_id, 'Unknown') for genre_id in item.get('genre_ids', [])]
-            tv_show = {
-                col[0]: str(item.get(col[1], 'N/A')) if col[1] != 'genre_ids' else ', '.join(genre_names)
-                for col in columns
-            }
-
-            tv_show_manager.add_tv_show(tv_show)
+        # Colors for the titles
+        colors = ['cyan', 'magenta', 'yellow', 'green', 'blue']
         
-        # Display the processed TV show data
-        tv_show_manager.display_data(tv_show_manager.tv_shows[tv_show_manager.slice_start:tv_show_manager.slice_end])
+        # Sort by popularity and get top 5
+        sorted_data = sorted(data, key=lambda x: x.get('popularity', 0), reverse=True)[:5]
+        
+        # Create list of colored titles
+        colored_items = []
+        for item, color in zip(sorted_data, colors):
+            title = item.get(name_key, 'Unknown')
+            colored_items.append(f"[{color}]{title}[/]")
+        
+        # Join with colored arrows and print with proper category label
+        console.print(
+            f"[bold purple]{category}:[/] {' [red]→[/] '.join(colored_items)}"
+        )
 
-    def _display_with_title(self, title: str, data, columns):
+    def display_trending_tv_shows(self):
         """
-        Display data with a title.
-
-        Parameters:
-            - title (str): The title to display.
-            - data (list): List of dictionaries containing the data to process.
-            - columns (list): A list of tuples, where each tuple contains the column name and the key to fetch the data from the dictionary.
+        Fetch and display the top 5 trending TV shows of the week.
+        Uses cached data if available, otherwise makes a new request.
         """
-        self.console.print(f"\n{title}", style="bold underline")
-        self._process_and_add_tv_shows(data, columns)
+        if self._cached_trending_tv is None:
+            self._cached_trending_tv = self._make_request("trending/tv/week").get("results", [])
+        
+        self._display_top_5("Trending TV shows", self._cached_trending_tv, name_key='name')
 
-    def display_trending_tv_shows(self):
+    def refresh_trending_tv_shows(self):
         """
-        Fetch and display the trending TV shows of the week.
+        Force a refresh of the trending TV shows cache.
         """
-        data = self._make_request("trending/tv/week").get("results", [])
-        columns = [
-            ("Title", "name", 'cyan'), 
-            ("First Air Date", "first_air_date", 'green'), 
-            ("Popularity", "popularity", 'magenta'),
-            ("Genres", "genre_ids", 'blue'),
-            ("Origin Country", "origin_country", 'red'),
-            ("Vote Average", "vote_average", 'yellow')
-        ]
-        self._display_with_title("Trending TV Shows of the Week", data, columns)
+        self._cached_trending_tv = self._make_request("trending/tv/week").get("results", [])
+        return self._cached_trending_tv
 
     def display_trending_films(self):
         """
-        Fetch and display the trending films of the week.
+        Fetch and display the top 5 trending films of the week.
+        Uses cached data if available, otherwise makes a new request.
         """
-        data = self._make_request("trending/movie/week").get("results", [])
-        columns = [
-            ("Title", "title", 'cyan'), 
-            ("Release Date", "release_date", 'green'), 
-            ("Popularity", "popularity", 'magenta'),
-            ("Genres", "genre_ids", 'blue'),
-            ("Vote Average", "vote_average", 'yellow')
-        ]
-        self._display_with_title("Trending Films of the Week", data, columns)
+        if self._cached_trending_movies is None:
+            self._cached_trending_movies = self._make_request("trending/movie/week").get("results", [])
+        
+        self._display_top_5("Trending films", self._cached_trending_movies, name_key='title')
 
+    def refresh_trending_films(self):
+        """
+        Force a refresh of the trending films cache.
+        """
+        self._cached_trending_movies = self._make_request("trending/movie/week").get("results", [])
+        return self._cached_trending_movies
+      
     def search_movie(self, movie_name: str):
         """
         Search for a movie by name and return its TMDB ID.
@@ -217,10 +208,10 @@ class TheMovieDB:
         generic_obj = []
         data = self._make_request("search/movie", {"query": movie_name}).get("results", [])
         if not data:
-            self.console.print("No movies found with that name.", style="red")
+            console.print("No movies found with that name.", style="red")
             return None
 
-        self.console.print("\nSelect a Movie:")
+        console.print("\nSelect a Movie:")
         for i, movie in enumerate(data, start=1):
             generic_obj.append({
                 'name': movie['title'],
@@ -243,7 +234,7 @@ class TheMovieDB:
         """
         movie = self._make_request(f"movie/{tmdb_id}")
         if not movie:
-            self.console.print("Movie not found.", style="red")
+            console.print("Movie not found.", style="red")
             return None
         
         return Json_film(movie)
@@ -260,12 +251,12 @@ class TheMovieDB:
         """
         data = self._make_request("search/tv", {"query": tv_name}).get("results", [])
         if not data:
-            self.console.print("No TV shows found with that name.", style="red")
+            console.print("No TV shows found with that name.", style="red")
             return None
 
-        self.console.print("\nSelect a TV Show:")
+        console.print("\nSelect a TV Show:")
         for i, show in enumerate(data, start=1):
-            self.console.print(f"{i}. {show['name']} (First Air Date: {show.get('first_air_date', 'N/A')})")
+            console.print(f"{i}. {show['name']} (First Air Date: {show.get('first_air_date', 'N/A')})")
 
         choice = int(input("Enter the number of the show you want: ")) - 1
         selected_show = data[choice]
@@ -283,12 +274,12 @@ class TheMovieDB:
         """
         data = self._make_request(f"tv/{tv_show_id}").get("seasons", [])
         if not data:
-            self.console.print("No seasons found for this TV show.", style="red")
+            console.print("No seasons found for this TV show.", style="red")
             return None
 
-        self.console.print("\nSelect a Season:")
+        console.print("\nSelect a Season:")
         for i, season in enumerate(data, start=1):
-            self.console.print(f"{i}. {season['name']} (Episodes: {season['episode_count']})")
+            console.print(f"{i}. {season['name']} (Episodes: {season['episode_count']})")
 
         choice = int(input("Enter the number of the season you want: ")) - 1
         return data[choice]["season_number"]
@@ -306,12 +297,12 @@ class TheMovieDB:
         """
         data = self._make_request(f"tv/{tv_show_id}/season/{season_number}").get("episodes", [])
         if not data:
-            self.console.print("No episodes found for this season.", style="red")
+            console.print("No episodes found for this season.", style="red")
             return None
 
-        self.console.print("\nSelect an Episode:")
+        console.print("\nSelect an Episode:")
         for i, episode in enumerate(data, start=1):
-            self.console.print(f"{i}. {episode['name']} (Air Date: {episode.get('air_date', 'N/A')})")
+            console.print(f"{i}. {episode['name']} (Air Date: {episode.get('air_date', 'N/A')})")
 
         choice = int(input("Enter the number of the episode you want: ")) - 1
         return data[choice]
@@ -319,28 +310,4 @@ class TheMovieDB:
 
 
 # Output
-tmdb = TheMovieDB(api_key)
-
-
-"""
-Example:
-
-
-@ movie
-movie_name = "Interstellar"
-movie_id = tmdb.search_movie(movie_name)
-
-if movie_id:
-    movie_details = tmdb.get_movie_details(tmdb_id=movie_id)
-    print(movie_details)
-
-
-@ series
-tv_name = "Game of Thrones"
-tv_show_id = tmdb.search_tv_show(tv_name)
-if tv_show_id:
-    season_number = tmdb.get_seasons(tv_show_id=tv_show_id)
-    if season_number:
-        episode = tmdb.get_episodes(tv_show_id=tv_show_id, season_number=season_number)
-        print(episode)
-"""
+tmdb = TheMovieDB(api_key)

StreamingCommunity/TelegramHelp/telegram_bot.py

@@ -1,4 +1,4 @@
-# 04.02.25
+# 04.02.26
 # Made by: @GiuPic
 
 import os
@@ -9,16 +9,141 @@ import uuid
 import json
 import threading
 import subprocess
-
+import threading
+from typing import Optional
 
 # External libraries
 import telebot
 
+session_data = {}
+
+class TelegramSession:
+
+    def set_session(value):
+        session_data['script_id'] = value
+
+    def get_session():
+        return session_data.get('script_id', 'unknown')
+
+    def updateScriptId(screen_id, titolo):
+        json_file = "../../scripts.json"
+        try:
+            with open(json_file, 'r') as f:
+                scripts_data = json.load(f)
+        except FileNotFoundError:
+            scripts_data = []
+
+        # cerco lo script con lo screen_id
+        for script in scripts_data:
+            if script["screen_id"] == screen_id:
+                # se trovo il match, aggiorno il titolo
+                script["titolo"] = titolo
+
+                # aggiorno il file json
+                with open(json_file, 'w') as f:
+                    json.dump(scripts_data, f, indent=4)
+
+                return
+
+        print(f"Screen_id {screen_id} non trovato.")
+
+    def deleteScriptId(screen_id):
+        json_file = "../../scripts.json"
+        try:
+            with open(json_file, 'r') as f:
+                scripts_data = json.load(f)
+        except FileNotFoundError:
+            scripts_data = []
+
+        for script in scripts_data:
+            if script["screen_id"] == screen_id:
+                # se trovo il match, elimino lo script
+                scripts_data.remove(script)
+
+                # aggiorno il file json
+                with open(json_file, 'w') as f:
+                    json.dump(scripts_data, f, indent=4)
+
+                print(f"Script eliminato per screen_id {screen_id}")
+                return
+
+        print(f"Screen_id {screen_id} non trovato.")
+
+class TelegramRequestManager:
+    _instance = None
+
+    def __new__(cls, *args, **kwargs):
+        if not cls._instance:
+            cls._instance = super().__new__(cls)
+        return cls._instance
+
+    def __init__(self, json_file: str = "active_requests.json"):
+        if not hasattr(self, 'initialized'):
+            self.json_file = json_file
+            self.initialized = True
+            self.on_response_callback = None
+
+    def create_request(self, type: str) -> str:
+        request_data = {
+            "type": type,
+            "response": None,
+            "timestamp": time.time()
+        }
+
+        with open(self.json_file, "w") as f:
+            json.dump(request_data, f)
+
+        return "Ok"
+
+    def save_response(self, message_text: str) -> bool:
+        try:
+            # Carica il file JSON
+            with open(self.json_file, "r") as f:
+                data = json.load(f)
+
+            # Controlla se esiste la chiave 'type' e se la risposta è presente
+            if "type" in data and "response" in data:
+                data["response"] = message_text  # Aggiorna la risposta
 
-# Fix import
-sys.path.append(os.path.abspath(os.path.join(os.path.dirname(__file__), "..", "..")))
-from StreamingCommunity.TelegramHelp.request_manager import RequestManager
+                with open(self.json_file, "w") as f:
+                    json.dump(data, f, indent=4)
 
+                return True
+            else:
+                return False
+
+        except (FileNotFoundError, json.JSONDecodeError) as e:
+            print(f"⚠️ save_response - errore: {e}")
+            return False
+
+    def get_response(self) -> Optional[str]:
+        try:
+            with open(self.json_file, "r") as f:
+                data = json.load(f)
+
+                # Verifica se esiste la chiave "response"
+                if "response" in data:
+                    response = data["response"]  # Ottieni la risposta direttamente
+
+                    if response is not None and self.on_response_callback:
+                        self.on_response_callback(response)
+
+                    return response
+
+        except (FileNotFoundError, json.JSONDecodeError) as e:
+            print(f"get_response - errore: {e}")
+        return None
+
+    def clear_file(self) -> bool:
+        try:
+            with open(self.json_file, "w") as f:
+                json.dump({}, f)
+            print(f"File {self.json_file} è stato svuotato con successo.")
+            return True
+
+        except Exception as e:
+            print(f"⚠️ clear_file - errore: {e}")
+            return False
 
 # Funzione per caricare variabili da un file .env
 def load_env(file_path="../../.env"):
@@ -44,13 +169,17 @@ class TelegramBot:
             if os.path.exists(cls._config_file):
                 with open(cls._config_file, "r") as f:
                     config = json.load(f)
-                cls._instance = cls.init_bot(
-                    config["token"], config["authorized_user_id"]
-                )
+
+                # Assicura che authorized_user_id venga trattato come una lista
+                authorized_users = config.get('authorized_user_id', [])
+                if isinstance(authorized_users, str):
+                    authorized_users = [int(uid) for uid in authorized_users.split(",") if uid.strip().isdigit()]
+
+                cls._instance = cls.init_bot(config['token'], authorized_users)
+                #cls._instance = cls.init_bot(config['token'], config['authorized_user_id'])
+
             else:
-                raise Exception(
-                    "Bot non ancora inizializzato. Chiamare prima init_bot() con token e authorized_user_id"
-                )
+                raise Exception("Bot non ancora inizializzato. Chiamare prima init_bot() con token e authorized_user_id")
         return cls._instance
 
     @classmethod
@@ -63,7 +192,8 @@ class TelegramBot:
                 json.dump(config, f)
         return cls._instance
 
-    def __init__(self, token, authorized_user_id):
+    def __init__(self, token, authorized_users):
+
         def monitor_scripts():
             while True:
                 try:
@@ -132,10 +262,10 @@ class TelegramBot:
             )
 
         self.token = token
-        self.authorized_user_id = authorized_user_id
-        self.chat_id = authorized_user_id
+        self.authorized_users = authorized_users
+        self.chat_id = authorized_users
         self.bot = telebot.TeleBot(token)
-        self.request_manager = RequestManager()
+        self.request_manager = TelegramRequestManager()
 
         # Registra gli handler
         self.register_handlers()
@@ -171,7 +301,7 @@ class TelegramBot:
             self.handle_response(message)
 
     def is_authorized(self, user_id):
-        return user_id == self.authorized_user_id
+        return user_id in self.authorized_users
 
     def handle_get_id(self, message):
         if not self.is_authorized(message.from_user.id):
@@ -194,7 +324,6 @@ class TelegramBot:
 
         screen_id = str(uuid.uuid4())[:8]
         debug_mode = os.getenv("DEBUG")
-        verbose = debug_mode
 
         if debug_mode == "True":
             subprocess.Popen(["python3", "../../test_run.py", screen_id])
@@ -407,6 +536,13 @@ class TelegramBot:
         temp_file = f"/tmp/screen_output_{screen_id}.txt"
 
         try:
+            # Verifica se lo screen con l'ID specificato esiste
+            existing_screens = subprocess.check_output(["screen", "-list"]).decode('utf-8')
+            if screen_id not in existing_screens:
+                print(f"⚠️ La sessione screen con ID {screen_id} non esiste.")
+                self.bot.send_message(message.chat.id, f"⚠️ La sessione screen con ID {screen_id} non esiste.")
+                return
+
             # Cattura l'output della screen
             subprocess.run(
                 ["screen", "-X", "-S", screen_id, "hardcopy", "-h", temp_file],
@@ -440,51 +576,22 @@ class TelegramBot:
                 "\n\n", "\n"
             )  # Rimuovi newline multipli
 
-            # Estrarre tutte le parti da "Download:" fino a "Video" o "Subtitle", senza includerli
-            download_matches = re.findall(
-                r"Download: (.*?)(?:Video|Subtitle)", cleaned_output
-            )
-            if download_matches:
-                # Serie TV e Film StreamingCommunity
-
-                proc_matches = re.findall(r"Proc: ([\d\.]+%)", cleaned_output)
-
-                # Creare una stringa unica con tutti i risultati
-                result_string = "\n".join(
-                    [
-                        f"Download: {download_matches[i].strip()}\nDownload al {proc_matches[i]}"
-                        for i in range(len(download_matches))
-                        if i < len(proc_matches)
-                    ]
-                )
-
-                if result_string != "":
-                    cleaned_output = result_string
-                else:
-                    print(f"❌ La parola 'Download:' non è stata trovata nella stringa.")
-            else:
-
-                download_list = []
-
-                # Estrai tutte le righe che iniziano con "Download:" fino al prossimo "Download" o alla fine della riga
-                matches = re.findall(r"Download:\s*(.*?)(?=Download|$)", cleaned_output)
+            # Dentro cleaned_output c'è una stringa recupero quello che si trova tra ## ##
+            download_section = re.search(r"##(.*?)##", cleaned_output, re.DOTALL)
+            if download_section:
+                cleaned_output_0 = "Download: " + download_section.group(1).strip()
 
-                # Se sono stati trovati download, stampali
-                if matches:
-                    for i, match in enumerate(matches, 1):
-                        # rimuovo solo la parte "downloader.py:57Result:400" se esiste
-                        match = re.sub(r"downloader.py:\d+Result:400", "", match)
-                        match = match.strip()  # Rimuovo gli spazi bianchi in eccesso
-                        if match:  # Assicurati che la stringa non sia vuota
-                            print(f"Download {i}: {match}")
+            # Recupero tutto quello che viene dopo con ####
+            download_section_bottom = re.search(r"####(.*)", cleaned_output, re.DOTALL)
+            if download_section_bottom:
+                cleaned_output_1 = download_section_bottom.group(1).strip()
 
-                        # Aggiungi il risultato modificato alla lista
-                        download_list.append(f"Download {i}: {match}")
-
-                    # Creare una stringa unica con tutti i risultati
-                    cleaned_output = "\n".join(download_list)
-                else:
-                    print("❌ Nessun download trovato")
+            # Unico i due risultati se esistono
+            if cleaned_output_0 and cleaned_output_1:
+                cleaned_output = f"{cleaned_output_0}\n{cleaned_output_1}"
+                # Rimuovo 'segments.py:302' e 'downloader.py:385' se presente
+                cleaned_output = re.sub(r'downloader\.py:\d+', '', cleaned_output)
+                cleaned_output = re.sub(r'segments\.py:\d+', '', cleaned_output)
 
             # Invia l'output pulito
             print(f"📄 Output della screen {screen_id}:\n{cleaned_output}")
@@ -505,7 +612,16 @@ class TelegramBot:
         os.remove(temp_file)
 
     def send_message(self, message, choices):
-        if choices is None:
+
+        formatted_message = message
+        if choices:
+            formatted_choices = "\n".join(choices)
+            formatted_message = f"{message}\n\n{formatted_choices}"
+
+        for chat_id in self.authorized_users:
+            self.bot.send_message(chat_id, formatted_message)
+
+        """ if choices is None:
             if self.chat_id:
                 print(f"{message}")
                 self.bot.send_message(self.chat_id, message)
@@ -514,7 +630,7 @@ class TelegramBot:
             message = f"{message}\n\n{formatted_choices}"
             if self.chat_id:
                 print(f"{message}")
-                self.bot.send_message(self.chat_id, message)
+                self.bot.send_message(self.chat_id, message) """
 
     def _send_long_message(self, chat_id, text, chunk_size=4096):
         """Suddivide e invia un messaggio troppo lungo in più parti."""
@@ -527,16 +643,20 @@ class TelegramBot:
 
         if choices is None:
             print(f"{prompt_message}")
-            self.bot.send_message(
+            """ self.bot.send_message(
                 self.chat_id,
                 f"{prompt_message}",
-            )
+            ) """
+            for chat_id in self.authorized_users:  # Manda a tutti gli ID autorizzati
+                self.bot.send_message(chat_id, f"{prompt_message}")
         else:
             print(f"{prompt_message}\n\nOpzioni: {', '.join(choices)}")
-            self.bot.send_message(
+            """ self.bot.send_message(
                 self.chat_id,
                 f"{prompt_message}\n\nOpzioni: {', '.join(choices)}",
-            )
+            ) """
+            for chat_id in self.authorized_users:  # Manda a tutti gli ID autorizzati
+                self.bot.send_message(chat_id, f"{prompt_message}\n\nOpzioni: {', '.join(choices)}")
 
         start_time = time.time()
         while time.time() - start_time < timeout:
@@ -546,7 +666,8 @@ class TelegramBot:
             time.sleep(1)
 
         print(f"⚠️ Timeout: nessuna risposta ricevuta.")
-        self.bot.send_message(self.chat_id, "⚠️ Timeout: nessuna risposta ricevuta.")
+        for chat_id in self.authorized_users:  # Manda a tutti gli ID autorizzati
+            self.bot.send_message(chat_id, "⚠️ Timeout: nessuna risposta ricevuta.")
         self.request_manager.clear_file()
         return None
 
@@ -558,4 +679,37 @@ class TelegramBot:
 
 
 def get_bot_instance():
-    return TelegramBot.get_instance()
+    return TelegramBot.get_instance()
+
+# Esempio di utilizzo
+if __name__ == "__main__":
+
+    # Usa le variabili
+    token = os.getenv("TOKEN_TELEGRAM")
+    authorized_users = os.getenv("AUTHORIZED_USER_ID")
+
+    # Controlla se le variabili sono presenti
+    if not token:
+        print("Errore: TOKEN_TELEGRAM non è definito nel file .env.")
+        sys.exit(1)
+
+    if not authorized_users:
+        print("Errore: AUTHORIZED_USER_ID non è definito nel file .env.")
+        sys.exit(1)
+
+    try:
+        TOKEN = token  # Inserisci il token del tuo bot Telegram sul file .env
+        AUTHORIZED_USER_ID = list(map(int, authorized_users.split(",")))  # Inserisci il tuo ID utente Telegram sul file .env
+    except ValueError as e:
+        print(f"Errore nella conversione degli ID autorizzati: {e}. Controlla il file .env e assicurati che gli ID siano numeri interi separati da virgole.")
+        sys.exit(1)
+
+    # Inizializza il bot
+    bot = TelegramBot.init_bot(TOKEN, AUTHORIZED_USER_ID)
+    bot.run()
+
+"""
+start - Avvia lo script
+list - Lista script attivi
+get - Mostra ID utente Telegram
+"""