TeLLMgramBot 2.1.2__tar.gz → 2.3.0__tar.gz

{tellmgrambot-2.1.2 → tellmgrambot-2.3.0}/LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2023 Digital Heresy
+Copyright (c) 2023-2026 Digital Heresy
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

{tellmgrambot-2.1.2 → tellmgrambot-2.3.0}/PKG-INFO

@@ -1,12 +1,12 @@
 Metadata-Version: 2.4
 Name: TeLLMgramBot
-Version: 2.1.2
+Version: 2.3.0
 Summary: OpenAI GPT, driven by Telegram
 Home-page: https://github.com/Digital-Heresy/TeLLMgramBot
 Author: Digital Heresy
 Author-email: ronin.atx@gmail.com
 License: MIT
-Requires-Python: >=3.10
+Requires-Python: >=3.12
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: openai>2.0
@@ -16,7 +16,7 @@ Requires-Dist: beautifulsoup4
 Requires-Dist: typing
 Requires-Dist: validators
 Requires-Dist: tiktoken>=0.12
-Requires-Dist: python-telegram-bot
+Requires-Dist: python-telegram-bot>20.0
 Dynamic: author
 Dynamic: author-email
 Dynamic: description
@@ -54,8 +54,6 @@ Using Telegram as the interface not only solves "exposing" the interface, but gi
 ## Directories
 When initializing TeLLMgramBot, the following directories get created:
 * `configs` - Contains bot configuration files.
-  * `commands.txt`
-    * Users can type `/help` interacting with the to see this file's text get displayed in Telegram.
   * `config.yaml` (can be a different name)
     * This file sets main OpenAI parameters like naming and GPT models to process.
     * The parameter `url_model` is to read URL content, different than `chat_model` that the bot normally uses to interact with the user.
@@ -64,7 +62,7 @@ When initializing TeLLMgramBot, the following directories get created:
     * This important YAML file contains token size parameters for supported OpenAI models.
     * If the first time, `gpt-5`, `gpt-5-mini`, `gpt-5-nano`, `gpt-4o`, and `gpt-4o-mini` get populated, but the user can specify more models with token size parameters as needed.
 * `prompts` - Contains prompt files for how the bot interacts with any user.
-    * `test_personality.prmpt`
+    * `test_personality.prmpt` (can be a different name)
       * This is a sample prompt file as a basis to test this library.
       * The user can create more prompt files as needed for different personalities. See [OpenAI Playground](https://platform.openai.com/playground) to test some ideas.
     * `url_analysis.prmpt`
@@ -122,12 +120,11 @@ Each file with the associated API key will update its respective environment var
 This library includes an example script `test_local.py`, which uses files from the folders `configs` and `prompts` for TeLLMgramBot to process. The bot communicates with OpenAI via the **Responses API**, which replaces the older Chat Completions endpoint.
 1. Ensure the previous sections are followed with the proper API keys and your Telegram bot set.
 2. Install this library via PIP (`pip install TeLLMgramBot`) and then import into your project.
-3. Instantiate the bot by passing in various configuration pieces needed below:
+3. Instantiate the bot by passing in various configuration pieces needed below.
+   Note the Telegram bot's full name and username auto-populate before startup.
    ```
    telegram_bot = TeLLMgramBot.TelegramBot(
-       bot_username   = <Bot username like 'friendly_bot'>,
        bot_owner      = <Bot owner's Telegram username>,
-       bot_name       = <Bot name like 'Friendly Bot'>,
        bot_nickname   = <Bot nickname like 'Botty'>,
        bot_initials   = <Bot initials like 'FB'>,
        chat_model     = <Conversation model like 'gpt-4o-mini'>,
@@ -142,8 +139,7 @@ This library includes an example script `test_local.py`, which uses files from t
    telegram_bot.start_polling()
    ```
    Once you see `TeLLMgramBot polling...`, the bot is online in Telegram.
-5. Typing `/help` shows all available commands reported by the `configs/commands.txt` file.
-6. Only as owner, type `/start` directly to the bot to initiate user conversations.
+5. Converse! Type `/help` for all available commands.
 
 ## Resources
 * GitHub repository [python-telegram-bot](https://github.com/python-telegram-bot/python-telegram-bot) has guides to create a Telegram bot.

{tellmgrambot-2.1.2 → tellmgrambot-2.3.0}/README.md

@@ -24,8 +24,6 @@ Using Telegram as the interface not only solves "exposing" the interface, but gi
 ## Directories
 When initializing TeLLMgramBot, the following directories get created:
 * `configs` - Contains bot configuration files.
-  * `commands.txt`
-    * Users can type `/help` interacting with the to see this file's text get displayed in Telegram.
   * `config.yaml` (can be a different name)
     * This file sets main OpenAI parameters like naming and GPT models to process.
     * The parameter `url_model` is to read URL content, different than `chat_model` that the bot normally uses to interact with the user.
@@ -34,7 +32,7 @@ When initializing TeLLMgramBot, the following directories get created:
     * This important YAML file contains token size parameters for supported OpenAI models.
     * If the first time, `gpt-5`, `gpt-5-mini`, `gpt-5-nano`, `gpt-4o`, and `gpt-4o-mini` get populated, but the user can specify more models with token size parameters as needed.
 * `prompts` - Contains prompt files for how the bot interacts with any user.
-    * `test_personality.prmpt`
+    * `test_personality.prmpt` (can be a different name)
       * This is a sample prompt file as a basis to test this library.
       * The user can create more prompt files as needed for different personalities. See [OpenAI Playground](https://platform.openai.com/playground) to test some ideas.
     * `url_analysis.prmpt`
@@ -92,12 +90,11 @@ Each file with the associated API key will update its respective environment var
 This library includes an example script `test_local.py`, which uses files from the folders `configs` and `prompts` for TeLLMgramBot to process. The bot communicates with OpenAI via the **Responses API**, which replaces the older Chat Completions endpoint.
 1. Ensure the previous sections are followed with the proper API keys and your Telegram bot set.
 2. Install this library via PIP (`pip install TeLLMgramBot`) and then import into your project.
-3. Instantiate the bot by passing in various configuration pieces needed below:
+3. Instantiate the bot by passing in various configuration pieces needed below.
+   Note the Telegram bot's full name and username auto-populate before startup.
    ```
    telegram_bot = TeLLMgramBot.TelegramBot(
-       bot_username   = <Bot username like 'friendly_bot'>,
        bot_owner      = <Bot owner's Telegram username>,
-       bot_name       = <Bot name like 'Friendly Bot'>,
        bot_nickname   = <Bot nickname like 'Botty'>,
        bot_initials   = <Bot initials like 'FB'>,
        chat_model     = <Conversation model like 'gpt-4o-mini'>,
@@ -112,8 +109,7 @@ This library includes an example script `test_local.py`, which uses files from t
    telegram_bot.start_polling()
    ```
    Once you see `TeLLMgramBot polling...`, the bot is online in Telegram.
-5. Typing `/help` shows all available commands reported by the `configs/commands.txt` file.
-6. Only as owner, type `/start` directly to the bot to initiate user conversations.
+5. Converse! Type `/help` for all available commands.
 
 ## Resources
 * GitHub repository [python-telegram-bot](https://github.com/python-telegram-bot/python-telegram-bot) has guides to create a Telegram bot.

{tellmgrambot-2.1.2 → tellmgrambot-2.3.0}/TeLLMgramBot/TeLLMgramBot.py

@@ -2,63 +2,93 @@
 import os
 import re
 import json
+import asyncio
 from tempfile import gettempdir
 from math import floor
-from telegram import Update
+from telegram import Bot, Update, Message, Chat, User
+from telegram.constants import MessageLimit
 from telegram.ext import Application, CommandHandler, MessageHandler, filters, ContextTypes
 import openai
 
 from .openai_singleton import OpenAIClientSingleton
-from .initialize import INIT_BOT_CONFIG, init_structure, init_bot_config, init_bot_prompt, init_bot_commands
+from .initialize import INIT_BOT_CONFIG, init_structure, init_bot_config, init_bot_prompt
 from .conversation import Conversation
 from .tokenGPT import TokenGPT
 from .message_handlers import handle_greetings, handle_common_queries, handle_url_ask
 from .utils import read_yaml, read_text, exact_word_match, generate_error_path, log_error
 
-
-# noinspection PyMethodMayBeStatic,PyUnusedLocal
 class TelegramBot:
-    # Show all the commands available by the bot using the TelegramCommands.txt file
+    """
+    The bridge between the Telegram interface and Large Langage Model (LLM) using OpenAI's GPT models.
+    - Tokens help retain conversation messages between the Telegram bot assistant and the user.
+    - URLs in [square brackets] can be supplied on how the bot should interpret it.
+    - For more information, see README or: https://github.com/Digital-Heresy/TeLLMgramBot
+    """
+    async def _tele_info(self):
+        """Fetch the Telegram bot's information before running application."""
+        try:
+            bot = await Bot(token=os.environ['TELLMGRAMBOT_TELEGRAM_API_KEY']).get_me()
+            self.telegram['username'] = bot.username
+            self.telegram['name'] = bot.full_name
+        except Exception as e:
+            # Fail fast if the bot's identity cannot be fetched to avoid
+            # continuing with an uninitialized self.telegram['username'].
+            log_error(e, error_type='Telegram', error_filename=self.error_log)
+            raise
+
     async def tele_commands(self, update: Update, context: ContextTypes.DEFAULT_TYPE):
-        reply = ''
-        with open(init_bot_commands('commands.txt'), "r", encoding="utf-8") as file:
-            for line in file:
-                reply += line
-        await update.message.reply_text(reply)
+        """Show all the commands available when the user sends `/help` to the bot."""
+        await update.message.reply_text("TeLLMgramBot commands:\n"
+            "/nick - Set your nickname (e.g. \"/nick B0b #2\").\n"
+            "/forget - Clear all of your conversations.\n"
+            "/help - Display this usage information.\n\n"
+            "You must have a username to converse (for now).\n"
+            "Chat history will still show in your Telegram client.\n\n"
+            "Administrator-only commands:\n"
+            "/start - Go online to receive new responses (default).\n"
+            "/stop - Go offline to prevent new responses.\n"
+        )
 
-    # Start command only runs by the 'bot_owner' specified in configuration file 
     async def tele_start_command(self, update: Update, context: ContextTypes.DEFAULT_TYPE):
+        """A bot_owner-only command to go online and handle any new messages."""
         uname = update.message.from_user.username
         if uname == self.telegram['owner']:
+            self._online = True
             greeting_text = f"Oh, hello {update.message.from_user.first_name}! Let me get to work!"
             await update.message.reply_text(greeting_text)
-            self.started = True
-            self.GPTOnline = True
         else:
-            await update.message.reply_text("Sorry, but I'm off the clock at the moment.")
+            await update.message.reply_text("Sorry, I can't do that for you.")
 
-    # Stop command formally closes out the polling loop
     async def tele_stop_command(self, update: Update, context: ContextTypes.DEFAULT_TYPE):
+        """A bot_owner-only command to go offline and not handle any new messages."""
         uname = update.message.from_user.username
         if uname == self.telegram['owner']:
-            self.GPTOnline = False
+            self._online = False
             await update.message.reply_text("Sure thing boss, cutting out!")
         else:
             await update.message.reply_text("Sorry, I can't do that for you.")
 
-    # Let bot know to call the user by a different name other than the Telegram user name
-    # noinspection RegExpRedundantEscape,PyArgumentList
     async def tele_nick_command(self, update: Update, context: ContextTypes.DEFAULT_TYPE):
-        # Must follow the format of "/nick <nickname>" using regular expression
-        result = re.search(r'^\/nick[ \n]+([ \S]+)', update.message.text)
-        if result is not None:
+        """
+        Let bot assistant know to call the user by a different name other than the Telegram username.
+        Must follow the format of "/nick(@<bot name>)? <nickname>", checked by a regular expression.
+        """
+        validated = await self.tele_validate(update)
+        if not validated:
+            return
+        (msg, chat, user) = validated
+
+        # If it's a group conversation, need to handle commands directly to bot with @<bot name> also
+        pattern = re.compile(fr"^\s*/nick(?:@{re.escape(self.telegram['username'])})?\s+(.+?)\s*$", re.IGNORECASE)
+        result = pattern.search(msg.text or "")
+        if result:
             prompt = f"Please refer to me by my nickname, {result.group(1).strip()}, rather than my user name."
-            await update.message.reply_text(await self.tele_handle_response(text=prompt, update=update))
+            await msg.reply_text(await self.tele_handle_response(prompt, msg))
         else:
-            await update.message.reply_text("Please provide a valid nickname after the command like \"/nick B0b #2\".")
+            await msg.reply_text("Please provide a valid nickname after the command like \"/nick B0b #2\".")
 
-    # Remove the whole conversation including past session logs for peace of mind
     async def tele_forget_command(self, update: Update, context: ContextTypes.DEFAULT_TYPE):
+        """Remove the whole conversation including past session logs for peace of mind."""
         uname = update.message.from_user.username
         if uname in self.conversations:
             self.conversations[uname].clear_interaction()
@@ -70,17 +100,24 @@ class TelegramBot:
                 " already asked me to forget about you. Either way, nice to meet you!"
             )
 
-    # Responses
-    async def tele_handle_response(self, text: str, update: Update) -> str:
-        # Before we handle messages, ensure a user has /started us
+    async def tele_handle_response(self, text: str, msg: Message) -> str:
+        """
+        Primary function for handling any response including Generative AI, ensuring:
+        - The owner started up the bot assistant for user interactions.
+        - User has conversed with the bot assistant before.
+        - Depending on regular interaction or URL request, formulate message based
+          on the Generative AI model (e.g. OpenAI GPT) and token count checks.
+        """
         # Starting ensures we get some kind of user account details for logging
-        not_started_reply = "I'd love to chat, but please wait as I haven't started up yet!"
-        if not self.started:
-            return not_started_reply
+        if not self._online:
+            return "I'd love to chat, but I am offline at the moment!"
+
+        # Print information of the user sending message for conversation
+        uname = msg.from_user.username
+        print(f"User {uname} in {msg.chat.type} chat ID {str(msg.chat.id)}")
 
         # For a new session, track if the user has conversed with the Telegram bot before
         # Username is consistent across restarts and different conversation instances
-        uname = update.message.from_user.username
         if uname not in self.conversations:
             self.conversations[uname] = Conversation(
                 uname,
@@ -101,16 +138,16 @@ class TelegramBot:
 
         # Form the assistant's message based on low level easy stuff or send to GPT
         # OpenAI's Responses API relies on the maximum number of tokens the selected model can support
-        reply = not_started_reply
+        reply = "Sorry, I couldn't process your message! Please contact my creator."
         if handle_greetings(text):
             reply = handle_greetings(text)
         elif handle_common_queries(text):
             reply = handle_common_queries(text)
         elif url_match:
             # URL content is passed into another model to summarize (GPT-4 preferred)
-            await update.message.reply_text("Sure, give me a moment to look at that URL...")
+            await msg.reply_text("Sure, give me a moment to look at that URL...")
             reply = await handle_url_ask(text, self.chatgpt['url_model'])
-        elif self.GPTOnline:
+        elif self._online:
             # This is essentially the transition point between quick Telegram replies and GPT
             response = await self.gpt_completion(uname)
             reply = response.choices[0].message.content
@@ -121,10 +158,10 @@ class TelegramBot:
         # If the user is getting closer to the bot's token threshold, warn the first time
         if token_count > self.chatgpt['prune_back_to'] and uname not in self.token_warning:
             reply += ("\n\n"
-                      "By the way, our conversation will soon reach my token limit, so I may"
-                      " start forgetting some of our older exchanges. Would you like me to"
-                      " summarize our conversation so far to keep the main points alive?"
-                      )
+                "By the way, our conversation will soon reach my token limit, so I may"
+                " start forgetting some of our older exchanges. Would you like me to"
+                " summarize our conversation so far to keep the main points alive?"
+            )
             self.token_warning[uname] = True
 
         # Add assistant's message to the user's conversation
@@ -136,53 +173,81 @@ class TelegramBot:
 
         return reply
 
-    # Handles the Telegram side of the message, discerning between Private and Group conversation
-    async def tele_handle_message(self, update: Update, context=ContextTypes.DEFAULT_TYPE):
-        message_type: str = update.message.chat.type  # PM or Group Chat
-        message_text: str = update.message.text
-        message_print = f"User {update.message.from_user.username} in {message_type} chat ID {update.message.chat.id}"
+    async def tele_handle_message(self, update: Update, context: ContextTypes.DEFAULT_TYPE):
+        """Handles the Telegram side of the message, discerning between Private and Group conversation."""
+        validated = await self.tele_validate(update)
+        if not validated:
+            return
+        (msg, chat, user) = validated
 
         # If it's a group text, only reply if the bot is named
         # The real magic of how the bot behaves is in tele_handle_response()
-        if message_type == 'supergroup' or message_type == 'group':
-            if exact_word_match(self.telegram['username'], message_text):
-                print(message_print)
-                new_text: str = message_text.replace(self.telegram['username'], '').strip()
-                response: str = await self.tele_handle_response(text=new_text, update=update)
+        response = "Sorry, I couldn't process your message! Please contact my creator."
+        if chat.type == 'supergroup' or chat.type == 'group':
+            if exact_word_match(self.telegram['username'], msg.text):
+                pattern = r'@?\b' + re.escape(self.telegram['username']) + r'\b'
+                new_text = re.sub(pattern, '', msg.text).strip()
+                response = await self.tele_handle_response(new_text, msg)
             elif (
-                exact_word_match(self.telegram['nickname'], message_text) or
-                exact_word_match(self.telegram['initials'], message_text)
+                exact_word_match(self.telegram['nickname'], msg.text) or
+                exact_word_match(self.telegram['initials'], msg.text)
             ):
-                print(message_print)
-                response: str = await self.tele_handle_response(text=message_text, update=update)
+                response = await self.tele_handle_response(msg.text, msg)
             else:
                 return
-        elif message_type == 'private':
-            print(message_print)
-            response: str = await self.tele_handle_response(text=message_text, update=update)
+        elif chat.type == 'private':
+            response = await self.tele_handle_response(msg.text, msg)
         else:
             return
-        await update.message.reply_text(response)
 
-    # Handle errors caused on the Telegram side
-    async def tele_error(self, update: Update, context: ContextTypes.DEFAULT_TYPE):
-        if update.message.from_user.username is None:
-            # If the user doesn't have a Telegram username, we can't really do anything
-            await update.message.reply_text('Add a username to your Telegram account so that I can talk to you!')
+        # Split into smaller chunks since Telegram messages have a maximum text length (likely 4096)
+        chunk_length = MessageLimit.MAX_TEXT_LENGTH - 1
+        for chunk in [response[i:i+chunk_length] for i in range(0, len(response), chunk_length)]:
+            await msg.reply_text(chunk)
+            await asyncio.sleep(0.12)  # small pause to reduce risk of rate limiting
+
+    async def tele_validate(self, update: Update) -> tuple[Message, Chat, User] | None:
+        """
+        Check if any update through Telegram has a complete message, chat, and user.
+        This uses python-telegram-bot's Update `effective` methods for all three.
+        """
+        if update is None:
+            return None
+
+        # Any python-telegram-bot 'effective' method helps ensure there are no "None" types
+        # Non-user updates like Inline queries or chat member updates makes either one undefined
+        msg  = update.effective_message
+        chat = update.effective_chat
+        user = update.effective_user
+
+        # If there is no chat or valid message of the unique conversation, no reason to reply
+        if chat is None or msg is None:
+            return None
+        # chat.type => 'private', 'group', 'supergroup', 'channel'
+        # chat.id = user.id if 'private'
+
+        # Handle the user sending the message
+        if user:
+            # This ensures conversations don't overlap (for now, until user.id is implemented)
+            uname = getattr(user, "username", None)
+            if uname is None:
+                await msg.reply_text('Add a username to your Telegram account so that I can talk to you!')
+                return None
         else:
-            log_error(context.error, error_type='Telegram', error_filename=self.error_log)
-            await update.message.reply_text("Sorry, I ran into an error! Please contact my creator.")
-
-    # Read the GPT Conversation so far
-    @staticmethod
-    def gpt_read_interactions(file_path: str):
-        with open(file_path, 'r') as interaction_log:
-            lines = interaction_log.readlines()
-        formatted_messages = [json.loads(line) for line in lines]
-        return formatted_messages
-
-    # Get the OpenAI response based on bot configuration
+            # If not the user chatting directly to the bot, don't bother
+            return None
+
+        return (msg, chat, user)
+
+    async def tele_error(self, update: Update, context: ContextTypes.DEFAULT_TYPE):
+        """Handle any conversation error caused on the Telegram side."""
+        log_error(context.error, error_type='Telegram', error_filename=self.error_log)
+        msg = update.effective_message if update else None
+        if msg:
+            await msg.reply_text("Sorry, I ran into an error! Please contact my creator.")
+
     async def gpt_completion(self, uname: str):
+        """Get the OpenAI response based on bot configuration."""
         try:
             client = OpenAIClientSingleton.get_instance()
             response = await client.chat.completions.create(
@@ -190,7 +255,6 @@ class TelegramBot:
                 messages=self.conversations[uname].messages,
             )
             return response
-
         except openai.AuthenticationError as e:
             # Handle authentication error
             log_error(e, error_type='OpenAI-Authentication', error_filename=self.error_log)
@@ -211,47 +275,51 @@ class TelegramBot:
             # Catch any other unexpected exceptions
             log_error(e, error_type='Other', error_filename=self.error_log)
 
-    # The main polling "loop" the user interacts with via Telegram
     def start_polling(self):
+        """The main polling "loop" the user interacts with via Telegram."""
         print(f"TeLLMgramBot {self.telegram['username']} polling...")
         self.telegram['app'].run_polling(poll_interval=self.telegram['pollinterval'])
         print(f"TeLLMgramBot {self.telegram['username']} polling ended.")
 
     # Initialization
     def __init__(self,
-                 bot_username   = INIT_BOT_CONFIG['bot_username'],
-                 bot_owner      = INIT_BOT_CONFIG['bot_owner'],
-                 bot_name       = INIT_BOT_CONFIG['bot_name'],
-                 bot_nickname   = INIT_BOT_CONFIG['bot_nickname'],
-                 bot_initials   = INIT_BOT_CONFIG['bot_initials'],
-                 chat_model     = INIT_BOT_CONFIG['chat_model'],
-                 url_model      = INIT_BOT_CONFIG['url_model'],
-                 token_limit    = INIT_BOT_CONFIG['token_limit'],
-                 persona_temp   = INIT_BOT_CONFIG['persona_temp'],
-                 persona_prompt = INIT_BOT_CONFIG['persona_prompt']
-                 ):
+        bot_owner      = INIT_BOT_CONFIG['bot_owner'],
+        bot_nickname   = INIT_BOT_CONFIG['bot_nickname'],
+        bot_initials   = INIT_BOT_CONFIG['bot_initials'],
+        chat_model     = INIT_BOT_CONFIG['chat_model'],
+        url_model      = INIT_BOT_CONFIG['url_model'],
+        token_limit    = INIT_BOT_CONFIG['token_limit'],
+        persona_temp   = INIT_BOT_CONFIG['persona_temp'],
+        persona_prompt = INIT_BOT_CONFIG['persona_prompt']
+    ):
+        # Starting to initialize, not online yet
+        self._online = False
+
         # First provide the main structure if not already there
         init_structure()
 
-        # Set up our variables
+        # Initialize some variables
         self.error_log = generate_error_path()
-        self.started = False
-        self.GPTOnline = False
-        self.token_warning = {}  # Determines whether user has reached token limit by OpenAI model
+        self.token_warning = {}  # Determines whether user has reached token limit by AI model
         self.conversations = {}  # Provides Conversation class per user based on bot response
-
-        # Get Telegram Spun Up
-        # noinspection PyDictCreation
         self.telegram = {
             'owner'        : bot_owner,
-            'username'     : bot_username,
             'nickname'     : bot_nickname,
             'initials'     : bot_initials,
             'pollinterval' : 3
         }
-        self.telegram['app'] = Application.builder().token(os.environ['TELLMGRAMBOT_TELEGRAM_API_KEY']).build()
+        # Check for event running loops before getting the bot's information
+        try:
+            loop = asyncio.get_running_loop()
+        except RuntimeError:
+            # No running event loop; safe to run synchronously
+            asyncio.run(self._tele_info())
+        else:
+            # Already in an event loop; schedule as a background task
+            loop.create_task(self._tele_info())
 
-        # Add our handlers for Commands, Messages, and Errors
+        # Build our application with handlers for Commands, Messages, and Errors
+        self.telegram['app'] = Application.builder().token(os.environ['TELLMGRAMBOT_TELEGRAM_API_KEY']).build()
         self.telegram['app'].add_handler(CommandHandler('help', self.tele_commands))
         self.telegram['app'].add_handler(CommandHandler('start', self.tele_start_command))
         self.telegram['app'].add_handler(CommandHandler('stop', self.tele_stop_command))
@@ -263,7 +331,6 @@ class TelegramBot:
         # Get our LLM spun up with defaults if not defined by user input
         # Tokens as integers measure the length of conversation messages
         self.chatgpt = {
-            'name'        : bot_name,
             'prompt'      : persona_prompt,
             'chat_model'  : chat_model,
             'url_model'   : url_model,
@@ -276,9 +343,11 @@ class TelegramBot:
         self.chatgpt['prune_threshold'] = floor(0.95 * self.chatgpt['token_limit'])
         self.chatgpt['prune_back_to'] = max(0, self.chatgpt['prune_threshold'] - 500)
 
-    # Sets TeLLMgramBot object based on its YAML configuration and prompt files
-    # noinspection PyMethodParameters
+        # Bot is now ready and active by default
+        self._online = True 
+
     def set(config_file='config.yaml', prompt_file='test_personality.prmpt'):
+        """Set TeLLMgramBot object based on its YAML configuration and prompt files."""
         # First provide the main structure if not already there
         init_structure()
 
@@ -301,9 +370,7 @@ class TelegramBot:
 
         # Apply parameters to bot:
         return TelegramBot(
-            bot_username   = config['bot_username'],
             bot_owner      = config['bot_owner'],
-            bot_name       = config['bot_name'],
             bot_nickname   = config['bot_nickname'],
             bot_initials   = config['bot_initials'],
             chat_model     = config['chat_model'],