def admin_panel(
*args,
total_count=None,
private_count=None,
group_count=None,
active_user_count=None,
inactive_user_count=None,
dm_total=None,
dm_active=None,
dm_inactive=None,
dm_banned=None,
groups_total=None,
groups_active=None,
groups_inactive=None,
total_reach=None,
tracked_group_members=None,
**kwargs,
):
if len(args) == 1 and isinstance(args[0], dict):
d = args[0]
dm_total = d.get("dm_total", dm_total)
dm_active = d.get("dm_active", dm_active)
dm_inactive = d.get("dm_inactive", dm_inactive)
dm_banned = d.get("dm_banned", dm_banned)
groups_total = d.get("groups_total", groups_total)
groups_active = d.get("groups_active", groups_active)
groups_inactive = d.get("groups_inactive", groups_inactive)
total_reach = d.get("total_reach", total_reach)
tracked_group_members = d.get("tracked_group_members", tracked_group_members)
total_count = d.get("user_count", total_count)
private_count = d.get("private_chat_count", private_count)
group_count = d.get("group_chat_count", group_count)
active_user_count = d.get("active_user_count", active_user_count)
inactive_user_count = d.get("inactive_user_count", inactive_user_count)
elif len(args) == 9:
(
dm_total,
dm_active,
dm_inactive,
dm_banned,
groups_total,
groups_active,
groups_inactive,
total_reach,
tracked_group_members,
) = args
elif len(args) == 5:
(
total_count,
private_count,
group_count,
active_user_count,
inactive_user_count,
) = args
if dm_total is not None:
reach_val = total_reach or 0
return (
"Hello, this is the admin panel.\n\n"
"👤 Private Chats (DM):\n"
f" ├ Total with DM: {dm_total}\n"
f" ├ ✅ Active (reachable): {dm_active or 0}\n"
f" ├ 🚫 Inactive (blocked bot): {dm_inactive or 0}\n"
f" └ ⛔ Banned: {dm_banned or 0}\n\n"
"🏘 Groups:\n"
f" ├ Total groups: {groups_total or 0}\n"
f" ├ ✅ Active (bot member): {groups_active or 0}\n"
f" ├ 🚫 Inactive (kicked/left): {groups_inactive or 0}\n"
f" ├ 👥 Estimated Reach: ~{reach_val:,} members\n"
f" └ 💬 Tracked chatters: {tracked_group_members or 0}"
)
return ("""Hello, this is the admin panel.
👥 Total chats: {total_count}
👤 Private users: {private_count}
🏘 Groups: {group_count}
✅ Active: {active_user_count}
🚫 Inactive: {inactive_user_count}""").format(
total_count=total_count,
private_count=private_count,
group_count=group_count,
active_user_count=active_user_count,
inactive_user_count=inactive_user_count,
)
def not_groups():
return "This command cannot be used in a group!"
def finish_mailing(
total: int = 0,
delivered: int = 0,
unreachable: int = 0,
migrated: int = 0,
failed: int = 0,
) -> str:
if total <= 0 and delivered <= 0:
return "Mailing is complete!"
return (
f"Mailing is complete!\n\n"
f"📊 Delivery Report:\n"
f"├ 🎯 Total targets: {total}\n"
f"├ ✅ Delivered: {delivered}\n"
f"├ 🚫 Unreachable / Blocked: {unreachable}\n"
f"├ 🔄 Migrated to supergroup: {migrated}\n"
f"└ ⚠️ Failed: {failed}"
)
def start_mailing():
return "Starting mailing..."
def mailing_audience_preview(total_users, active_users, inactive_users, banned_users, private_users, group_users):
return ("""Mailing audience preview
Users to process: {total_users}
Active: {active_users}
Inactive: {inactive_users}
Banned: {banned_users}
Private chats: {private_users}
Groups: {group_users}
Enter the message to send:""").format(
total_users=total_users,
active_users=active_users,
inactive_users=inactive_users,
banned_users=banned_users,
private_users=private_users,
group_users=group_users,
)
def mailing_select_audience() -> str:
return (
"Broadcast Mailing\n\n"
"Select the target audience for your broadcast:"
)
def mailing_audience_preview_segmented(
audience_type: str | None = None,
total_recipients: int = 0,
active_count: int = 0,
inactive_count: int = 0,
estimated_reach: int = 0,
*,
audience_name: str | None = None,
**kwargs,
) -> str:
chosen_audience = audience_name if audience_name is not None else (audience_type or "")
lines = [
"Mailing audience preview",
f"Target audience: {chosen_audience}",
f"Recipients to process: {total_recipients}",
]
if active_count > 0 or inactive_count > 0:
lines.append(f"Active: {active_count}")
if inactive_count > 0:
lines.append(f"Inactive: {inactive_count}")
if estimated_reach > 0:
lines.append(f"Estimated reach: ~{estimated_reach:,} members")
lines.extend([
"",
"Enter the message to send:",
])
return "\n".join(lines)
def canceled():
return "Action canceled!"
def your_message_sent():
return "Your message sent!"
def something_went_wrong():
return "Something went wrong, see log for more information!"
def please_type_message():
return "Please type message:"
def log_deleted():
return "Log deleted, starting to write a new one."
def active_users_check_started(total_users):
return f"Starting availability check for {total_users} users..."
def active_users_check_completed(total_users, reachable_users, unreachable_users):
return ("""Availability check finished.
Total users processed: {total_users}
Reachable: {reachable_users}
Unreachable: {unreachable_users}""").format(
total_users=total_users,
reachable_users=reachable_users,
unreachable_users=unreachable_users,
)
def active_users_check_no_targets():
return "There are no users available for checking."
def check_groups_started(total_groups: int) -> str:
return f"Starting availability and reach check for {total_groups} groups..."
def check_groups_completed(
total_groups: int,
reachable_groups: int = 0,
unreachable_groups: int = 0,
total_reach: int = 0,
*,
active_groups: int | None = None,
kicked_groups: int | None = None,
) -> str:
reachable = active_groups if active_groups is not None else reachable_groups
unreachable = kicked_groups if kicked_groups is not None else unreachable_groups
reach_val = total_reach or 0
return (
"Group check finished.\n\n"
f"Total groups processed: {total_groups}\n"
f"Reachable (bot member): {reachable}\n"
f"Unreachable (kicked/left): {unreachable}\n"
f"Total estimated reach: ~{reach_val:,} members"
)
def check_groups_no_targets() -> str:
return "There are no active groups available for checking."
active_groups_check_started = check_groups_started
active_groups_check_completed = check_groups_completed
active_groups_check_no_targets = check_groups_no_targets
def enter_chat_id():
return "Enter the chat ID (for example, -1001234567890):"
def invalid_chat_id():
return "Chat ID must be a number like -1001234567890. Try again or tap Cancel."
def enter_chat_message():
return "Enter the message you want to send to this chat:"
def known_chat_target(chat_id, chat_name, chat_username, status):
return ("""Known chat target
ID: {chat_id}
Name: {chat_name}
Username: {chat_username}
Status: {status}""").format(
chat_id=chat_id,
chat_name=chat_name,
chat_username=chat_username or "—",
status=status or "unknown",
)
def unknown_chat_target(chat_id):
return (
"Chat {chat_id} is not in the local database yet. "
"I'll still try to send the message if the bot has access."
).format(chat_id=chat_id)
def chat_message_sent(chat_id):
return f"Message delivered to chat {chat_id}."
def chat_message_failed(chat_id):
return f"Failed to send message to chat {chat_id}. Make sure the bot is a member and can write there."
def chat_message_sending():
return "Sending message..."
def downloads_cleanup_blocked(active_jobs, queued_jobs):
return (
"Cleanup skipped because downloads are still running. "
"active_jobs={active_jobs}, queued_jobs={queued_jobs}."
).format(active_jobs=active_jobs, queued_jobs=queued_jobs)
def downloads_cleanup_finished(removed_files, removed_dirs, skipped_recent_files):
return (
"Downloads cleanup finished. Removed {removed_files} files and {removed_dirs} directories; "
"skipped {skipped_recent_files} recent files."
).format(
removed_files=removed_files,
removed_dirs=removed_dirs,
skipped_recent_files=skipped_recent_files,
)