conn = None

try:

conn = sqlite3.connect(DB_NAME)

cursor = conn.cursor()

cursor.execute("""

""")

cursor.execute("CREATE INDEX IF NOT EXISTS idx_username ON users (username)")

cursor.execute("""

""")

cursor.execute("""

""")

cursor.execute("""

""")

cursor.execute("""

""")

conn.commit()

logger.info(f"Database '{DB_NAME}' initialized successfully (tables users, blacklist, sudo_users ensured).")

except sqlite3.Error as e:

logger.error(f"SQLite error during DB initialization: {e}", exc_info=True)

finally:

if conn:

conn = None

try:

conn = sqlite3.connect(DB_NAME)

cursor = conn.cursor()

current_timestamp_iso = datetime.now(timezone.utc).isoformat()

cursor.execute(

"INSERT OR IGNORE INTO blacklist (user_id, reason, banned_by_id, timestamp) VALUES (?, ?, ?, ?)",

(user_id, reason, banned_by_id, current_timestamp_iso)

)

conn.commit()

return cursor.rowcount > 0

except sqlite3.Error as e:

logger.error(f"SQLite error adding user {user_id} to blacklist: {e}", exc_info=True)

return False

finally:

if conn:

conn = None

try:

conn = sqlite3.connect(DB_NAME)

cursor = conn.cursor()

cursor.execute("DELETE FROM blacklist WHERE user_id = ?", (user_id,))

conn.commit()

return cursor.rowcount > 0

except sqlite3.Error as e:

logger.error(f"SQLite error removing user {user_id} from blacklist: {e}", exc_info=True)

return False

finally:

if conn:

conn = None

try:

conn = sqlite3.connect(DB_NAME)

cursor = conn.cursor()

cursor.execute("SELECT reason FROM blacklist WHERE user_id = ?", (user_id,))

row = cursor.fetchone()

if row:

return row[0]

return None

except sqlite3.Error as e:

logger.error(f"SQLite error checking blacklist reason for user {user_id}: {e}", exc_info=True)

return None

finally:

if conn:

if not update.message or not update.effective_user:

return

user = update.effective_user

if user.id == OWNER_ID:

return

if is_user_blacklisted(user.id):

user_mention_log = f"@{user.username}" if user.username else str(user.id)

message_text_preview = update.message.text[:50] if update.message.text else "[No text content]"

logger.info(f"User {user.id} ({user_mention_log}) is blacklisted. Silently ignoring and blocking interaction: '{message_text_preview}'")

"""Adds a user to the sudo list."""

conn = None

try:

conn = sqlite3.connect(DB_NAME)

cursor = conn.cursor()

current_timestamp_iso = datetime.now(timezone.utc).isoformat()

cursor.execute(

"INSERT OR IGNORE INTO sudo_users (user_id, added_by_id, timestamp) VALUES (?, ?, ?)",

(user_id, added_by_id, current_timestamp_iso)

)

conn.commit()

return cursor.rowcount > 0

except sqlite3.Error as e:

logger.error(f"SQLite error adding sudo user {user_id}: {e}", exc_info=True)

return False

finally:

if conn:

"""Removes a user from the sudo list."""

conn = None

try:

conn = sqlite3.connect(DB_NAME)

cursor = conn.cursor()

cursor.execute("DELETE FROM sudo_users WHERE user_id = ?", (user_id,))

conn.commit()

return cursor.rowcount > 0

except sqlite3.Error as e:

logger.error(f"SQLite error removing sudo user {user_id}: {e}", exc_info=True)

return False

finally:

if conn:

"""Checks if a user is on the sudo list (specifically, not checking if they are THE owner)."""

conn = None

try:

conn = sqlite3.connect(DB_NAME)

cursor = conn.cursor()

cursor.execute("SELECT 1 FROM sudo_users WHERE user_id = ?", (user_id,))

return cursor.fetchone() is not None

except sqlite3.Error as e:

logger.error(f"SQLite error checking sudo for user {user_id}: {e}", exc_info=True)

return False

finally:

if conn:

"""Checks if the user is the Owner or a Sudo user."""

if user_id == OWNER_ID:

return True

if not user:

return

conn = None

try:

conn = sqlite3.connect(DB_NAME)

cursor = conn.cursor()

current_timestamp_iso = datetime.now(timezone.utc).isoformat()

cursor.execute("""

""", (

user.id, user.username, user.first_name, user.last_name,

user.language_code, 1 if user.is_bot else 0, current_timestamp_iso

))

conn.commit()

except sqlite3.Error as e:

logger.error(f"SQLite error updating user {user.id} in users table: {e}", exc_info=True)

finally:

if conn:

if not username_query:

return None

conn = None

user_obj: User | None = None

try:

conn = sqlite3.connect(DB_NAME)

cursor = conn.cursor()

normalized_username = username_query.lstrip('@').lower()

cursor.execute(

"SELECT user_id, username, first_name, last_name, language_code, is_bot FROM users WHERE LOWER(username) = ?",

(normalized_username,)

)

row = cursor.fetchone()

if row:

user_obj = User(

id=row[0], username=row[1], first_name=row[2] or "",

last_name=row[3], language_code=row[4], is_bot=bool(row[5])

)

logger.info(f"User {username_query} found in DB with ID {row[0]}.")

except sqlite3.Error as e:

logger.error(f"SQLite error fetching user by username '{username_query}': {e}", exc_info=True)

finally:

if conn:

conn.close()

if update.effective_user:

update_user_in_db(update.effective_user)

if update.message and update.message.reply_to_message and update.message.reply_to_message.from_user:

update_user_in_db(update.message.reply_to_message.from_user)

chat = update.effective_chat

if chat and chat.type in [ChatType.GROUP, ChatType.SUPERGROUP]:

if 'known_chats' not in context.bot_data:

context.bot_data['known_chats'] = set()

try:

with sqlite3.connect(DB_NAME) as conn:

cursor = conn.cursor()

known_ids = {row[0] for row in cursor.execute("SELECT chat_id FROM bot_chats")}

context.bot_data['known_chats'] = known_ids

logger.info(f"Loaded {len(known_ids)} known chats into cache.")

except sqlite3.Error as e:

logger.error(f"Could not preload known chats into cache: {e}")

if chat.id not in context.bot_data['known_chats']:

logger.info(f"Passively discovered and adding new chat to DB: {chat.title} ({chat.id})")

add_chat_to_db(chat.id, chat.title or f"Untitled Chat {chat.id}")

conn = None

sudo_list = []

try:

conn = sqlite3.connect(DB_NAME)

cursor = conn.cursor()

cursor.execute("SELECT user_id, timestamp FROM sudo_users ORDER BY timestamp DESC")

rows = cursor.fetchall()

for row in rows:

sudo_list.append((row[0], row[1]))

except sqlite3.Error as e:

logger.error(f"SQLite error fetching all sudo users: {e}", exc_info=True)

finally:

if conn:

conn.close()

if not duration_str:

return None

duration_str = duration_str.lower()

value = 0

unit = None

match = re.match(r"(\d+)([smhdw])", duration_str)

if match:

value = int(match.group(1))

unit = match.group(2)

else:

try:

value = int(duration_str)

unit = 'm'

except ValueError:

return None

if unit == 's': return timedelta(seconds=value)

elif unit == 'm': return timedelta(minutes=value)

elif unit == 'h': return timedelta(hours=value)

elif unit == 'd': return timedelta(days=value)

elif unit == 'w': return timedelta(weeks=value)

target_arg: str | None = None

duration_arg: str | None = None

reason_list: list[str] = []

if not args: return None, None, None

target_arg = args[0]

remaining_args = args[1:]

if remaining_args:

potential_duration_td = parse_duration_to_timedelta(remaining_args[0])

if potential_duration_td is not None:

duration_arg = remaining_args[0]

reason_list = remaining_args[1:]

else:

reason_list = remaining_args

reason_str = " ".join(reason_list) if reason_list else None

target_arg: str | None = None

custom_title_full: str | None = None

if not args:

return None, None

target_arg = args[0]

if len(args) > 1:

custom_title_full = " ".join(args[1:])

"""

try:

await update.message.reply_text(text=text, **kwargs)

except telegram.error.BadRequest as e:

if "Message to be replied not found" in str(e):

logger.warning("Original message not found for reply. Sending as a new message.")

await context.bot.send_message(chat_id=update.effective_chat.id, text=text, **kwargs)

else:

update: Update,

context: ContextTypes.DEFAULT_TYPE,

permission: str,

failure_message: str,

allow_bot_privileged_override: bool = True

) -> bool:

user = update.effective_user

chat = update.effective_chat

if allow_bot_privileged_override and is_privileged_user(user.id):

return True

try:

actor_chat_member = await context.bot.get_chat_member(chat.id, user.id)

if actor_chat_member.status == "creator":

return True

if actor_chat_member.status == "administrator" and getattr(actor_chat_member, permission, False):

return True

except TelegramError as e:

logger.error(f"Error checking permissions for {user.id} in chat {chat.id}: {e}")

await send_safe_reply(update, context, text="Mrow? Couldn't verify your permissions due to an API error.")

return False

await send_safe_reply(update, context, text=failure_message)

total_seconds = int(delta.total_seconds())

if total_seconds < 0:

return "0s"

days, rem = divmod(total_seconds, 86400)

hours, rem = divmod(rem, 3600)

minutes, seconds = divmod(rem, 60)

parts = []

if days > 0:

parts.append(f"{days}d")

if hours > 0:

parts.append(f"{hours}h")

if minutes > 0:

parts.append(f"{minutes}m")

if not parts and seconds >= 0 :

parts.append(f"{seconds}s")

elif seconds > 0:

parts.append(f"{seconds}s")

reason = reason or "No reason provided."

try:

with sqlite3.connect(DB_NAME) as conn:

cursor = conn.cursor()

timestamp = datetime.now(timezone.utc).isoformat()

cursor.execute(

"INSERT OR REPLACE INTO global_bans (user_id, reason, banned_by_id, timestamp) VALUES (?, ?, ?, ?)",

(user_id, reason, banned_by_id, timestamp)

)

return cursor.rowcount > 0

except sqlite3.Error as e:

logger.error(f"SQLite error adding user {user_id} to gban list: {e}")

try:

with sqlite3.connect(DB_NAME) as conn:

cursor = conn.cursor()

cursor.execute("DELETE FROM global_bans WHERE user_id = ?", (user_id,))

return cursor.rowcount > 0

except sqlite3.Error as e:

logger.error(f"SQLite error removing user {user_id} from gban list: {e}")

try:

with sqlite3.connect(DB_NAME) as conn:

cursor = conn.cursor()

cursor.execute("SELECT reason FROM global_bans WHERE user_id = ?", (user_id,))

row = cursor.fetchone()

return row[0] if row else None

except sqlite3.Error as e:

logger.error(f"SQLite error checking gban status for user {user_id}: {e}")

try:

with sqlite3.connect(DB_NAME) as conn:

cursor = conn.cursor()

timestamp = datetime.now(timezone.utc).isoformat()

cursor.execute(

"INSERT OR REPLACE INTO bot_chats (chat_id, chat_title, added_at) VALUES (?, ?, ?)",

(chat_id, chat_title, timestamp)

)

except sqlite3.Error as e:

try:

with sqlite3.connect(DB_NAME) as conn:

cursor = conn.cursor()

cursor.execute("DELETE FROM bot_chats WHERE chat_id = ?", (chat_id,))

except sqlite3.Error as e:

"""Checks if gban enforcement is enabled for a specific chat."""

try:

with sqlite3.connect(DB_NAME) as conn:

cursor = conn.cursor()

res = cursor.execute(

"SELECT enforce_gban FROM bot_chats WHERE chat_id = ?", (chat_id,)

).fetchone()

if res is None:

return True

return bool(res[0])

except sqlite3.Error as e:

logger.error(f"Could not check gban enforcement status for chat {chat_id}: {e}")

is_protected = False; is_owner_match = False; bot_username = context.bot.username

if bot_username and target_mention.lower() == f"@{bot_username.lower()}": is_protected = True

elif OWNER_ID:

owner_username = None

try: owner_chat = await context.bot.get_chat(OWNER_ID); owner_username = owner_chat.username

except Exception as e: logger.warning(f"Could not fetch owner username for protection check: {e}")

if owner_username and target_mention.lower() == f"@{owner_username.lower()}": is_protected = True; is_owner_match = True

if not TENOR_API_KEY: return None

if not search_terms: logger.warning("No search terms for get_themed_gif."); return None

search_term = random.choice(search_terms); logger.info(f"Searching Tenor: '{search_term}'")

url = "https://tenor.googleapis.com/v2/search"; params = { "q": search_term, "key": TENOR_API_KEY, "client_key": "my_cat_bot_project_py", "limit": 15, "media_filter": "gif", "contentfilter": "medium", "random": "true" }

try:

response = requests.get(url, params=params, timeout=7)

if response.status_code != 200:

logger.error(f"Tenor API failed for '{search_term}', status: {response.status_code}")

try: error_content = response.json(); logger.error(f"Tenor error content: {error_content}")

except requests.exceptions.JSONDecodeError: logger.error(f"Tenor error response (non-JSON): {response.text[:500]}")

return None

data = response.json(); results = data.get("results")

if results:

selected_gif = random.choice(results); gif_url = selected_gif.get("media_formats", {}).get("gif", {}).get("url")

if not gif_url: gif_url = selected_gif.get("media_formats", {}).get("tinygif", {}).get("url")

if gif_url: logger.info(f"Found GIF URL: {gif_url}"); return gif_url

else: logger.warning(f"Could not extract GIF URL from Tenor item for '{search_term}'.")

else: logger.warning(f"No results on Tenor for '{search_term}'."); logger.debug(f"Tenor response (no results): {data}")

except requests.exceptions.Timeout: logger.error(f"Timeout fetching GIF from Tenor for '{search_term}'.")

except requests.exceptions.RequestException as e: logger.error(f"Network/Request error fetching GIF from Tenor: {e}")

except Exception as e: logger.error(f"Unexpected error in get_themed_gif for '{search_term}': {e}", exc_info=True)

user = update.effective_user

welcome_message = f"Meow {user.mention_html()}! I'm the Meow Bot. 🐾\nUse /help to see available commands!"

if context.args:

if context.args[0] == 'help':

await update.message.reply_html(HELP_TEXT, disable_web_page_preview=True)

return

if context.args[0] == 'sudocmds':

if not is_privileged_user(user.id):

return

final_sudo_help = SUDO_COMMANDS_TEXT

if user.id == OWNER_ID:

final_sudo_help += "\n" + OWNER_COMMANDS_TEXT

await update.message.reply_html(final_sudo_help, disable_web_page_preview=True)

return

chat = update.effective_chat

if chat.type == ChatType.PRIVATE:

await update.message.reply_html(HELP_TEXT, disable_web_page_preview=True)

return

bot_username = context.bot.username

deep_link_url = f"https://t.me/{bot_username}?start=help"

keyboard = InlineKeyboardMarkup(

[

[InlineKeyboardButton(text="📬 Get Help (PM)", url=deep_link_url)]

]

)

message_text = "Meeeow! 🐾 I've sent the help message to your private chat. Please click the button below to see it."

if OWNER_ID:

owner_mention = f"<code>{OWNER_ID}</code>"; owner_name = "My Esteemed Human"

try: owner_chat = await context.bot.get_chat(OWNER_ID); owner_mention = owner_chat.mention_html(); owner_name = owner_chat.full_name or owner_chat.username or owner_name

except TelegramError as e: logger.warning(f"Could not fetch owner info ({OWNER_ID}): {e}")

except Exception as e: logger.warning(f"Unexpected error fetching owner info: {e}")

message = (f"My designated human is: 👤 <b>{html.escape(owner_name)}</b> ({owner_mention}) ❤️")

await update.message.reply_html(message)

chat_member_status_str: str | None = None,

is_target_owner: bool = False,

is_target_sudo: bool = False,

blacklist_reason_str: str | None = None,

gban_reason_str: str | None = None,

current_chat_id_for_status: int | None = None,

bot_context: ContextTypes.DEFAULT_TYPE | None = None

) -> str:

info_lines = []

entity_id = entity.id

is_user_type = isinstance(entity, User)

entity_chat_type = getattr(entity, 'type', None) if not is_user_type else ChatType.PRIVATE

if is_user_type or entity_chat_type == ChatType.PRIVATE:

user = entity

info_lines.append(f"👤 <b>User Information:</b>\n")

first_name = html.escape(getattr(user, 'first_name', "N/A") or "N/A")

last_name = html.escape(getattr(user, 'last_name', "") or "")

username_display = f"@{html.escape(user.username)}" if user.username else "N/A"

permalink_user_url = f"tg://user?id={user.id}"

permalink_text_display = "Link"

permalink_html_user = f"<a href=\"{permalink_user_url}\">{permalink_text_display}</a>"

is_bot_val = getattr(user, 'is_bot', False)

is_bot_str = "Yes" if is_bot_val else "No"

language_code_val = getattr(user, 'language_code', "N/A")

info_lines.extend([

f"<b>• ID:</b> <code>{user.id}</code>",

f"<b>• First Name:</b> {first_name}",

])

if getattr(user, 'last_name', None):

info_lines.append(f"<b>• Last Name:</b> {last_name}")

info_lines.extend([

f"<b>• Username:</b> {username_display}",

f"<b>• Permalink:</b> {permalink_html_user}",

f"<b>• Is Bot:</b> <code>{is_bot_str}</code>",

f"<b>• Language Code:</b> <code>{language_code_val if language_code_val else 'N/A'}</code>\n"

])

if chat_member_status_str and current_chat_id_for_status != user.id and current_chat_id_for_status is not None:

display_status = ""

if chat_member_status_str == "creator": display_status = "<code>Creator</code>"

elif chat_member_status_str == "administrator": display_status = "<code>Admin</code>"

elif chat_member_status_str == "member": display_status = "<code>Member</code>"

elif chat_member_status_str == "left": display_status = "<code>Not in chat</code>"

elif chat_member_status_str == "kicked": display_status = "<code>Banned</code>"

elif chat_member_status_str == "restricted": display_status = "<code>Muted</code>"

elif chat_member_status_str == "not_a_member": display_status = "<code>Not in chat</code>"

else: display_status = f"<code>{html.escape(chat_member_status_str.replace('_', ' ').capitalize())}</code>"

info_lines.append(f"<b>• Status:</b> {display_status}\n")

if is_target_owner:

info_lines.append(f"<b>• Bot Owner:</b> <code>Yes</code>")

elif is_target_sudo:

info_lines.append(f"<b>• Bot Sudo:</b> <code>Yes</code>")

if blacklist_reason_str is not None:

info_lines.append(f"<b>• Blacklisted:</b> <code>Yes</code>")

info_lines.append(f"<b>Reason:</b> {html.escape(blacklist_reason_str)}")

else:

info_lines.append(f"<b>• Blacklisted:</b> <code>No</code>")

if gban_reason_str is not None:

info_lines.append(f"<b>• Globally Banned:</b> <code>Yes</code>")

info_lines.append(f"<b>Reason:</b> {html.escape(gban_reason_str)}")

else:

info_lines.append(f"<b>• Globally Banned:</b> <code>No</code>")

elif entity_chat_type == ChatType.CHANNEL:

channel = entity

info_lines.append(f"📢 <b>Channel info:</b>\n")

info_lines.append(f"<b>• ID:</b> <code>{channel.id}</code>")

channel_name_to_display = channel.title or getattr(channel, 'first_name', None) or f"Channel {channel.id}"

info_lines.append(f"<b>• Title:</b> {html.escape(channel_name_to_display)}")

if channel.username:

info_lines.append(f"<b>• Username:</b> @{html.escape(channel.username)}")

permalink_channel_url = f"https://t.me/{html.escape(channel.username)}"

permalink_text_display = "Link"

permalink_channel_html = f"<a href=\"{permalink_channel_url}\">{permalink_text_display}</a>"

info_lines.append(f"<b>• Permalink:</b> {permalink_channel_html}")

else:

info_lines.append(f"<b>• Permalink:</b> Private channel (no public link)")

elif entity_chat_type in [ChatType.GROUP, ChatType.SUPERGROUP]:

chat = entity

title = html.escape(chat.title or f"{entity_chat_type.capitalize()} {chat.id}")

info_lines.append(f"ℹ️ Entity <code>{chat.id}</code> is a <b>{entity_chat_type.capitalize()}</b> ({title}).")

info_lines.append(f"This command primarily provides detailed info for Users and Channels.")

else:

info_lines.append(f"❓ <b>Unknown or Unsupported Entity Type:</b> ID <code>{html.escape(str(entity_id))}</code>")

if entity_chat_type:

info_lines.append(f" • Type detected: {entity_chat_type.capitalize()}")

target_entity_obj: Chat | User | None = None

initial_user_obj_from_update: User | None = None

target_chat_obj_from_api: Chat | None = None

initial_entity_id_for_refresh: int | None = None

current_chat_id = update.effective_chat.id

command_caller_id = update.effective_user.id

if update.effective_user:

update_user_in_db(update.effective_user)

if update.message.reply_to_message:

if update.message.reply_to_message.sender_chat:

target_chat_obj_from_api = update.message.reply_to_message.sender_chat

initial_entity_id_for_refresh = target_chat_obj_from_api.id

logger.info(f"/info target is replied sender_chat: ID={target_chat_obj_from_api.id}")

else:

initial_user_obj_from_update = update.message.reply_to_message.from_user

if initial_user_obj_from_update:

update_user_in_db(initial_user_obj_from_update)

initial_entity_id_for_refresh = initial_user_obj_from_update.id

logger.info(f"/info target is replied user: {initial_user_obj_from_update.id}")

elif context.args:

target_input_str = context.args[0]

logger.info(f"/info target is argument: {target_input_str}")

resolved_user_from_db: User | None = None

if target_input_str.startswith("@"):

username_to_find = target_input_str[1:]

resolved_user_from_db = get_user_from_db_by_username(username_to_find)

if resolved_user_from_db:

initial_user_obj_from_update = resolved_user_from_db

initial_entity_id_for_refresh = resolved_user_from_db.id

else:

logger.info(f"Trying find entity @{username_to_find} by using Telegram API.")

try:

target_chat_obj_from_api = await context.bot.get_chat(target_input_str)

initial_entity_id_for_refresh = target_chat_obj_from_api.id

if target_chat_obj_from_api.type == ChatType.PRIVATE:

user_to_save = User(id=target_chat_obj_from_api.id, first_name=target_chat_obj_from_api.first_name or "", is_bot=getattr(target_chat_obj_from_api, 'is_bot', False), username=target_chat_obj_from_api.username, last_name=target_chat_obj_from_api.last_name, language_code=getattr(target_chat_obj_from_api, 'language_code', None))

update_user_in_db(user_to_save)

initial_user_obj_from_update = user_to_save

except TelegramError as e:

logger.error(f"Telegram API error for @ '{target_input_str}': {e}")

await update.message.reply_text(f"😿 Mrow! I couldn't find '{html.escape(target_input_str)}'.")

return

except Exception as e:

logger.error(f"Unexpected error processing @ '{target_input_str}': {e}", exc_info=True)

await update.message.reply_text(f"💥 An unexpected error occurred with '{html.escape(target_input_str)}'.")

return

else:

try:

target_id = int(target_input_str)

initial_entity_id_for_refresh = target_id

target_chat_obj_from_api = await context.bot.get_chat(target_id)

if target_chat_obj_from_api.type == ChatType.PRIVATE:

user_to_save = User(id=target_chat_obj_from_api.id, first_name=target_chat_obj_from_api.first_name or "", is_bot=getattr(target_chat_obj_from_api, 'is_bot', False), username=target_chat_obj_from_api.username, last_name=target_chat_obj_from_api.last_name, language_code=getattr(target_chat_obj_from_api, 'language_code', None))

update_user_in_db(user_to_save)

initial_user_obj_from_update = user_to_save

except ValueError:

await update.message.reply_text(f"Mrow? Invalid format: '{html.escape(target_input_str)}'.")

return

except TelegramError as e:

logger.error(f"Error fetching chat/user info for ID '{target_input_str}': {e}")

await update.message.reply_text(f"😿 Couldn't find or access info for ID '{html.escape(target_input_str)}': {e}")

return

except Exception as e:

logger.error(f"Unexpected error processing ID '{target_input_str}': {e}", exc_info=True)

await update.message.reply_text(f"💥 An unexpected error occurred processing ID '{html.escape(target_input_str)}'.")

return

else:

initial_user_obj_from_update = update.effective_user

if initial_user_obj_from_update:

update_user_in_db(initial_user_obj_from_update)

initial_entity_id_for_refresh = initial_user_obj_from_update.id

logger.info(f"/info target is command sender: {initial_user_obj_from_update.id}")

final_entity_to_display: Chat | User | None = None

if initial_user_obj_from_update:

final_entity_to_display = initial_user_obj_from_update

elif target_chat_obj_from_api:

final_entity_to_display = target_chat_obj_from_api

if final_entity_to_display and initial_entity_id_for_refresh is not None:

is_target_owner_flag = False

is_target_sudo_flag = False

member_status_in_current_chat_str: str | None = None

blacklist_reason_str: str | None = None

gban_reason_str: str | None = None

try:

fresh_data_chat_obj = await context.bot.get_chat(chat_id=initial_entity_id_for_refresh)

if isinstance(final_entity_to_display, User) or fresh_data_chat_obj.type == ChatType.PRIVATE:

current_is_bot = getattr(final_entity_to_display, 'is_bot', False)

current_lang_code = getattr(final_entity_to_display, 'language_code', None)

refreshed_user = User(

id=fresh_data_chat_obj.id,

first_name=fresh_data_chat_obj.first_name or getattr(final_entity_to_display, 'first_name', None) or "",