Upload 233 files

.env.sample

@@ -0,0 +1,12 @@
+# Don't use quotes( " and ' )
+
+API_ID=
+API_HASH=
+SESSION=
+REDIS_URI=
+REDIS_PASSWORD=
+
+# [OPTIONAL]
+
+LOG_CHANNEL=
+BOT_TOKEN=

.gitattributes

@@ -33,3 +33,13 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+resources/extras/logo_readme.jpg filter=lfs diff=lfs merge=lfs -text
+resources/extras/ultroid.jpg filter=lfs diff=lfs merge=lfs -text
+resources/fonts/11.otf filter=lfs diff=lfs merge=lfs -text
+resources/fonts/3.ttf filter=lfs diff=lfs merge=lfs -text
+resources/fonts/default.ttf filter=lfs diff=lfs merge=lfs -text
+resources/fonts/DroidSansMono.ttf filter=lfs diff=lfs merge=lfs -text
+resources/fonts/Quivira.otf filter=lfs diff=lfs merge=lfs -text
+resources/fonts/Roboto-Italic.ttf filter=lfs diff=lfs merge=lfs -text
+resources/fonts/Roboto-Medium.ttf filter=lfs diff=lfs merge=lfs -text
+resources/fonts/Roboto-Regular.ttf filter=lfs diff=lfs merge=lfs -text

.github/ISSUE_TEMPLATE/bug-reports.yml

@@ -0,0 +1,68 @@
+name: Bug Report
+description: File a bug report
+title: "[BUG REPORT]"
+labels: [bug]
+body:
+  - type: markdown
+    attributes:
+      value: |
+        Thanks for taking the time to fill out this bug report!
+  - type: input
+    id: contact
+    attributes:
+      label: Contact Details
+      description: Your telegram username or email ID.
+      placeholder: ex. @username or email@example.com
+    validations:
+      required: false
+  - type: textarea
+    id: what-happened
+    attributes:
+      label: What happened?
+      description: Also tell us, what did you expect to happen?
+      placeholder: Tell us what you see!
+      value: "A bug happened!"
+    validations:
+      required: true
+  - type: dropdown
+    id: version
+    attributes:
+      label: Version
+      description: What version of Ultroid are you running?
+      options:
+        - "0.5"
+        - "0.6"
+        - "0.7"
+        - "> 0.7"
+
+    validations:
+      required: true
+  - type: dropdown
+    id: hosted
+    attributes:
+      label: Hosted On
+      description: You are hosting Ultroid on Which Platform?
+      options:
+        - Vps
+        - Heroku
+        - Railway
+        - Qovery
+        - Termux
+        - Other
+        - Didn't Deployed Yet
+    validations:
+      required: true
+  - type: textarea
+    id: logs
+    attributes:
+      label: Relevant logs output
+      description: Please copy and paste any relevant log output. This will be automatically formatted into code, so no need for backticks.
+      render: shell
+  - type: checkboxes
+    id: terms
+    attributes:
+      label: Acknowledgement
+      description: By submitting this issue, you agree that you have read the [docs](https://ultroid.tech) and gone through the [deploy tutorial](https://www.youtube.com/watch?v=9wF7k9qA0Q4) at first.
+      options:
+        - label: I have followed all of the above steps.
+          required: true

.github/ISSUE_TEMPLATE/config.yml

@@ -0,0 +1,8 @@
+blank_issues_enabled: true
+contact_links:
+  - name: Ultroid Support
+    url: https://t.me/UltroidSupportChat
+    about: Please drop your doubts or queries there for an immediate response.
+  - name: Documentation
+    url: https://ultroid.tech/
+    about: Basic documentation for setting up.

.github/PULL_REQUEST_TEMPLATE/pull_request_template.md

@@ -0,0 +1,9 @@
+# Title
+
+### Detailed Description [Optional] :
+detailed_description_here
+
+### Issue Number [Optional] :
+Issue Number here if your pull request close any issue or is linked to.
+
+----

.github/stalebot.yml

@@ -0,0 +1,13 @@
+# Number of days of inactivity before an issue becomes stale
+daysUntilStale: 50
+# Number of days of inactivity before a stale issue is closed
+daysUntilClose: 7
+# Label to use when marking an issue as stale
+staleLabel: inactive
+# Comment to post when marking an issue as stale. Set to `false` to disable
+markComment: >
+  This issue has been automatically marked as stale because it has not had
+  any recent activity. It will be closed if no further activity occurs. Thank you
+  for your contributions.
+# Comment to post when closing a stale issue. Set to `false` to disable
+closeComment: false

.github/workflows/codeql-analysis.yml

@@ -0,0 +1,35 @@
+name: CodeQL Analysis
+
+on:
+  push:
+    branches-ignore:
+      - 'dependabot/**'
+  pull_request:
+    branches: [ '**' ]
+  schedule:
+    - cron: '0 8 * * *'
+  workflow_dispatch:
+
+jobs:
+  analyze:
+    name: Analyze
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v2
+
+      - name: Cache CodeQL database
+        uses: actions/cache@v2
+        with:
+          path: ~/.codeql
+          key: ${{ runner.os }}-codeql-${{ hashFiles('**/qlpack.yml') }}
+          restore-keys: ${{ runner.os }}-codeql-
+
+      - name: Initialize CodeQL
+        uses: github/codeql-action/init@v2
+        with:
+          languages: 'python'
+
+      - name: Perform CodeQL Analysis
+        uses: github/codeql-action/analyze@v2

.github/workflows/pylint.yaml

@@ -0,0 +1,45 @@
+name: PyLint
+on:
+  push:
+    branches: [ dev ]
+    paths:
+    - "**.py"
+jobs:
+  PEP8:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v2
+      - name: Setup Python
+        uses: actions/setup-python@v1
+        with:
+          python-version: 3.8
+          cache: "pip"
+      - name: Install Python lint libraries
+        run: pip install autopep8 autoflake isort black
+      - name: Check for showstoppers
+        run: |
+          autopep8 --verbose --in-place --recursive --aggressive --aggressive assistant/*.py
+          autopep8 --verbose --in-place --recursive --aggressive --aggressive assistant/manager/*.py
+          autopep8 --verbose --in-place --recursive --aggressive --aggressive plugins/*.py
+      - name: Remove unused imports and variables
+        run: |
+          autoflake --in-place --recursive --remove-all-unused-imports --remove-unused-variables --ignore-init-module-imports assistant/*.py
+          autoflake --in-place --recursive --remove-all-unused-imports --remove-unused-variables --ignore-init-module-imports assistant/manager/*.py
+          autoflake --in-place --recursive --remove-all-unused-imports --remove-unused-variables --ignore-init-module-imports plugins/*.py
+      - name: lint with isort and black
+        run: |
+          isort assistant/*.py
+          isort assistant/manager/*.py
+          black --fast assistant/*.py
+          black assistant/manager/*.py
+          isort plugins/*.py
+          black --fast plugins/*.py
+      - uses: stefanzweifel/git-auto-commit-action@v4
+        with:
+          commit_message: 'pylint: auto fixes'
+          commit_options: '--no-verify'
+          repository: .
+          commit_user_name: buddhhu
+          commit_user_email: 48654350+buddhhu@users.noreply.github.com
+          commit_author: Amit Sharma <48654350+buddhhu@users.noreply.github.com>
+          

.github/workflows/stringanalysis.yml

@@ -0,0 +1,33 @@
+name: Strings Analysis
+
+on:
+  pull_request:
+  push:
+    branches: dev
+    paths: strings/strings/*
+  workflow_dispatch:
+
+jobs:
+  analyze:
+    name: Checkout Strings
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v2
+      - name: Setup Python
+        uses: actions/setup-python@v2
+        with:
+          python-version: 3.9.x
+      - name: Install Stuff
+        run: pip install pyyaml
+      - name: dl stuff
+        run: wget -O stringizer.py https://gist.githubusercontent.com/New-dev0/6dfc8a177418565a776167764b2fe0e4/raw/f515e9892a331110c1565eb109eb712eb64423bd/stringzer.py
+      - name: do stuff
+        run: python stringizer.py && rm stringizer.py
+      - uses: stefanzweifel/git-auto-commit-action@v4
+        with:
+          commit_message: 'Strings: Auto Count'
+          commit_options: '--no-verify'
+          repository: .
+          commit_user_name: TeamUltroid
+          commit_user_email: 48654350+buddhhu@users.noreply.github.com
+          commit_author: Amit Sharma <48654350+buddhhu@users.noreply.github.com>

.gitignore

@@ -0,0 +1,47 @@
+.env
+*.session-journal
+*.session
+build
+test*
+*.mp3
+*.webm
+*.webp
+*.mp4
+*.tgs
+*.txt
+/*.jpg
+/*.png
+/*.mp4
+*.log
+target/npmlist.json
+package-lock.json
+ultroid.json
+resources/extras/thumbnail.jpg
+resources/auth/
+
+# Directories
+addons/
+vcbot/
+__pycache__/
+venv/
+node_modules/
+glitch_me/
+src/glitch-me
+.idea/
+.vscode/
+temp/
+bin-debug/
+bin-release/
+[Oo]bj/
+[Bb]in/
+.settings/
+*.swf
+*.air
+*.ipa
+*.apk
+
+# temporary files
+*.raw
+
+# fly.io configs
+fly.toml

CODE_OF_CONDUCT.md

@@ -0,0 +1,128 @@
+# Contributor Covenant Code of Conduct
+
+## Our Pledge
+
+We as members, contributors, and leaders pledge to make participation in our
+community a harassment-free experience for everyone, regardless of age, body
+size, visible or invisible disability, ethnicity, sex characteristics, gender
+identity and expression, level of experience, education, socio-economic status,
+nationality, personal appearance, race, religion, or sexual identity
+and orientation.
+
+We pledge to act and interact in ways that contribute to an open, welcoming,
+diverse, inclusive, and healthy community.
+
+## Our Standards
+
+Examples of behavior that contributes to a positive environment for our
+community include:
+
+* Demonstrating empathy and kindness toward other people
+* Being respectful of differing opinions, viewpoints, and experiences
+* Giving and gracefully accepting constructive feedback
+* Accepting responsibility and apologizing to those affected by our mistakes,
+  and learning from the experience
+* Focusing on what is best not just for us as individuals, but for the
+  overall community
+
+Examples of unacceptable behavior include:
+
+* The use of sexualized language or imagery, and sexual attention or
+  advances of any kind
+* Trolling, insulting or derogatory comments, and personal or political attacks
+* Public or private harassment
+* Publishing others' private information, such as a physical or email
+  address, without their explicit permission
+* Other conduct which could reasonably be considered inappropriate in a
+  professional setting
+
+## Enforcement Responsibilities
+
+Community leaders are responsible for clarifying and enforcing our standards of
+acceptable behavior and will take appropriate and fair corrective action in
+response to any behavior that they deem inappropriate, threatening, offensive,
+or harmful.
+
+Community leaders have the right and responsibility to remove, edit, or reject
+comments, commits, code, wiki edits, issues, and other contributions that are
+not aligned to this Code of Conduct, and will communicate reasons for moderation
+decisions when appropriate.
+
+## Scope
+
+This Code of Conduct applies within all community spaces, and also applies when
+an individual is officially representing the community in public spaces.
+Examples of representing our community include using an official e-mail address,
+posting via an official social media account, or acting as an appointed
+representative at an online or offline event.
+
+## Enforcement
+
+Instances of abusive, harassing, or otherwise unacceptable behavior may be
+reported to the community leaders responsible for enforcement at
+teamultroid@ultroid.tech.
+All complaints will be reviewed and investigated promptly and fairly.
+
+All community leaders are obligated to respect the privacy and security of the
+reporter of any incident.
+
+## Enforcement Guidelines
+
+Community leaders will follow these Community Impact Guidelines in determining
+the consequences for any action they deem in violation of this Code of Conduct:
+
+### 1. Correction
+
+**Community Impact**: Use of inappropriate language or other behavior deemed
+unprofessional or unwelcome in the community.
+
+**Consequence**: A private, written warning from community leaders, providing
+clarity around the nature of the violation and an explanation of why the
+behavior was inappropriate. A public apology may be requested.
+
+### 2. Warning
+
+**Community Impact**: A violation through a single incident or series
+of actions.
+
+**Consequence**: A warning with consequences for continued behavior. No
+interaction with the people involved, including unsolicited interaction with
+those enforcing the Code of Conduct, for a specified period of time. This
+includes avoiding interactions in community spaces as well as external channels
+like social media. Violating these terms may lead to a temporary or
+permanent ban.
+
+### 3. Temporary Ban
+
+**Community Impact**: A serious violation of community standards, including
+sustained inappropriate behavior.
+
+**Consequence**: A temporary ban from any sort of interaction or public
+communication with the community for a specified period of time. No public or
+private interaction with the people involved, including unsolicited interaction
+with those enforcing the Code of Conduct, is allowed during this period.
+Violating these terms may lead to a permanent ban.
+
+### 4. Permanent Ban
+
+**Community Impact**: Demonstrating a pattern of violation of community
+standards, including sustained inappropriate behavior,  harassment of an
+individual, or aggression toward or disparagement of classes of individuals.
+
+**Consequence**: A permanent ban from any sort of public interaction within
+the community.
+
+## Attribution
+
+This Code of Conduct is adapted from the [Contributor Covenant][homepage],
+version 2.0, available at
+https://www.contributor-covenant.org/version/2/0/code_of_conduct.html.
+
+Community Impact Guidelines were inspired by [Mozilla's code of conduct
+enforcement ladder](https://github.com/mozilla/diversity).
+
+[homepage]: https://www.contributor-covenant.org
+
+For answers to common questions about this code of conduct, see the FAQ at
+https://www.contributor-covenant.org/faq. Translations are available at
+https://www.contributor-covenant.org/translations.

CONTRIBUTING.md

@@ -0,0 +1,23 @@
+# Welcome To Contributing Guide
+Any contribution done to this repository will be appreciated! 🎉
+
+### About Ultroid
+- **Ultroid** is Telegram Userbot, which allow you to perform many task easily. 
+- It's base core is a pip package named [`pyUltroid`](https://GitHub.com/TeamUltroid/pyUltroid).
+- This repository, contains Ultroid's official plugin files.
+- moreover, Ultroid User also have an option to get more plugins available at [`UltroidAddons`](https://github.com/TeamUltroid/UltroidAddons)
+
+### Issues
+- Search for existing Similar issues.
+- You can open a issue first before contributing, If it contain some major changes like `bug fixes` or `feature addition`.
+- If you are busy or getting trouble while making changes, you can just open the issue (explaining it).
+
+### Contributing
+- You can [fork](https://github.com/TeamUltroid/Ultroid/fork) this repository.
+- You can commits your changes now.
+- You can [Git-Squash](https://docs.github.com/en/get-started/using-git/about-git-rebase) your commits, if they are more. [Optional]
+- At last, You are ready to [`make a Pull Request`](https://docs.github.com/en/github/collaborating-with-pull-requests/proposing-changes-to-your-work-with-pull-requests/creating-a-pull-request).
+- Make sure that, your `Pull Request` contain an explaining title and issue number if it closes any open issue.
+
+### Thanks
+- Congrats! 💫 you have successfully made your Contribution to Ultroid.

Dockerfile

@@ -0,0 +1,20 @@
+# Ultroid - UserBot
+# Copyright (C) 2021-2025 TeamUltroid
+# This file is a part of < https://github.com/TeamUltroid/Ultroid/ >
+# PLease read the GNU Affero General Public License in <https://www.github.com/TeamUltroid/Ultroid/blob/main/LICENSE/>.
+
+FROM theteamultroid/ultroid:main
+
+# set timezone
+ENV TZ=Asia/Kolkata
+RUN ln -snf /usr/share/zoneinfo/$TZ /etc/localtime && echo $TZ > /etc/timezone
+
+COPY installer.sh .
+
+RUN bash installer.sh
+
+# changing workdir
+WORKDIR "/root/TeamUltroid"
+
+# start the bot.
+CMD ["bash", "startup"]

LICENSE

@@ -0,0 +1,661 @@
+                    GNU AFFERO GENERAL PUBLIC LICENSE
+                       Version 3, 19 November 2007
+
+ Copyright (C) 2007 Free Software Foundation, Inc. <https://fsf.org/>
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+                            Preamble
+
+  The GNU Affero General Public License is a free, copyleft license for
+software and other kinds of works, specifically designed to ensure
+cooperation with the community in the case of network server software.
+
+  The licenses for most software and other practical works are designed
+to take away your freedom to share and change the works.  By contrast,
+our General Public Licenses are intended to guarantee your freedom to
+share and change all versions of a program--to make sure it remains free
+software for all its users.
+
+  When we speak of free software, we are referring to freedom, not
+price.  Our General Public Licenses are designed to make sure that you
+have the freedom to distribute copies of free software (and charge for
+them if you wish), that you receive source code or can get it if you
+want it, that you can change the software or use pieces of it in new
+free programs, and that you know you can do these things.
+
+  Developers that use our General Public Licenses protect your rights
+with two steps: (1) assert copyright on the software, and (2) offer
+you this License which gives you legal permission to copy, distribute
+and/or modify the software.
+
+  A secondary benefit of defending all users' freedom is that
+improvements made in alternate versions of the program, if they
+receive widespread use, become available for other developers to
+incorporate.  Many developers of free software are heartened and
+encouraged by the resulting cooperation.  However, in the case of
+software used on network servers, this result may fail to come about.
+The GNU General Public License permits making a modified version and
+letting the public access it on a server without ever releasing its
+source code to the public.
+
+  The GNU Affero General Public License is designed specifically to
+ensure that, in such cases, the modified source code becomes available
+to the community.  It requires the operator of a network server to
+provide the source code of the modified version running there to the
+users of that server.  Therefore, public use of a modified version, on
+a publicly accessible server, gives the public access to the source
+code of the modified version.
+
+  An older license, called the Affero General Public License and
+published by Affero, was designed to accomplish similar goals.  This is
+a different license, not a version of the Affero GPL, but Affero has
+released a new version of the Affero GPL which permits relicensing under
+this license.
+
+  The precise terms and conditions for copying, distribution and
+modification follow.
+
+                       TERMS AND CONDITIONS
+
+  0. Definitions.
+
+  "This License" refers to version 3 of the GNU Affero General Public License.
+
+  "Copyright" also means copyright-like laws that apply to other kinds of
+works, such as semiconductor masks.
+
+  "The Program" refers to any copyrightable work licensed under this
+License.  Each licensee is addressed as "you".  "Licensees" and
+"recipients" may be individuals or organizations.
+
+  To "modify" a work means to copy from or adapt all or part of the work
+in a fashion requiring copyright permission, other than the making of an
+exact copy.  The resulting work is called a "modified version" of the
+earlier work or a work "based on" the earlier work.
+
+  A "covered work" means either the unmodified Program or a work based
+on the Program.
+
+  To "propagate" a work means to do anything with it that, without
+permission, would make you directly or secondarily liable for
+infringement under applicable copyright law, except executing it on a
+computer or modifying a private copy.  Propagation includes copying,
+distribution (with or without modification), making available to the
+public, and in some countries other activities as well.
+
+  To "convey" a work means any kind of propagation that enables other
+parties to make or receive copies.  Mere interaction with a user through
+a computer network, with no transfer of a copy, is not conveying.
+
+  An interactive user interface displays "Appropriate Legal Notices"
+to the extent that it includes a convenient and prominently visible
+feature that (1) displays an appropriate copyright notice, and (2)
+tells the user that there is no warranty for the work (except to the
+extent that warranties are provided), that licensees may convey the
+work under this License, and how to view a copy of this License.  If
+the interface presents a list of user commands or options, such as a
+menu, a prominent item in the list meets this criterion.
+
+  1. Source Code.
+
+  The "source code" for a work means the preferred form of the work
+for making modifications to it.  "Object code" means any non-source
+form of a work.
+
+  A "Standard Interface" means an interface that either is an official
+standard defined by a recognized standards body, or, in the case of
+interfaces specified for a particular programming language, one that
+is widely used among developers working in that language.
+
+  The "System Libraries" of an executable work include anything, other
+than the work as a whole, that (a) is included in the normal form of
+packaging a Major Component, but which is not part of that Major
+Component, and (b) serves only to enable use of the work with that
+Major Component, or to implement a Standard Interface for which an
+implementation is available to the public in source code form.  A
+"Major Component", in this context, means a major essential component
+(kernel, window system, and so on) of the specific operating system
+(if any) on which the executable work runs, or a compiler used to
+produce the work, or an object code interpreter used to run it.
+
+  The "Corresponding Source" for a work in object code form means all
+the source code needed to generate, install, and (for an executable
+work) run the object code and to modify the work, including scripts to
+control those activities.  However, it does not include the work's
+System Libraries, or general-purpose tools or generally available free
+programs which are used unmodified in performing those activities but
+which are not part of the work.  For example, Corresponding Source
+includes interface definition files associated with source files for
+the work, and the source code for shared libraries and dynamically
+linked subprograms that the work is specifically designed to require,
+such as by intimate data communication or control flow between those
+subprograms and other parts of the work.
+
+  The Corresponding Source need not include anything that users
+can regenerate automatically from other parts of the Corresponding
+Source.
+
+  The Corresponding Source for a work in source code form is that
+same work.
+
+  2. Basic Permissions.
+
+  All rights granted under this License are granted for the term of
+copyright on the Program, and are irrevocable provided the stated
+conditions are met.  This License explicitly affirms your unlimited
+permission to run the unmodified Program.  The output from running a
+covered work is covered by this License only if the output, given its
+content, constitutes a covered work.  This License acknowledges your
+rights of fair use or other equivalent, as provided by copyright law.
+
+  You may make, run and propagate covered works that you do not
+convey, without conditions so long as your license otherwise remains
+in force.  You may convey covered works to others for the sole purpose
+of having them make modifications exclusively for you, or provide you
+with facilities for running those works, provided that you comply with
+the terms of this License in conveying all material for which you do
+not control copyright.  Those thus making or running the covered works
+for you must do so exclusively on your behalf, under your direction
+and control, on terms that prohibit them from making any copies of
+your copyrighted material outside their relationship with you.
+
+  Conveying under any other circumstances is permitted solely under
+the conditions stated below.  Sublicensing is not allowed; section 10
+makes it unnecessary.
+
+  3. Protecting Users' Legal Rights From Anti-Circumvention Law.
+
+  No covered work shall be deemed part of an effective technological
+measure under any applicable law fulfilling obligations under article
+11 of the WIPO copyright treaty adopted on 20 December 1996, or
+similar laws prohibiting or restricting circumvention of such
+measures.
+
+  When you convey a covered work, you waive any legal power to forbid
+circumvention of technological measures to the extent such circumvention
+is effected by exercising rights under this License with respect to
+the covered work, and you disclaim any intention to limit operation or
+modification of the work as a means of enforcing, against the work's
+users, your or third parties' legal rights to forbid circumvention of
+technological measures.
+
+  4. Conveying Verbatim Copies.
+
+  You may convey verbatim copies of the Program's source code as you
+receive it, in any medium, provided that you conspicuously and
+appropriately publish on each copy an appropriate copyright notice;
+keep intact all notices stating that this License and any
+non-permissive terms added in accord with section 7 apply to the code;
+keep intact all notices of the absence of any warranty; and give all
+recipients a copy of this License along with the Program.
+
+  You may charge any price or no price for each copy that you convey,
+and you may offer support or warranty protection for a fee.
+
+  5. Conveying Modified Source Versions.
+
+  You may convey a work based on the Program, or the modifications to
+produce it from the Program, in the form of source code under the
+terms of section 4, provided that you also meet all of these conditions:
+
+    a) The work must carry prominent notices stating that you modified
+    it, and giving a relevant date.
+
+    b) The work must carry prominent notices stating that it is
+    released under this License and any conditions added under section
+    7.  This requirement modifies the requirement in section 4 to
+    "keep intact all notices".
+
+    c) You must license the entire work, as a whole, under this
+    License to anyone who comes into possession of a copy.  This
+    License will therefore apply, along with any applicable section 7
+    additional terms, to the whole of the work, and all its parts,
+    regardless of how they are packaged.  This License gives no
+    permission to license the work in any other way, but it does not
+    invalidate such permission if you have separately received it.
+
+    d) If the work has interactive user interfaces, each must display
+    Appropriate Legal Notices; however, if the Program has interactive
+    interfaces that do not display Appropriate Legal Notices, your
+    work need not make them do so.
+
+  A compilation of a covered work with other separate and independent
+works, which are not by their nature extensions of the covered work,
+and which are not combined with it such as to form a larger program,
+in or on a volume of a storage or distribution medium, is called an
+"aggregate" if the compilation and its resulting copyright are not
+used to limit the access or legal rights of the compilation's users
+beyond what the individual works permit.  Inclusion of a covered work
+in an aggregate does not cause this License to apply to the other
+parts of the aggregate.
+
+  6. Conveying Non-Source Forms.
+
+  You may convey a covered work in object code form under the terms
+of sections 4 and 5, provided that you also convey the
+machine-readable Corresponding Source under the terms of this License,
+in one of these ways:
+
+    a) Convey the object code in, or embodied in, a physical product
+    (including a physical distribution medium), accompanied by the
+    Corresponding Source fixed on a durable physical medium
+    customarily used for software interchange.
+
+    b) Convey the object code in, or embodied in, a physical product
+    (including a physical distribution medium), accompanied by a
+    written offer, valid for at least three years and valid for as
+    long as you offer spare parts or customer support for that product
+    model, to give anyone who possesses the object code either (1) a
+    copy of the Corresponding Source for all the software in the
+    product that is covered by this License, on a durable physical
+    medium customarily used for software interchange, for a price no
+    more than your reasonable cost of physically performing this
+    conveying of source, or (2) access to copy the
+    Corresponding Source from a network server at no charge.
+
+    c) Convey individual copies of the object code with a copy of the
+    written offer to provide the Corresponding Source.  This
+    alternative is allowed only occasionally and noncommercially, and
+    only if you received the object code with such an offer, in accord
+    with subsection 6b.
+
+    d) Convey the object code by offering access from a designated
+    place (gratis or for a charge), and offer equivalent access to the
+    Corresponding Source in the same way through the same place at no
+    further charge.  You need not require recipients to copy the
+    Corresponding Source along with the object code.  If the place to
+    copy the object code is a network server, the Corresponding Source
+    may be on a different server (operated by you or a third party)
+    that supports equivalent copying facilities, provided you maintain
+    clear directions next to the object code saying where to find the
+    Corresponding Source.  Regardless of what server hosts the
+    Corresponding Source, you remain obligated to ensure that it is
+    available for as long as needed to satisfy these requirements.
+
+    e) Convey the object code using peer-to-peer transmission, provided
+    you inform other peers where the object code and Corresponding
+    Source of the work are being offered to the general public at no
+    charge under subsection 6d.
+
+  A separable portion of the object code, whose source code is excluded
+from the Corresponding Source as a System Library, need not be
+included in conveying the object code work.
+
+  A "User Product" is either (1) a "consumer product", which means any
+tangible personal property which is normally used for personal, family,
+or household purposes, or (2) anything designed or sold for incorporation
+into a dwelling.  In determining whether a product is a consumer product,
+doubtful cases shall be resolved in favor of coverage.  For a particular
+product received by a particular user, "normally used" refers to a
+typical or common use of that class of product, regardless of the status
+of the particular user or of the way in which the particular user
+actually uses, or expects or is expected to use, the product.  A product
+is a consumer product regardless of whether the product has substantial
+commercial, industrial or non-consumer uses, unless such uses represent
+the only significant mode of use of the product.
+
+  "Installation Information" for a User Product means any methods,
+procedures, authorization keys, or other information required to install
+and execute modified versions of a covered work in that User Product from
+a modified version of its Corresponding Source.  The information must
+suffice to ensure that the continued functioning of the modified object
+code is in no case prevented or interfered with solely because
+modification has been made.
+
+  If you convey an object code work under this section in, or with, or
+specifically for use in, a User Product, and the conveying occurs as
+part of a transaction in which the right of possession and use of the
+User Product is transferred to the recipient in perpetuity or for a
+fixed term (regardless of how the transaction is characterized), the
+Corresponding Source conveyed under this section must be accompanied
+by the Installation Information.  But this requirement does not apply
+if neither you nor any third party retains the ability to install
+modified object code on the User Product (for example, the work has
+been installed in ROM).
+
+  The requirement to provide Installation Information does not include a
+requirement to continue to provide support service, warranty, or updates
+for a work that has been modified or installed by the recipient, or for
+the User Product in which it has been modified or installed.  Access to a
+network may be denied when the modification itself materially and
+adversely affects the operation of the network or violates the rules and
+protocols for communication across the network.
+
+  Corresponding Source conveyed, and Installation Information provided,
+in accord with this section must be in a format that is publicly
+documented (and with an implementation available to the public in
+source code form), and must require no special password or key for
+unpacking, reading or copying.
+
+  7. Additional Terms.
+
+  "Additional permissions" are terms that supplement the terms of this
+License by making exceptions from one or more of its conditions.
+Additional permissions that are applicable to the entire Program shall
+be treated as though they were included in this License, to the extent
+that they are valid under applicable law.  If additional permissions
+apply only to part of the Program, that part may be used separately
+under those permissions, but the entire Program remains governed by
+this License without regard to the additional permissions.
+
+  When you convey a copy of a covered work, you may at your option
+remove any additional permissions from that copy, or from any part of
+it.  (Additional permissions may be written to require their own
+removal in certain cases when you modify the work.)  You may place
+additional permissions on material, added by you to a covered work,
+for which you have or can give appropriate copyright permission.
+
+  Notwithstanding any other provision of this License, for material you
+add to a covered work, you may (if authorized by the copyright holders of
+that material) supplement the terms of this License with terms:
+
+    a) Disclaiming warranty or limiting liability differently from the
+    terms of sections 15 and 16 of this License; or
+
+    b) Requiring preservation of specified reasonable legal notices or
+    author attributions in that material or in the Appropriate Legal
+    Notices displayed by works containing it; or
+
+    c) Prohibiting misrepresentation of the origin of that material, or
+    requiring that modified versions of such material be marked in
+    reasonable ways as different from the original version; or
+
+    d) Limiting the use for publicity purposes of names of licensors or
+    authors of the material; or
+
+    e) Declining to grant rights under trademark law for use of some
+    trade names, trademarks, or service marks; or
+
+    f) Requiring indemnification of licensors and authors of that
+    material by anyone who conveys the material (or modified versions of
+    it) with contractual assumptions of liability to the recipient, for
+    any liability that these contractual assumptions directly impose on
+    those licensors and authors.
+
+  All other non-permissive additional terms are considered "further
+restrictions" within the meaning of section 10.  If the Program as you
+received it, or any part of it, contains a notice stating that it is
+governed by this License along with a term that is a further
+restriction, you may remove that term.  If a license document contains
+a further restriction but permits relicensing or conveying under this
+License, you may add to a covered work material governed by the terms
+of that license document, provided that the further restriction does
+not survive such relicensing or conveying.
+
+  If you add terms to a covered work in accord with this section, you
+must place, in the relevant source files, a statement of the
+additional terms that apply to those files, or a notice indicating
+where to find the applicable terms.
+
+  Additional terms, permissive or non-permissive, may be stated in the
+form of a separately written license, or stated as exceptions;
+the above requirements apply either way.
+
+  8. Termination.
+
+  You may not propagate or modify a covered work except as expressly
+provided under this License.  Any attempt otherwise to propagate or
+modify it is void, and will automatically terminate your rights under
+this License (including any patent licenses granted under the third
+paragraph of section 11).
+
+  However, if you cease all violation of this License, then your
+license from a particular copyright holder is reinstated (a)
+provisionally, unless and until the copyright holder explicitly and
+finally terminates your license, and (b) permanently, if the copyright
+holder fails to notify you of the violation by some reasonable means
+prior to 60 days after the cessation.
+
+  Moreover, your license from a particular copyright holder is
+reinstated permanently if the copyright holder notifies you of the
+violation by some reasonable means, this is the first time you have
+received notice of violation of this License (for any work) from that
+copyright holder, and you cure the violation prior to 30 days after
+your receipt of the notice.
+
+  Termination of your rights under this section does not terminate the
+licenses of parties who have received copies or rights from you under
+this License.  If your rights have been terminated and not permanently
+reinstated, you do not qualify to receive new licenses for the same
+material under section 10.
+
+  9. Acceptance Not Required for Having Copies.
+
+  You are not required to accept this License in order to receive or
+run a copy of the Program.  Ancillary propagation of a covered work
+occurring solely as a consequence of using peer-to-peer transmission
+to receive a copy likewise does not require acceptance.  However,
+nothing other than this License grants you permission to propagate or
+modify any covered work.  These actions infringe copyright if you do
+not accept this License.  Therefore, by modifying or propagating a
+covered work, you indicate your acceptance of this License to do so.
+
+  10. Automatic Licensing of Downstream Recipients.
+
+  Each time you convey a covered work, the recipient automatically
+receives a license from the original licensors, to run, modify and
+propagate that work, subject to this License.  You are not responsible
+for enforcing compliance by third parties with this License.
+
+  An "entity transaction" is a transaction transferring control of an
+organization, or substantially all assets of one, or subdividing an
+organization, or merging organizations.  If propagation of a covered
+work results from an entity transaction, each party to that
+transaction who receives a copy of the work also receives whatever
+licenses to the work the party's predecessor in interest had or could
+give under the previous paragraph, plus a right to possession of the
+Corresponding Source of the work from the predecessor in interest, if
+the predecessor has it or can get it with reasonable efforts.
+
+  You may not impose any further restrictions on the exercise of the
+rights granted or affirmed under this License.  For example, you may
+not impose a license fee, royalty, or other charge for exercise of
+rights granted under this License, and you may not initiate litigation
+(including a cross-claim or counterclaim in a lawsuit) alleging that
+any patent claim is infringed by making, using, selling, offering for
+sale, or importing the Program or any portion of it.
+
+  11. Patents.
+
+  A "contributor" is a copyright holder who authorizes use under this
+License of the Program or a work on which the Program is based.  The
+work thus licensed is called the contributor's "contributor version".
+
+  A contributor's "essential patent claims" are all patent claims
+owned or controlled by the contributor, whether already acquired or
+hereafter acquired, that would be infringed by some manner, permitted
+by this License, of making, using, or selling its contributor version,
+but do not include claims that would be infringed only as a
+consequence of further modification of the contributor version.  For
+purposes of this definition, "control" includes the right to grant
+patent sublicenses in a manner consistent with the requirements of
+this License.
+
+  Each contributor grants you a non-exclusive, worldwide, royalty-free
+patent license under the contributor's essential patent claims, to
+make, use, sell, offer for sale, import and otherwise run, modify and
+propagate the contents of its contributor version.
+
+  In the following three paragraphs, a "patent license" is any express
+agreement or commitment, however denominated, not to enforce a patent
+(such as an express permission to practice a patent or covenant not to
+sue for patent infringement).  To "grant" such a patent license to a
+party means to make such an agreement or commitment not to enforce a
+patent against the party.
+
+  If you convey a covered work, knowingly relying on a patent license,
+and the Corresponding Source of the work is not available for anyone
+to copy, free of charge and under the terms of this License, through a
+publicly available network server or other readily accessible means,
+then you must either (1) cause the Corresponding Source to be so
+available, or (2) arrange to deprive yourself of the benefit of the
+patent license for this particular work, or (3) arrange, in a manner
+consistent with the requirements of this License, to extend the patent
+license to downstream recipients.  "Knowingly relying" means you have
+actual knowledge that, but for the patent license, your conveying the
+covered work in a country, or your recipient's use of the covered work
+in a country, would infringe one or more identifiable patents in that
+country that you have reason to believe are valid.
+
+  If, pursuant to or in connection with a single transaction or
+arrangement, you convey, or propagate by procuring conveyance of, a
+covered work, and grant a patent license to some of the parties
+receiving the covered work authorizing them to use, propagate, modify
+or convey a specific copy of the covered work, then the patent license
+you grant is automatically extended to all recipients of the covered
+work and works based on it.
+
+  A patent license is "discriminatory" if it does not include within
+the scope of its coverage, prohibits the exercise of, or is
+conditioned on the non-exercise of one or more of the rights that are
+specifically granted under this License.  You may not convey a covered
+work if you are a party to an arrangement with a third party that is
+in the business of distributing software, under which you make payment
+to the third party based on the extent of your activity of conveying
+the work, and under which the third party grants, to any of the
+parties who would receive the covered work from you, a discriminatory
+patent license (a) in connection with copies of the covered work
+conveyed by you (or copies made from those copies), or (b) primarily
+for and in connection with specific products or compilations that
+contain the covered work, unless you entered into that arrangement,
+or that patent license was granted, prior to 28 March 2007.
+
+  Nothing in this License shall be construed as excluding or limiting
+any implied license or other defenses to infringement that may
+otherwise be available to you under applicable patent law.
+
+  12. No Surrender of Others' Freedom.
+
+  If conditions are imposed on you (whether by court order, agreement or
+otherwise) that contradict the conditions of this License, they do not
+excuse you from the conditions of this License.  If you cannot convey a
+covered work so as to satisfy simultaneously your obligations under this
+License and any other pertinent obligations, then as a consequence you may
+not convey it at all.  For example, if you agree to terms that obligate you
+to collect a royalty for further conveying from those to whom you convey
+the Program, the only way you could satisfy both those terms and this
+License would be to refrain entirely from conveying the Program.
+
+  13. Remote Network Interaction; Use with the GNU General Public License.
+
+  Notwithstanding any other provision of this License, if you modify the
+Program, your modified version must prominently offer all users
+interacting with it remotely through a computer network (if your version
+supports such interaction) an opportunity to receive the Corresponding
+Source of your version by providing access to the Corresponding Source
+from a network server at no charge, through some standard or customary
+means of facilitating copying of software.  This Corresponding Source
+shall include the Corresponding Source for any work covered by version 3
+of the GNU General Public License that is incorporated pursuant to the
+following paragraph.
+
+  Notwithstanding any other provision of this License, you have
+permission to link or combine any covered work with a work licensed
+under version 3 of the GNU General Public License into a single
+combined work, and to convey the resulting work.  The terms of this
+License will continue to apply to the part which is the covered work,
+but the work with which it is combined will remain governed by version
+3 of the GNU General Public License.
+
+  14. Revised Versions of this License.
+
+  The Free Software Foundation may publish revised and/or new versions of
+the GNU Affero General Public License from time to time.  Such new versions
+will be similar in spirit to the present version, but may differ in detail to
+address new problems or concerns.
+
+  Each version is given a distinguishing version number.  If the
+Program specifies that a certain numbered version of the GNU Affero General
+Public License "or any later version" applies to it, you have the
+option of following the terms and conditions either of that numbered
+version or of any later version published by the Free Software
+Foundation.  If the Program does not specify a version number of the
+GNU Affero General Public License, you may choose any version ever published
+by the Free Software Foundation.
+
+  If the Program specifies that a proxy can decide which future
+versions of the GNU Affero General Public License can be used, that proxy's
+public statement of acceptance of a version permanently authorizes you
+to choose that version for the Program.
+
+  Later license versions may give you additional or different
+permissions.  However, no additional obligations are imposed on any
+author or copyright holder as a result of your choosing to follow a
+later version.
+
+  15. Disclaimer of Warranty.
+
+  THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY
+APPLICABLE LAW.  EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT
+HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY
+OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO,
+THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+PURPOSE.  THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM
+IS WITH YOU.  SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF
+ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
+
+  16. Limitation of Liability.
+
+  IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
+WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS
+THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY
+GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE
+USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF
+DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD
+PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS),
+EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF
+SUCH DAMAGES.
+
+  17. Interpretation of Sections 15 and 16.
+
+  If the disclaimer of warranty and limitation of liability provided
+above cannot be given local legal effect according to their terms,
+reviewing courts shall apply local law that most closely approximates
+an absolute waiver of all civil liability in connection with the
+Program, unless a warranty or assumption of liability accompanies a
+copy of the Program in return for a fee.
+
+                     END OF TERMS AND CONDITIONS
+
+            How to Apply These Terms to Your New Programs
+
+  If you develop a new program, and you want it to be of the greatest
+possible use to the public, the best way to achieve this is to make it
+free software which everyone can redistribute and change under these terms.
+
+  To do so, attach the following notices to the program.  It is safest
+to attach them to the start of each source file to most effectively
+state the exclusion of warranty; and each file should have at least
+the "copyright" line and a pointer to where the full notice is found.
+
+    <one line to give the program's name and a brief idea of what it does.>
+    Copyright (C) <year>  <name of author>
+
+    This program is free software: you can redistribute it and/or modify
+    it under the terms of the GNU Affero General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU Affero General Public License for more details.
+
+    You should have received a copy of the GNU Affero General Public License
+    along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+Also add information on how to contact you by electronic and paper mail.
+
+  If your software can interact with users remotely through a computer
+network, you should also make sure that it provides a way for users to
+get its source.  For example, if your program is a web application, its
+interface could display a "Source" link that leads users to an archive
+of the code.  There are many ways you could offer source, and different
+solutions will be better for different programs; see section 13 for the
+specific requirements.
+
+  You should also get your employer (if you work as a programmer) or school,
+if any, to sign a "copyright disclaimer" for the program, if necessary.
+For more information on this, and how to apply and follow the GNU AGPL, see
+<https://www.gnu.org/licenses/>.

app.json

@@ -0,0 +1,56 @@
+{
+    "name": "Ultroid UserBot",
+    "description": "Pluggable telegram userbot, made in python using Telethon.",
+    "logo": "https://graph.org/file/031957757a4f6a5191040.jpg",
+    "keywords": [
+        "Telethon",
+        "telegram",
+        "userbot",
+        "python",
+        "ultroid"
+    ],
+    "repository": "https://github.com/TeamUltroid/Ultroid",
+    "website": "https://ultroid.tech",
+    "success_url": "https://t.me/TeamUltroid",
+    "stack": "container",
+    "env": {
+        "API_ID": {
+            "description": "You api id, from my.telegram.org or @ScrapperRoBot.",
+            "value": "", 
+            "required": false
+        },
+        "API_HASH": {
+            "description": "You api hash, from my.telegram.org or @ScrapperRoBot.",
+            "value": "",
+            "required": false
+        },
+        "SESSION": {
+            "description": "Session String (telethon or pyrogram) for your telegram user account. The userbot will NOT work without a session string!!",
+            "value": ""
+        },
+        "REDIS_URI": {
+            "description": "Redis endpoint URL, from redislabs.com",
+            "value": ""
+        },
+        "REDIS_PASSWORD": {
+            "description": "Redis endpoint password, from redislabs.com",
+            "value": ""
+        },
+        "HEROKU_API": {
+            "description": "Heroku API token. Mandatory for Heroku Deploy...",
+            "value": "",
+            "required": false
+        },
+        "HEROKU_APP_NAME": {
+            "description": "Name of your Heroku app, given in the first blank on this page. To be added if deploying to heroku ONLY.",
+            "value": "",
+            "required": false
+        }
+    },
+    "formation": {
+        "ultroid": {
+            "quantity": 1,
+            "size": "eco"
+        }
+    }
+}

assistant/__init__.py

@@ -0,0 +1,34 @@
+# Ultroid - UserBot
+# Copyright (C) 2021-2025 TeamUltroid
+#
+# This file is a part of < https://github.com/TeamUltroid/Ultroid/ >
+# PLease read the GNU Affero General Public License in
+# <https://www.github.com/TeamUltroid/Ultroid/blob/main/LICENSE/>.
+
+from telethon import Button, custom
+
+from plugins import ATRA_COL, InlinePlugin
+from pyUltroid import *
+from pyUltroid import _ult_cache
+from pyUltroid._misc import owner_and_sudos
+from pyUltroid._misc._assistant import asst_cmd, callback, in_pattern
+from pyUltroid.fns.helper import *
+from pyUltroid.fns.tools import get_stored_file
+from strings import get_languages, get_string
+
+OWNER_NAME = ultroid_bot.full_name
+OWNER_ID = ultroid_bot.uid
+
+AST_PLUGINS = {}
+
+
+async def setit(event, name, value):
+    try:
+        udB.set_key(name, value)
+    except BaseException as er:
+        LOGS.exception(er)
+        return await event.edit("`Something Went Wrong`")
+
+
+def get_back_button(name):
+    return [Button.inline("« Bᴀᴄᴋ", data=f"{name}")]

assistant/callbackstuffs.py

@@ -0,0 +1,1318 @@
+# Ultroid - UserBot
+# Copyright (C) 2021-2025 TeamUltroid
+#
+# This file is a part of < https://github.com/TeamUltroid/Ultroid/ >
+# PLease read the GNU Affero General Public License in
+# <https://www.github.com/TeamUltroid/Ultroid/blob/main/LICENSE/>.
+
+import ast
+import asyncio
+import re
+import sys
+import time
+from asyncio.exceptions import TimeoutError as AsyncTimeOut
+from os import execl, remove
+from random import choice
+
+from bs4 import BeautifulSoup as bs
+
+try:
+    from pyUltroid.fns.gDrive import GDriveManager
+except ImportError:
+    GDriveManager = None
+from telethon import Button, events
+from catbox import CatboxUploader
+from telethon.tl.types import MessageMediaWebPage
+from telethon.utils import get_peer_id
+
+from pyUltroid.fns.helper import fast_download, progress
+from pyUltroid.fns.tools import Carbon, async_searcher, get_paste, telegraph_client
+from pyUltroid.startup.loader import Loader
+
+from . import *
+
+# --------------------------------------------------------------------#
+telegraph = telegraph_client()
+GDrive = GDriveManager() if GDriveManager else None
+uploader = CatboxUploader()
+# --------------------------------------------------------------------#
+
+def text_to_url(event):
+    """function to get media url (with|without) Webpage"""
+    if isinstance(event.media, MessageMediaWebPage):
+        webpage = event.media.webpage
+        if not isinstance(webpage, types.WebPageEmpty) and webpage.type in ["photo"]:
+            return webpage.display_url
+    return event.text
+
+
+# --------------------------------------------------------------------#
+
+_buttons = {
+    "otvars": {
+        "text": "Other Variables to set for @TeamUltroid:",
+        "buttons": [
+            [
+                Button.inline("Tᴀɢ Lᴏɢɢᴇʀ", data="taglog"),
+                Button.inline("SᴜᴘᴇʀFʙᴀɴ", data="cbs_sfban"),
+            ],
+            [
+                Button.inline("Sᴜᴅᴏ Mᴏᴅᴇ", data="sudo"),
+                Button.inline("Hᴀɴᴅʟᴇʀ", data="hhndlr"),
+            ],
+            [
+                Button.inline("Exᴛʀᴀ Pʟᴜɢɪɴs", data="plg"),
+                Button.inline("Aᴅᴅᴏɴs", data="eaddon"),
+            ],
+            [
+                Button.inline("Eᴍᴏᴊɪ ɪɴ Hᴇʟᴘ", data="emoj"),
+                Button.inline("Sᴇᴛ ɢDʀɪᴠᴇ", data="gdrive"),
+            ],
+            [
+                Button.inline("Iɴʟɪɴᴇ Pɪᴄ", data="inli_pic"),
+                Button.inline("Sᴜᴅᴏ HNDLR", data="shndlr"),
+            ],
+            [Button.inline("Dᴜᴀʟ Mᴏᴅᴇ", "cbs_oofdm")],
+            [Button.inline("« Bᴀᴄᴋ", data="setter")],
+        ],
+    },
+    "sfban": {
+        "text": "SuperFban Settings:",
+        "buttons": [
+            [Button.inline("FBᴀɴ Gʀᴏᴜᴘ", data="sfgrp")],
+            [Button.inline("Exᴄʟᴜᴅᴇ Fᴇᴅs", data="abs_sfexf")],
+            [Button.inline("« Bᴀᴄᴋ", data="cbs_otvars")],
+        ],
+    },
+    "apauto": {
+        "text": "This'll auto approve on outgoing messages",
+        "buttons": [
+            [Button.inline("Aᴜᴛᴏ Aᴘᴘʀᴏᴠᴇ ON", data="apon")],
+            [Button.inline("Aᴜᴛᴏ Aᴘᴘʀᴏᴠᴇ OFF", data="apof")],
+            [Button.inline("« Bᴀᴄᴋ", data="cbs_pmcstm")],
+        ],
+    },
+    "alvcstm": {
+        "text": f"Customise your {HNDLR}alive. Choose from the below options -",
+        "buttons": [
+            [Button.inline("Aʟɪᴠᴇ Tᴇxᴛ", data="abs_alvtx")],
+            [Button.inline("Aʟɪᴠᴇ ᴍᴇᴅɪᴀ", data="alvmed")],
+            [Button.inline("Dᴇʟᴇᴛᴇ Aʟɪᴠᴇ Mᴇᴅɪᴀ", data="delmed")],
+            [Button.inline("« Bᴀᴄᴋ", data="setter")],
+        ],
+    },
+    "pmcstm": {
+        "text": "Customise your PMPERMIT Settings -",
+        "buttons": [
+            [
+                Button.inline("Pᴍ Tᴇxᴛ", data="pmtxt"),
+                Button.inline("Pᴍ Mᴇᴅɪᴀ", data="pmmed"),
+            ],
+            [
+                Button.inline("Aᴜᴛᴏ Aᴘᴘʀᴏᴠᴇ", data="cbs_apauto"),
+                Button.inline("PMLOGGER", data="pml"),
+            ],
+            [
+                Button.inline("Sᴇᴛ Wᴀʀɴs", data="swarn"),
+                Button.inline("Dᴇʟᴇᴛᴇ Pᴍ Mᴇᴅɪᴀ", data="delpmmed"),
+            ],
+            [Button.inline("PMPermit Type", data="cbs_pmtype")],
+            [Button.inline("« Bᴀᴄᴋ", data="cbs_ppmset")],
+        ],
+    },
+    "pmtype": {
+        "text": "Select the type of PMPermit needed.",
+        "buttons": [
+            [Button.inline("Inline", data="inpm_in")],
+            [Button.inline("Normal", data="inpm_no")],
+            [Button.inline("« Bᴀᴄᴋ", data="cbs_pmcstm")],
+        ],
+    },
+    "ppmset": {
+        "text": "PMPermit Settings:",
+        "buttons": [
+            [Button.inline("Tᴜʀɴ PMPᴇʀᴍɪᴛ Oɴ", data="pmon")],
+            [Button.inline("Tᴜʀɴ PMPᴇʀᴍɪᴛ Oғғ", data="pmoff")],
+            [Button.inline("Cᴜsᴛᴏᴍɪᴢᴇ PMPᴇʀᴍɪᴛ", data="cbs_pmcstm")],
+            [Button.inline("« Bᴀᴄᴋ", data="setter")],
+        ],
+    },
+    "chatbot": {
+        "text": "From This Feature U can chat with ppls Via ur Assistant Bot.\n[More info](https://t.me/UltroidUpdates/2)",
+        "buttons": [
+            [
+                Button.inline("Cʜᴀᴛ Bᴏᴛ  Oɴ", data="onchbot"),
+                Button.inline("Cʜᴀᴛ Bᴏᴛ  Oғғ", data="ofchbot"),
+            ],
+            [
+                Button.inline("Bᴏᴛ Wᴇʟᴄᴏᴍᴇ", data="bwel"),
+                Button.inline("Bᴏᴛ Wᴇʟᴄᴏᴍᴇ Mᴇᴅɪᴀ", data="botmew"),
+            ],
+            [Button.inline("Bᴏᴛ Iɴғᴏ Tᴇxᴛ", data="botinfe")],
+            [Button.inline("Fᴏʀᴄᴇ Sᴜʙsᴄʀɪʙᴇ", data="pmfs")],
+            [Button.inline("« Bᴀᴄᴋ", data="setter")],
+        ],
+    },
+    "vcb": {
+        "text": "From This Feature U can play songs in group voice chat\n\n[moreinfo](https://t.me/UltroidUpdates/4)",
+        "buttons": [
+            [Button.inline("VC Sᴇssɪᴏɴ", data="abs_vcs")],
+            [Button.inline("« Bᴀᴄᴋ", data="setter")],
+        ],
+    },
+    "oofdm": {
+        "text": "About [Dual Mode](https://t.me/UltroidUpdates/18)",
+        "buttons": [
+            [
+                Button.inline("Dᴜᴀʟ Mᴏᴅᴇ Oɴ", "dmof"),
+                Button.inline("Dᴜᴀʟ Mᴏᴅᴇ Oғғ", "dmof"),
+            ],
+            [Button.inline("Dᴜᴀʟ Mᴏᴅᴇ Hɴᴅʟʀ", "dmhn")],
+            [Button.inline("« Back", data="cbs_otvars")],
+        ],
+    },
+    "apiset": {
+        "text": get_string("ast_1"),
+        "buttons": [
+            [Button.inline("Remove.bg API", data="abs_rmbg")],
+            [Button.inline("DEEP API", data="abs_dapi")],
+            [Button.inline("OCR API", data="abs_oapi")],
+            [Button.inline("« Back", data="setter")],
+        ],
+    },
+}
+
+_convo = {
+    "rmbg": {
+        "var": "RMBG_API",
+        "name": "Remove.bg API Key",
+        "text": get_string("ast_2"),
+        "back": "cbs_apiset",
+    },
+    "dapi": {
+        "var": "DEEP_AI",
+        "name": "Deep AI Api Key",
+        "text": "Get Your Deep Api from deepai.org and send here.",
+        "back": "cbs_apiset",
+    },
+    "oapi": {
+        "var": "OCR_API",
+        "name": "Ocr Api Key",
+        "text": "Get Your OCR api from ocr.space and send that Here.",
+        "back": "cbs_apiset",
+    },
+    "pmlgg": {
+        "var": "PMLOGGROUP",
+        "name": "Pm Log Group",
+        "text": "Send chat id of chat which you want to save as Pm log Group.",
+        "back": "pml",
+    },
+    "vcs": {
+        "var": "VC_SESSION",
+        "name": "Vc Session",
+        "text": "**Vc session**\nEnter the New session u generated for vc bot.\n\nUse /cancel to terminate the operation.",
+        "back": "cbs_vcb",
+    },
+    "settag": {
+        "var": "TAG_LOG",
+        "name": "Tag Log Group",
+        "text": f"Make a group, add your assistant and make it admin.\nGet the `{HNDLR}id` of that group and send it here for tag logs.\n\nUse /cancel to cancel.",
+        "back": "taglog",
+    },
+    "alvtx": {
+        "var": "ALIVE_TEXT",
+        "name": "Alive Text",
+        "text": "**Alive Text**\nEnter the new alive text.\n\nUse /cancel to terminate the operation.",
+        "back": "cbs_alvcstm",
+    },
+    "sfexf": {
+        "var": "EXCLUDE_FED",
+        "name": "Excluded Fed",
+        "text": "Send the Fed IDs you want to exclude in the ban. Split by a space.\neg`id1 id2 id3`\nSet is as `None` if you dont want any.\nUse /cancel to go back.",
+        "back": "cbs_sfban",
+    },
+}
+
+
+TOKEN_FILE = "resources/auths/auth_token.txt"
+
+
+@callback(
+    re.compile(
+        "sndplug_(.*)",
+    ),
+    owner=True,
+)
+async def send(eve):
+    key, name = (eve.data_match.group(1)).decode("UTF-8").split("_")
+    thumb = "resources/extras/inline.jpg"
+    await eve.answer("■ Sending ■")
+    data = f"uh_{key}_"
+    index = None
+    if "|" in name:
+        name, index = name.split("|")
+    key = "plugins" if key == "Official" else key.lower()
+    plugin = f"{key}/{name}.py"
+    _ = f"pasta-{plugin}"
+    if index is not None:
+        data += f"|{index}"
+        _ += f"|{index}"
+    buttons = [
+        [
+            Button.inline(
+                "« Pᴀsᴛᴇ »",
+                data=_,
+            )
+        ],
+        [
+            Button.inline("« Bᴀᴄᴋ", data=data),
+        ],
+    ]
+    try:
+        await eve.edit(file=plugin, thumb=thumb, buttons=buttons)
+    except Exception as er:
+        await eve.answer(str(er), alert=True)
+
+
+heroku_api, app_name = Var.HEROKU_API, Var.HEROKU_APP_NAME
+
+
+@callback("updatenow", owner=True)
+async def update(eve):
+    repo = Repo()
+    ac_br = repo.active_branch
+    ups_rem = repo.remote("upstream")
+    if heroku_api:
+        import heroku3
+
+        try:
+            heroku = heroku3.from_key(heroku_api)
+            heroku_app = None
+            heroku_applications = heroku.apps()
+        except BaseException as er:
+            LOGS.exception(er)
+            return await eve.edit("`Wrong HEROKU_API.`")
+        for app in heroku_applications:
+            if app.name == app_name:
+                heroku_app = app
+        if not heroku_app:
+            await eve.edit("`Wrong HEROKU_APP_NAME.`")
+            repo.__del__()
+            return
+        await eve.edit(get_string("clst_1"))
+        ups_rem.fetch(ac_br)
+        repo.git.reset("--hard", "FETCH_HEAD")
+        heroku_git_url = heroku_app.git_url.replace(
+            "https://", f"https://api:{heroku_api}@"
+        )
+
+        if "heroku" in repo.remotes:
+            remote = repo.remote("heroku")
+            remote.set_url(heroku_git_url)
+        else:
+            remote = repo.create_remote("heroku", heroku_git_url)
+        try:
+            remote.push(refspec=f"HEAD:refs/heads/{ac_br}", force=True)
+        except GitCommandError as error:
+            await eve.edit(f"`Here is the error log:\n{error}`")
+            repo.__del__()
+            return
+        await eve.edit("`Successfully Updated!\nRestarting, please wait...`")
+    else:
+        await eve.edit(get_string("clst_1"))
+        call_back()
+        await bash("git pull && pip3 install -r requirements.txt")
+        await bash("pip3 install -r requirements.txt --break-system-packages")
+        execl(sys.executable, sys.executable, "-m", "pyUltroid")
+
+@callback(re.compile("changes(.*)"), owner=True)
+async def changes(okk):
+    match = okk.data_match.group(1).decode("utf-8")
+    await okk.answer(get_string("clst_3"))
+    repo = Repo.init()
+    button = [[Button.inline("Update Now", data="updatenow")]]
+    changelog, tl_chnglog = await gen_chlog(
+        repo, f"HEAD..upstream/{repo.active_branch}"
+    )
+    cli = "\n\nClick the below button to update!"
+    if not match:
+        try:
+            if len(tl_chnglog) > 700:
+                tl_chnglog = f"{tl_chnglog[:700]}..."
+                button.append([Button.inline("View Complete", "changesall")])
+            await okk.edit("• Writing Changelogs 📝 •")
+            img = await Carbon(
+                file_name="changelog",
+                code=tl_chnglog,
+                backgroundColor=choice(ATRA_COL),
+                language="md",
+            )
+            return await okk.edit(
+                f"**• Ultroid Userbot •**{cli}", file=img, buttons=button
+            )
+        except Exception as er:
+            LOGS.exception(er)
+    changelog_str = changelog + cli
+    if len(changelog_str) > 1024:
+        await okk.edit(get_string("upd_4"))
+        await asyncio.sleep(2)
+        with open("ultroid_updates.txt", "w+") as file:
+            file.write(tl_chnglog)
+        await okk.edit(
+            get_string("upd_5"),
+            file="ultroid_updates.txt",
+            buttons=button,
+        )
+        remove("ultroid_updates.txt")
+        return
+    await okk.edit(
+        changelog_str,
+        buttons=button,
+        parse_mode="html",
+    )
+
+
+@callback(
+    re.compile(
+        "pasta-(.*)",
+    ),
+    owner=True,
+)
+async def _(e):
+    ok = (e.data_match.group(1)).decode("UTF-8")
+    index = None
+    if "|" in ok:
+        ok, index = ok.split("|")
+    with open(ok, "r") as hmm:
+        _, data = await get_paste(hmm.read())
+    if not data.get("link"):
+        return await e.answer(key[:30], alert=True)
+    if not key.startswith("http"):
+        link, raw = data["link"], data["raw"]
+    else:
+        link = key
+        raw = f"{key}/raw"
+    if ok.startswith("addons"):
+        key = "Addons"
+    elif ok.startswith("vcbot"):
+        key = "VCBot"
+    else:
+        key = "Official"
+    data = f"uh_{key}_"
+    if index is not None:
+        data += f"|{index}"
+    await e.edit(
+        "",
+        buttons=[
+            [Button.url("Lɪɴᴋ", link), Button.url("Rᴀᴡ", raw)],
+            [Button.inline("« Bᴀᴄᴋ", data=data)],
+        ],
+    )
+
+
+@callback(re.compile("cbs_(.*)"), owner=True)
+async def _edit_to(event):
+    match = event.data_match.group(1).decode("utf-8")
+    data = _buttons.get(match)
+    if not data:
+        return
+    await event.edit(data["text"], buttons=data["buttons"], link_preview=False)
+
+
+@callback(re.compile("abs_(.*)"), owner=True)
+async def convo_handler(event: events.CallbackQuery):
+    match = event.data_match.group(1).decode("utf-8")
+    if not _convo.get(match):
+        return
+    await event.delete()
+    get_ = _convo[match]
+    back = get_["back"]
+    async with event.client.conversation(event.sender_id) as conv:
+        await conv.send_message(get_["text"])
+        response = await conv.get_response()
+        themssg = response.message
+        try:
+            themssg = ast.literal_eval(themssg)
+        except Exception:
+            pass
+        if themssg == "/cancel":
+            return await conv.send_message(
+                "Cancelled!!",
+                buttons=get_back_button(back),
+            )
+        await setit(event, get_["var"], themssg)
+        await conv.send_message(
+            f"{get_['name']} changed to `{themssg}`",
+            buttons=get_back_button(back),
+        )
+
+
+@callback("authorise", owner=True)
+async def _(e):
+    if not e.is_private:
+        return
+    url = GDrive._create_token_file()
+    await e.edit("Go to the below link and send the code!")
+    async with asst.conversation(e.sender_id) as conv:
+        await conv.send_message(url)
+        code = await conv.get_response()
+        if GDrive._create_token_file(code=code.text):
+            await conv.send_message(
+                "`Success!\nYou are all set to use Google Drive with Ultroid Userbot.`",
+                buttons=Button.inline("Main Menu", data="setter"),
+            )
+        else:
+            await conv.send_message("Wrong code! Click authorise again.")
+
+
+@callback("folderid", owner=True, func=lambda x: x.is_private)
+async def _(e):
+    if not e.is_private:
+        return
+    msg = (
+        "Send your FOLDER ID\n\n"
+        + "For FOLDER ID:\n"
+        + "1. Open Google Drive App.\n"
+        + "2. Create Folder.\n"
+        + "3. Make that folder public.\n"
+        + "4. Send link of that folder."
+    )
+    await e.delete()
+    async with asst.conversation(e.sender_id, timeout=150) as conv:
+        await conv.send_message(msg)
+        repl = await conv.get_response()
+        id = repl.text
+        if id.startswith("https"):
+            id = id.split("?id=")[-1]
+        udB.set_key("GDRIVE_FOLDER_ID", id)
+        await repl.reply(
+            "`Success.`",
+            buttons=get_back_button("gdrive"),
+        )
+
+
+@callback("gdrive", owner=True)
+async def _(e):
+    if not e.is_private:
+        return
+    await e.edit(
+        "Click Authorise and send the code.\n\nYou can use your own CLIENT ID and SECRET by [this](https://t.me/UltroidUpdates/37)",
+        buttons=[
+            [
+                Button.inline("Folder ID", data="folderid"),
+                Button.inline("Authorise", data="authorise"),
+            ],
+            [Button.inline("« Back", data="cbs_otvars")],
+        ],
+        link_preview=False,
+    )
+
+
+@callback("dmof", owner=True)
+async def rhwhe(e):
+    if udB.get_key("DUAL_MODE"):
+        udB.del_key("DUAL_MODE")
+        key = "Off"
+    else:
+        udB.set_key("DUAL_MODE", "True")
+        key = "On"
+    Msg = f"Dual Mode : {key}"
+    await e.edit(Msg, buttons=get_back_button("cbs_otvars"))
+
+
+@callback("dmhn", owner=True)
+async def hndlrr(event):
+    await event.delete()
+    pru = event.sender_id
+    var = "DUAL_HNDLR"
+    name = "Dual Handler"
+    CH = udB.get_key(var) or "/"
+    async with event.client.conversation(pru) as conv:
+        await conv.send_message(
+            f"Send The Symbol Which u want as Handler/Trigger to use your Assistant bot\nUr Current Handler is [ `{CH}` ]\n\n use /cancel to cancel.",
+        )
+        response = conv.wait_event(events.NewMessage(chats=pru))
+        response = await response
+        themssg = response.message.message
+        if themssg == "/cancel":
+            await conv.send_message(
+                "Cancelled!!",
+                buttons=get_back_button("cbs_otvars"),
+            )
+        elif len(themssg) > 1:
+            await conv.send_message(
+                "Incorrect Handler",
+                buttons=get_back_button("cbs_otvars"),
+            )
+        else:
+            await setit(event, var, themssg)
+            await conv.send_message(
+                f"{name} changed to {themssg}",
+                buttons=get_back_button("cbs_otvars"),
+            )
+
+
+@callback("emoj", owner=True)
+async def emoji(event):
+    await event.delete()
+    pru = event.sender_id
+    var = "EMOJI_IN_HELP"
+    name = f"Emoji in `{HNDLR}help` menu"
+    async with event.client.conversation(pru) as conv:
+        await conv.send_message("Send emoji u want to set 🙃.\n\nUse /cancel to cancel.")
+        response = conv.wait_event(events.NewMessage(chats=pru))
+        response = await response
+        themssg = response.message.message
+        if themssg == "/cancel":
+            await conv.send_message(
+                "Cancelled!!",
+                buttons=get_back_button("cbs_otvars"),
+            )
+        elif themssg.startswith(("/", HNDLR)):
+            await conv.send_message(
+                "Incorrect Emoji",
+                buttons=get_back_button("cbs_otvars"),
+            )
+        else:
+            await setit(event, var, themssg)
+            await conv.send_message(
+                f"{name} changed to {themssg}\n",
+                buttons=get_back_button("cbs_otvars"),
+            )
+
+
+@callback("plg", owner=True)
+async def pluginch(event):
+    await event.delete()
+    pru = event.sender_id
+    var = "PLUGIN_CHANNEL"
+    name = "Plugin Channel"
+    async with event.client.conversation(pru) as conv:
+        await conv.send_message(
+            "Send id or username of a channel from where u want to install all plugins\n\nOur Channel~ @ultroidplugins\n\nUse /cancel to cancel.",
+        )
+        response = conv.wait_event(events.NewMessage(chats=pru))
+        response = await response
+        themssg = response.message.message
+        if themssg == "/cancel":
+            await conv.send_message(
+                "Cancelled!!",
+                buttons=get_back_button("cbs_otvars"),
+            )
+        elif themssg.startswith(("/", HNDLR)):
+            await conv.send_message(
+                "Incorrect channel",
+                buttons=get_back_button("cbs_otvars"),
+            )
+        else:
+            await setit(event, var, themssg)
+            await conv.send_message(
+                f"{name} changed to {themssg}\n After Setting All Things Do Restart",
+                buttons=get_back_button("cbs_otvars"),
+            )
+
+
+@callback("hhndlr", owner=True)
+async def hndlrr(event):
+    await event.delete()
+    pru = event.sender_id
+    var = "HNDLR"
+    name = "Handler/ Trigger"
+    async with event.client.conversation(pru) as conv:
+        await conv.send_message(
+            f"Send The Symbol Which u want as Handler/Trigger to use bot\nUr Current Handler is [ `{HNDLR}` ]\n\n use /cancel to cancel.",
+        )
+        response = conv.wait_event(events.NewMessage(chats=pru))
+        response = await response
+        themssg = response.message.message
+        if themssg == "/cancel":
+            await conv.send_message(
+                "Cancelled!!",
+                buttons=get_back_button("cbs_otvars"),
+            )
+        elif len(themssg) > 1:
+            await conv.send_message(
+                "Incorrect Handler",
+                buttons=get_back_button("cbs_otvars"),
+            )
+        elif themssg.startswith(("/", "#", "@")):
+            await conv.send_message(
+                "This cannot be used as handler",
+                buttons=get_back_button("cbs_otvars"),
+            )
+        else:
+            await setit(event, var, themssg)
+            await conv.send_message(
+                f"{name} changed to {themssg}",
+                buttons=get_back_button("cbs_otvars"),
+            )
+
+
+@callback("shndlr", owner=True)
+async def hndlrr(event):
+    await event.delete()
+    pru = event.sender_id
+    var = "SUDO_HNDLR"
+    name = "Sudo Handler"
+    async with event.client.conversation(pru) as conv:
+        await conv.send_message(
+            "Send The Symbol Which u want as Sudo Handler/Trigger to use bot\n\n use /cancel to cancel."
+        )
+
+        response = conv.wait_event(events.NewMessage(chats=pru))
+        response = await response
+        themssg = response.message.message
+        if themssg == "/cancel":
+            await conv.send_message(
+                "Cancelled!!",
+                buttons=get_back_button("cbs_otvars"),
+            )
+        elif len(themssg) > 1:
+            await conv.send_message(
+                "Incorrect Handler",
+                buttons=get_back_button("cbs_otvars"),
+            )
+        elif themssg.startswith(("/", "#", "@")):
+            await conv.send_message(
+                "This cannot be used as handler",
+                buttons=get_back_button("cbs_otvars"),
+            )
+        else:
+            await setit(event, var, themssg)
+            await conv.send_message(
+                f"{name} changed to {themssg}",
+                buttons=get_back_button("cbs_otvars"),
+            )
+
+
+@callback("taglog", owner=True)
+async def tagloggrr(e):
+    BUTTON = [
+        [Button.inline("SET TAG LOG", data="abs_settag")],
+        [Button.inline("DELETE TAG LOG", data="deltag")],
+        get_back_button("cbs_otvars"),
+    ]
+    await e.edit(
+        "Choose Options",
+        buttons=BUTTON,
+    )
+
+
+@callback("deltag", owner=True)
+async def _(e):
+    udB.del_key("TAG_LOG")
+    await e.answer("Done!!! Tag Logger has been turned Off")
+
+
+@callback("eaddon", owner=True)
+async def pmset(event):
+    BT = (
+        [Button.inline("Aᴅᴅᴏɴs  Oғғ", data="edof")]
+        if udB.get_key("ADDONS")
+        else [Button.inline("Aᴅᴅᴏɴs  Oɴ", data="edon")]
+    )
+
+    await event.edit(
+        "ADDONS~ Extra Plugins:",
+        buttons=[
+            BT,
+            [Button.inline("« Bᴀᴄᴋ", data="cbs_otvars")],
+        ],
+    )
+
+
+@callback("edon", owner=True)
+async def eddon(event):
+    var = "ADDONS"
+    await setit(event, var, "True")
+    await event.edit(
+        "Done! ADDONS has been turned on!!\n\n After Setting All Things Do Restart",
+        buttons=get_back_button("eaddon"),
+    )
+
+
+@callback("edof", owner=True)
+async def eddof(event):
+    udB.set_key("ADDONS", "False")
+    await event.edit(
+        "Done! ADDONS has been turned off!! After Setting All Things Do Restart",
+        buttons=get_back_button("eaddon"),
+    )
+
+
+@callback("sudo", owner=True)
+async def pmset(event):
+    BT = (
+        [Button.inline("Sᴜᴅᴏ Mᴏᴅᴇ  Oғғ", data="ofsudo")]
+        if udB.get_key("SUDO")
+        else [Button.inline("Sᴜᴅᴏ Mᴏᴅᴇ  Oɴ", data="onsudo")]
+    )
+
+    await event.edit(
+        f"SUDO MODE ~ Some peoples can use ur Bot which u selected. To know More use `{HNDLR}help sudo`",
+        buttons=[
+            BT,
+            [Button.inline("« Bᴀᴄᴋ", data="cbs_otvars")],
+        ],
+    )
+
+
+@callback("onsudo", owner=True)
+async def eddon(event):
+    var = "SUDO"
+    await setit(event, var, "True")
+    await event.edit(
+        "Done! SUDO MODE has been turned on!!\n\n After Setting All Things Do Restart",
+        buttons=get_back_button("sudo"),
+    )
+
+
+@callback("ofsudo", owner=True)
+async def eddof(event):
+    var = "SUDO"
+    await setit(event, var, "False")
+    await event.edit(
+        "Done! SUDO MODE has been turned off!! After Setting All Things Do Restart",
+        buttons=get_back_button("sudo"),
+    )
+
+
+@callback("sfgrp", owner=True)
+async def sfgrp(event):
+    await event.delete()
+    name = "FBan Group ID"
+    var = "FBAN_GROUP_ID"
+    pru = event.sender_id
+    async with asst.conversation(pru) as conv:
+        await conv.send_message(
+            f"Make a group, add @MissRose_Bot, send `{HNDLR}id`, copy that and send it here.\nUse /cancel to go back.",
+        )
+        response = conv.wait_event(events.NewMessage(chats=pru))
+        response = await response
+        themssg = response.message.message
+        if themssg == "/cancel":
+            return await conv.send_message(
+                "Cancelled!!",
+                buttons=get_back_button("cbs_sfban"),
+            )
+        await setit(event, var, themssg)
+        await conv.send_message(
+            f"{name} changed to {themssg}",
+            buttons=get_back_button("cbs_sfban"),
+        )
+
+
+@callback("alvmed", owner=True)
+async def media(event):
+    await event.delete()
+    pru = event.sender_id
+    var = "ALIVE_PIC"
+    name = "Alive Media"
+    async with event.client.conversation(pru) as conv:
+        await conv.send_message(
+            "**Alive Media**\nSend me a pic/gif/media to set as alive media.\n\nUse /cancel to terminate the operation.",
+        )
+        response = await conv.get_response()
+        try:
+            themssg = response.message
+            if themssg == "/cancel":
+                return await conv.send_message(
+                    "Operation cancelled!!",
+                    buttons=get_back_button("cbs_alvcstm"),
+                )
+        except BaseException as er:
+            LOGS.exception(er)
+        if (
+            not (response.text).startswith("/")
+            and response.text != ""
+            and (not response.media or isinstance(response.media, MessageMediaWebPage))
+        ):
+            url = text_to_url(response)
+        elif response.sticker:
+            url = response.file.id
+        else:
+            media = await event.client.download_media(response, "alvpc")
+            try:
+                url = uploader.upload_file(media)
+                remove(media)
+            except BaseException as er:
+                LOGS.exception(er)
+                return await conv.send_message(
+                    "Terminated.",
+                    buttons=get_back_button("cbs_alvcstm"),
+                )
+        await setit(event, var, url)
+        await conv.send_message(
+            f"{name} has been set.",
+            buttons=get_back_button("cbs_alvcstm"),
+        )
+
+
+@callback("delmed", owner=True)
+async def dell(event):
+    try:
+        udB.del_key("ALIVE_PIC")
+        return await event.edit(
+            get_string("clst_5"), buttons=get_back_button("cbs_alabs_vcstm")
+        )
+    except BaseException as er:
+        LOGS.exception(er)
+        return await event.edit(
+            get_string("clst_4"),
+            buttons=get_back_button("cbs_alabs_vcstm"),
+        )
+
+
+@callback("inpm_in", owner=True)
+async def inl_on(event):
+    var = "INLINE_PM"
+    await setit(event, var, "True")
+    await event.edit(
+        "Done!! PMPermit type has been set to inline!",
+        buttons=[[Button.inline("« Bᴀᴄᴋ", data="cbs_pmtype")]],
+    )
+
+
+@callback("inpm_no", owner=True)
+async def inl_on(event):
+    var = "INLINE_PM"
+    await setit(event, var, "False")
+    await event.edit(
+        "Done!! PMPermit type has been set to normal!",
+        buttons=[[Button.inline("« Bᴀᴄᴋ", data="cbs_pmtype")]],
+    )
+
+
+@callback("pmtxt", owner=True)
+async def name(event):
+    await event.delete()
+    pru = event.sender_id
+    var = "PM_TEXT"
+    name = "PM Text"
+    async with event.client.conversation(pru) as conv:
+        await conv.send_message(
+            "**PM Text**\nEnter the new Pmpermit text.\n\nu can use `{name}` `{fullname}` `{count}` `{mention}` `{username}` to get this from user Too\n\nUse /cancel to terminate the operation.",
+        )
+        response = conv.wait_event(events.NewMessage(chats=pru))
+        response = await response
+        themssg = response.message.message
+        if themssg == "/cancel":
+            return await conv.send_message(
+                "Cancelled!!",
+                buttons=get_back_button("cbs_pmcstm"),
+            )
+        if len(themssg) > 4090:
+            return await conv.send_message(
+                "Message too long!\nGive a shorter message please!!",
+                buttons=get_back_button("cbs_pmcstm"),
+            )
+        await setit(event, var, themssg)
+        await conv.send_message(
+            f"{name} changed to {themssg}\n\nAfter Setting All Things Do restart",
+            buttons=get_back_button("cbs_pmcstm"),
+        )
+
+
+@callback("swarn", owner=True)
+async def name(event):
+    m = range(1, 10)
+    tultd = [Button.inline(f"{x}", data=f"wrns_{x}") for x in m]
+    lst = list(zip(tultd[::3], tultd[1::3], tultd[2::3]))
+    lst.append([Button.inline("« Bᴀᴄᴋ", data="cbs_pmcstm")])
+    await event.edit(
+        "Select the number of warnings for a user before getting blocked in PMs.",
+        buttons=lst,
+    )
+
+
+@callback(re.compile(b"wrns_(.*)"), owner=True)
+async def set_wrns(event):
+    value = int(event.data_match.group(1).decode("UTF-8"))
+    if dn := udB.set_key("PMWARNS", value):
+        await event.edit(
+            f"PM Warns Set to {value}.\nNew users will have {value} chances in PMs before getting banned.",
+            buttons=get_back_button("cbs_pmcstm"),
+        )
+    else:
+        await event.edit(
+            f"Something went wrong, please check your {HNDLR}logs!",
+            buttons=get_back_button("cbs_pmcstm"),
+        )
+
+
+@callback("pmmed", owner=True)
+async def media(event):
+    await event.delete()
+    pru = event.sender_id
+    var = "PMPIC"
+    name = "PM Media"
+    async with event.client.conversation(pru) as conv:
+        await conv.send_message(
+            "**PM Media**\nSend me a pic/gif/sticker/link  to set as pmpermit media.\n\nUse /cancel to terminate the operation.",
+        )
+        response = await conv.get_response()
+        try:
+            themssg = response.message
+            if themssg == "/cancel":
+                return await conv.send_message(
+                    "Operation cancelled!!",
+                    buttons=get_back_button("cbs_pmcstm"),
+                )
+        except BaseException as er:
+            LOGS.exception(er)
+        media = await event.client.download_media(response, "pmpc")
+        if (
+            not (response.text).startswith("/")
+            and response.text != ""
+            and (not response.media or isinstance(response.media, MessageMediaWebPage))
+        ):
+            url = text_to_url(response)
+        elif response.sticker:
+            url = response.file.id
+        else:
+            try:
+                url = uploader.upload_file(media)
+                remove(media)
+            except BaseException as er:
+                LOGS.exception(er)
+                return await conv.send_message(
+                    "Terminated.",
+                    buttons=get_back_button("cbs_pmcstm"),
+                )
+        await setit(event, var, url)
+        await conv.send_message(
+            f"{name} has been set.",
+            buttons=get_back_button("cbs_pmcstm"),
+        )
+
+
+@callback("delpmmed", owner=True)
+async def dell(event):
+    try:
+        udB.del_key("PMPIC")
+        return await event.edit(
+            get_string("clst_5"), buttons=get_back_button("cbs_pmcstm")
+        )
+    except BaseException as er:
+        LOGS.exception(er)
+        return await event.edit(
+            get_string("clst_4"),
+            buttons=[[Button.inline("« Sᴇᴛᴛɪɴɢs", data="setter")]],
+        )
+
+
+@callback("apon", owner=True)
+async def apon(event):
+    var = "AUTOAPPROVE"
+    await setit(event, var, "True")
+    await event.edit(
+        "Done!! AUTOAPPROVE  Started!!",
+        buttons=[[Button.inline("« Bᴀᴄᴋ", data="cbs_apauto")]],
+    )
+
+
+@callback("apof", owner=True)
+async def apof(event):
+    try:
+        udB.set_key("AUTOAPPROVE", "False")
+        return await event.edit(
+            "Done! AUTOAPPROVE Stopped!!",
+            buttons=[[Button.inline("« Bᴀᴄᴋ", data="cbs_apauto")]],
+        )
+    except BaseException as er:
+        LOGS.exception(er)
+        return await event.edit(
+            get_string("clst_4"),
+            buttons=[[Button.inline("« Sᴇᴛᴛɪɴɢs", data="setter")]],
+        )
+
+
+@callback("pml", owner=True)
+async def l_vcs(event):
+    BT = (
+        [Button.inline("PMLOGGER OFF", data="pmlogof")]
+        if udB.get_key("PMLOG")
+        else [Button.inline("PMLOGGER ON", data="pmlog")]
+    )
+
+    await event.edit(
+        "PMLOGGER This Will Forward Ur Pm to Ur Private Group -",
+        buttons=[
+            BT,
+            [Button.inline("PᴍLᴏɢɢᴇʀ Gʀᴏᴜᴘ", "abs_pmlgg")],
+            [Button.inline("« Bᴀᴄᴋ", data="cbs_pmcstm")],
+        ],
+    )
+
+
+@callback("pmlog", owner=True)
+async def pmlog(event):
+    await setit(event, "PMLOG", "True")
+    await event.edit(
+        "Done!! PMLOGGER  Started!!",
+        buttons=[[Button.inline("« Bᴀᴄᴋ", data="pml")]],
+    )
+
+
+@callback("pmlogof", owner=True)
+async def pmlogof(event):
+    try:
+        udB.del_key("PMLOG")
+        return await event.edit(
+            "Done! PMLOGGER Stopped!!",
+            buttons=[[Button.inline("« Bᴀᴄᴋ", data="pml")]],
+        )
+    except BaseException as er:
+        LOGS.exception(er)
+        return await event.edit(
+            get_string("clst_4"),
+            buttons=[[Button.inline("« Sᴇᴛᴛɪɴɢs", data="setter")]],
+        )
+
+
+@callback("pmon", owner=True)
+async def pmonn(event):
+    var = "PMSETTING"
+    await setit(event, var, "True")
+    await event.edit(
+        "Done! PMPermit has been turned on!!",
+        buttons=[[Button.inline("« Bᴀᴄᴋ", data="cbs_ppmset")]],
+    )
+
+
+@callback("pmoff", owner=True)
+async def pmofff(event):
+    var = "PMSETTING"
+    await setit(event, var, "False")
+    await event.edit(
+        "Done! PMPermit has been turned off!!",
+        buttons=[[Button.inline("« Bᴀᴄᴋ", data="cbs_ppmset")]],
+    )
+
+
+@callback("botmew", owner=True)
+async def hhh(e):
+    async with e.client.conversation(e.chat_id) as conv:
+        await conv.send_message("Send Any Media to keep at your Bot's welcome ")
+        msg = await conv.get_response()
+        if not msg.media or msg.text.startswith("/"):
+            return await conv.send_message(
+                "Terminated!", buttons=get_back_button("cbs_chatbot")
+            )
+        udB.set_key("STARTMEDIA", msg.file.id)
+        await conv.send_message("Done!", buttons=get_back_button("cbs_chatbot"))
+
+
+@callback("botinfe", owner=True)
+async def hhh(e):
+    async with e.client.conversation(e.chat_id) as conv:
+        await conv.send_message(
+            "Send message to set to Display, when user Press Info button in Bot Welcome!\n\nsend `False` to completely remove that button.."
+        )
+        msg = await conv.get_response()
+        if msg.media or msg.text.startswith("/"):
+            return await conv.send_message(
+                "Terminated!", buttons=get_back_button("cbs_chatbot")
+            )
+        udB.set_key("BOT_INFO_START", msg.text)
+        await conv.send_message("Done!", buttons=get_back_button("cbs_chatbot"))
+
+
+@callback("pmfs", owner=True)
+async def heheh(event):
+    Ll = []
+    err = ""
+    async with event.client.conversation(event.chat_id) as conv:
+        await conv.send_message(
+            "• Send The Chat Id(s), which you want user to Join Before using Chat/Pm Bot\n\n• Send /clear to disable PmBot Force sub..\n• • Send /cancel to stop this process.."
+        )
+        await conv.send_message(
+            "Example : \n`-1001234567\n-100778888`\n\nFor Multiple Chat(s)."
+        )
+        try:
+            msg = await conv.get_response()
+        except AsyncTimeOut:
+            return await conv.send_message("**• TimeUp!**\nStart from /start back.")
+        if not msg.text or msg.text.startswith("/"):
+            timyork = "Cancelled!"
+            if msg.text == "/clear":
+                udB.del_key("PMBOT_FSUB")
+                timyork = "Done! Force Subscribe Stopped\nRestart your Bot!"
+            return await conv.send_message(
+                "Cancelled!", buttons=get_back_button("cbs_chatbot")
+            )
+        for chat in msg.message.split("\n"):
+            if chat.startswith("-") or chat.isdigit():
+                chat = int(chat)
+            try:
+                CHSJSHS = await event.client.get_entity(chat)
+                Ll.append(get_peer_id(CHSJSHS))
+            except Exception as er:
+                err += f"**{chat}** : {er}\n"
+        if err:
+            return await conv.send_message(err)
+        udB.set_key("PMBOT_FSUB", str(Ll))
+        await conv.send_message(
+            "Done!\nRestart Your Bot.", buttons=get_back_button("cbs_chatbot")
+        )
+
+
+@callback("bwel", owner=True)
+async def name(event):
+    await event.delete()
+    pru = event.sender_id
+    var = "STARTMSG"
+    name = "Bot Welcome Message:"
+    async with event.client.conversation(pru) as conv:
+        await conv.send_message(
+            "**BOT WELCOME MSG**\nEnter the msg which u want to show when someone start your assistant Bot.\nYou Can use `{me}` , `{mention}` Parameters Too\nUse /cancel to terminate the operation.",
+        )
+        response = conv.wait_event(events.NewMessage(chats=pru))
+        response = await response
+        themssg = response.message.message
+        if themssg == "/cancel":
+            return await conv.send_message(
+                "Cancelled!!",
+                buttons=get_back_button("cbs_chatbot"),
+            )
+        await setit(event, var, themssg)
+        await conv.send_message(
+            f"{name} changed to {themssg}",
+            buttons=get_back_button("cbs_chatbot"),
+        )
+
+
+@callback("onchbot", owner=True)
+async def chon(event):
+    var = "PMBOT"
+    await setit(event, var, "True")
+    Loader(path="assistant/pmbot.py", key="PM Bot").load()
+    if AST_PLUGINS.get("pmbot"):
+        for i, e in AST_PLUGINS["pmbot"]:
+            event.client.remove_event_handler(i)
+        for i, e in AST_PLUGINS["pmbot"]:
+            event.client.add_event_handler(i, events.NewMessage(**e))
+    await event.edit(
+        "Done! Now u Can Chat With People Via This Bot",
+        buttons=[Button.inline("« Bᴀᴄᴋ", data="cbs_chatbot")],
+    )
+
+
+@callback("ofchbot", owner=True)
+async def chon(event):
+    var = "PMBOT"
+    await setit(event, var, "False")
+    if AST_PLUGINS.get("pmbot"):
+        for i, e in AST_PLUGINS["pmbot"]:
+            event.client.remove_event_handler(i)
+    await event.edit(
+        "Done! Chat People Via This Bot Stopped.",
+        buttons=[Button.inline("« Bᴀᴄᴋ", data="cbs_chatbot")],
+    )
+
+
+@callback("inli_pic", owner=True)
+async def media(event):
+    await event.delete()
+    pru = event.sender_id
+    var = "INLINE_PIC"
+    name = "Inline Media"
+    async with event.client.conversation(pru) as conv:
+        await conv.send_message(
+            "**Inline Media**\nSend me a pic/gif/ or link  to set as inline media.\n\nUse /cancel to terminate the operation.",
+        )
+        response = await conv.get_response()
+        try:
+            themssg = response.message
+            if themssg == "/cancel":
+                return await conv.send_message(
+                    "Operation cancelled!!",
+                    buttons=get_back_button("setter"),
+                )
+        except BaseException as er:
+            LOGS.exception(er)
+        media = await event.client.download_media(response, "inlpic")
+        if (
+            not (response.text).startswith("/")
+            and response.text != ""
+            and (not response.media or isinstance(response.media, MessageMediaWebPage))
+        ):
+            url = text_to_url(response)
+        else:
+            try:
+                url = uploader.upload_file(media)
+                remove(media)
+            except BaseException as er:
+                LOGS.exception(er)
+                return await conv.send_message(
+                    "Terminated.",
+                    buttons=get_back_button("setter"),
+                )
+        await setit(event, var, url)
+        await conv.send_message(
+            f"{name} has been set.",
+            buttons=get_back_button("setter"),
+        )
+
+
+FD_MEDIA = {}
+
+
+@callback(re.compile("fd(.*)"), owner=True)
+async def fdroid_dler(event):
+    uri = event.data_match.group(1).decode("utf-8")
+    if FD_MEDIA.get(uri):
+        return await event.edit(file=FD_MEDIA[uri])
+    await event.answer("• Starting Download •", alert=True)
+    await event.edit("• Downloading.. •")
+    URL = f"https://f-droid.org/packages/{uri}"
+    conte = await async_searcher(URL, re_content=True)
+    BSC = bs(conte, "html.parser", from_encoding="utf-8")
+    dl_ = BSC.find("p", "package-version-download").find("a")["href"]
+    title = BSC.find("h3", "package-name").text.strip()
+    thumb = BSC.find("img", "package-icon")["src"]
+    if thumb.startswith("/"):
+        thumb = f"https://f-droid.org{thumb}"
+    thumb, _ = await fast_download(thumb, filename=f"{uri}.png")
+    s_time = time.time()
+    file, _ = await fast_download(
+        dl_,
+        filename=f"{title}.apk",
+        progress_callback=lambda d, t: asyncio.get_event_loop().create_task(
+            progress(
+                d,
+                t,
+                event,
+                s_time,
+                "Downloading...",
+            )
+        ),
+    )
+
+    time.time()
+    n_file = await event.client.fast_uploader(
+        file, show_progress=True, event=event, message="Uploading...", to_delete=True
+    )
+    buttons = Button.switch_inline("Search Back", query="fdroid", same_peer=True)
+    try:
+        msg = await event.edit(
+            f"**• [{title}]({URL}) •**", file=n_file, thumb=thumb, buttons=buttons
+        )
+    except Exception as er:
+        LOGS.exception(er)
+        try:
+            msg = await event.client.edit_message(
+                await event.get_input_chat(),
+                event.message_id,
+                f"**• [{title}]({URL}) •**",
+                buttons=buttons,
+                thumb=thumb,
+                file=n_file,
+            )
+        except Exception as er:
+            os.remove(thumb)
+            LOGS.exception(er)
+            return await event.edit(f"**ERROR**: `{er}`", buttons=buttons)
+    if msg and hasattr(msg, "media"):
+        FD_MEDIA.update({uri: msg.media})
+    os.remove(thumb)

assistant/games.py

@@ -0,0 +1,331 @@
+# Ultroid - UserBot
+# Copyright (C) 2021-2025 TeamUltroid
+#
+# This file is a part of < https://github.com/TeamUltroid/Ultroid/ >
+# PLease read the GNU Affero General Public License in
+# <https://www.github.com/TeamUltroid/Ultroid/blob/main/LICENSE/>.
+
+"""
+• `{i}akinator` | `/akinator`
+   Start akinator game from Userbot/Assistant
+
+• `/startgame`
+   Open Portal for Games
+"""
+
+import asyncio
+import re, uuid, operator
+from random import choice, shuffle
+
+from akipy.async_akipy import Akinator
+from telethon.errors.rpcerrorlist import BotMethodInvalidError
+from telethon.events import Raw
+from telethon.tl.types import InputMediaPoll, Poll, PollAnswer, UpdateMessagePollVote
+
+from pyUltroid._misc._decorators import ultroid_cmd
+from logging import getLogger
+from html import unescape
+from telethon.tl.types import TextWithEntities
+from pyUltroid.fns.helper import inline_mention
+from pyUltroid.fns.tools import async_searcher
+from telethon.errors import ChatSendStickersForbiddenError
+
+from . import *  # Ensure this import matches your project structure
+
+games = {}
+aki_photo = "https://graph.org/file/3cc8825c029fd0cab9edc.jpg"
+
+akipyLOGS = getLogger("akipy")
+
+@ultroid_cmd(pattern="akinator")
+async def akina(e):
+    sta = Akinator()
+    games[e.chat_id] = {e.id: sta}
+    LOGS.info(f"Game started for chat {e.chat_id} with ID {e.id}.")
+    try:
+        m = await e.client.inline_query(asst.me.username, f"aki_{e.chat_id}_{e.id}")
+        await m[0].click(e.chat_id)
+        akipyLOGS.info(f"Clicked inline result for chat {e.chat_id}")
+    except BotMethodInvalidError as err:
+        akipyLOGS.error(f"BotMethodInvalidError: {err}")
+        await asst.send_file(
+            e.chat_id,
+            aki_photo,
+            buttons=Button.inline(get_string("aki_2"), data=f"aki_{e.chat_id}_{e.id}"),
+        )
+    except Exception as er:
+        akipyLOGS.error(f"Unexpected error: {er}")
+        return await e.eor(f"ERROR : {er}")
+    if e.out:
+        await e.delete()
+
+
+@asst_cmd(pattern="akinator", owner=True)
+async def _akokk(e):
+    await akina(e)
+
+
+@callback(re.compile("aki_(.*)"), owner=True)
+async def doai(e):
+    adt = e.pattern_match.group(1).strip().decode("utf-8")
+    dt = adt.split("_")
+    ch = int(dt[0])
+    mid = int(dt[1])
+    await e.edit(get_string("com_1"))
+    try:
+        await games[ch][mid].start_game(child_mode=False)
+        bts = [Button.inline(o, f"aka_{adt}_{o}") for o in ["Yes", "No", "Idk"]]
+        cts = [Button.inline(o, f"aka_{adt}_{o}") for o in ["Probably", "Probably Not"]]
+        bts = [bts, cts]
+        await e.edit(f"Q. {games[ch][mid].question}", buttons=bts)
+    except KeyError:
+        return await e.answer(get_string("aki_1"), alert=True)
+
+
+@callback(re.compile("aka_(.*)"), owner=True)
+async def okah(e):
+    try:
+        mk = e.pattern_match.group(1).decode("utf-8").split("_")
+        #akipyLOGS.info(f"Parsed values: {mk}")
+
+        if len(mk) < 3:
+            akipyLOGS.error("Pattern match did not return enough parts.")
+            return await e.answer("Invalid data received.", alert=True)
+
+        ch = int(mk[0])
+        mid = int(mk[1])
+        ans = mk[2]
+
+        gm = games[ch][mid]
+        await gm.answer(ans)
+
+        # Check for the final guess in the API response
+        if gm.name_proposition and gm.description_proposition:
+            gm.win = True
+            text = f"It's {gm.name_proposition}\n{gm.description_proposition}"
+            await e.edit(text, file=gm.photo)
+        else:
+            # Game is not won yet, continue asking questions
+            buttons = [
+                [Button.inline(o, f"aka_{ch}_{mid}_{o}") for o in ["Yes", "No", "Idk"]],
+                [Button.inline(o, f"aka_{ch}_{mid}_{o}") for o in ["Probably", "Probably Not"]],
+            ]
+            await e.edit(gm.question, buttons=buttons)
+
+    except KeyError:
+        await e.answer(get_string("aki_3"))
+    except Exception as ex:
+        akipyLOGS.error(f"An unexpected error occurred: {ex}")
+
+
+@in_pattern(re.compile("aki_?(.*)"), owner=True)
+async def eiagx(e):
+    bts = Button.inline(get_string("aki_2"), data=e.text)
+    ci = types.InputWebDocument(aki_photo, 0, "image/jpeg", [])
+    ans = [
+        await e.builder.article(
+            "Akinator",
+            type="photo",
+            content=ci,
+            text="Akinator",
+            thumb=ci,
+            buttons=bts,
+            include_media=True,
+        )
+    ]
+    await e.answer(ans)
+
+
+# ----------------------- Main Command ------------------- #
+
+GIMAGE = "https://graph.org/file/1c51015bae5205a65fd69.jpg"
+
+@asst_cmd(pattern="startgame", owner=True)
+async def magic(event):
+    buttons = [
+        [Button.inline("Trivia Quiz", "trzia")],
+        [Button.inline("Cancel ❌", "delit")],
+    ]
+    await event.reply(
+        get_string("games_1"),
+        file=GIMAGE,
+        buttons=buttons,
+    )
+
+
+# -------------------------- Trivia ----------------------- #
+
+TR_BTS = {}
+DIFI_KEYS = ["Easy", "Medium", "Hard"]
+TRIVIA_CHATS = {}
+POLLS = {}
+CONGO_STICKER = [
+    "CAADAgADSgIAAladvQrJasZoYBh68AI",
+    "CAADAgADXhIAAuyZKUl879mlR_dkOwI",
+    "CAADAgADpQAD9wLID-xfZCDwOI5LAg",
+    "CAADAgADjAADECECEFZM-SrKO9GgAg",
+    "CAADAgADSwIAAj-VzArAzNCDiGWAHAI",
+    "CAADAgADhQADwZxgDIuMHR9IU10iAg",
+    "CAADAgADiwMAAsSraAuoe2BwYu1sdQI",
+]
+
+
+@callback("delit", owner=True)
+async def delete_it(event):
+    await event.delete()
+
+
+@callback(re.compile("ctdown(.*)"), owner=True)
+async def ct_spam(e):
+    n = e.data_match.group(1).decode("utf-8")
+    await e.answer(f"Wait {n} seconds..", alert=True)
+
+
+@callback(re.compile("trzia(.*)"), owner=True)
+async def choose_cata(event):
+    match = event.data_match.group(1).decode("utf-8")
+    if not match:
+        if TR_BTS.get("category"):
+            buttons = TR_BTS["category"]
+        else:
+            req = (
+                await async_searcher(
+                    "https://opentdb.com/api_category.php", re_json=True
+                )
+            )["trivia_categories"]
+            btt = []
+            for i in req:
+                name = i["name"]
+                if ":" in name:
+                    name = name.split(":")[1]
+                btt.append(Button.inline(name, f"trziad_{i['id']}"))
+            buttons = list(zip(btt[::2], btt[1::2]))
+            if len(btt) % 2 == 1:
+                buttons.append((btt[-1],))
+            buttons.append([Button.inline("Cancel ❌", "delit")])
+            TR_BTS.update({"category": buttons})
+        text = get_string("games_2")
+    elif match[0] == "d":
+        cat = match[1:]
+        buttons = [[Button.inline(i, f"trziac{cat}_{i}") for i in DIFI_KEYS]]
+        buttons.append(get_back_button("trzia"))
+        text = get_string("games_3")
+    elif match[0] == "c":
+        m = match[1:]
+        buttons = [[Button.inline(str(i), f"trziat{m}_{i}") for i in range(10, 70, 20)]]
+        text = get_string("games_4")
+    elif match[0] == "t":
+        m_ = match[1:]
+        buttons = [
+            [Button.inline(str(i), f"trzias{m_}_{i}") for i in [10, 30, 60, 120]]
+        ]
+        text = get_string("games_5")
+    elif match[0] == "s":
+        chat = event.chat_id
+        cat, le, nu, in_ = match[2:].split("_")
+        msg = await event.edit(get_string("games_6").format(le, nu))
+        for i in reversed(range(5)):
+            msg = await msg.edit(buttons=Button.inline(f"{i} ⏰", f"ctdown{i}"))
+            await asyncio.sleep(1)
+        await msg.edit(
+            msg.text + "\n\n• Send /cancel to stop the Quiz...", buttons=None
+        )
+        qsss = await async_searcher(
+            f"https://opentdb.com/api.php?amount={nu}&category={cat}&difficulty={le.lower()}",
+            re_json=True,
+        )
+        qs = qsss["results"]
+        if not qs:
+            await event.respond("Sorry, No Question Found for the given Criteria..")
+            await event.delete()
+            return
+        TRIVIA_CHATS.update({chat: {}})
+        for copper, q in enumerate(qs):
+            if TRIVIA_CHATS[chat].get("cancel") is not None:
+                break
+            ansi = str(uuid.uuid1()).split("-")[0].encode()
+            opts = [PollAnswer(TextWithEntities(unescape(q["correct_answer"]), entities=[]), ansi)]
+            [
+                opts.append(
+                    PollAnswer(TextWithEntities(unescape(a), entities=[]), str(uuid.uuid1()).split("-")[0].encode())
+                )
+                for a in q["incorrect_answers"]
+            ]
+            shuffle(opts)
+            poll = InputMediaPoll(
+                Poll(
+                    0,
+                    TextWithEntities(
+                        f"[{copper+1}].  " + unescape(q["question"]),
+                        entities=[]
+                    ),
+                    answers=opts,
+                    public_voters=True,
+                    quiz=True,
+                    close_period=int(in_),
+                ),
+                correct_answers=[ansi],
+                solution="Join @TeamUltroid",
+                solution_entities=[],
+            )
+            m_ = await event.client.send_message(chat, file=poll)
+            POLLS.update({m_.poll.poll.id: {"chat": m_.chat_id, "answer": ansi}})
+            await asyncio.sleep(int(in_))
+        if not TRIVIA_CHATS[chat]:
+            await event.respond(
+                "No-One Got Any Score in the Quiz!\nBetter Luck Next Time!"
+            )
+        else:
+            try:
+                await event.respond(file=choice(CONGO_STICKER))
+            except ChatSendStickersForbiddenError:
+                pass
+            LBD = "🎯 **Scoreboard of the Quiz.**\n\n"
+            TRC = TRIVIA_CHATS[chat]
+            if "cancel" in TRC.keys():
+                del TRC["cancel"]
+            for userid, user_score in dict(
+                sorted(TRC.items(), key=operator.itemgetter(1), reverse=True)
+            ).items():
+                user = inline_mention(await event.client.get_entity(userid))
+                LBD += f"••• {user} - {user_score}\n"
+            await event.respond(LBD)
+        del TRIVIA_CHATS[chat]
+        list_ = list(POLLS.copy().keys())
+        for key in list_:
+            if POLLS[key]["chat"] == chat:
+                del POLLS[key]
+        return
+    await event.edit(text, buttons=buttons)
+
+
+@asst.on(
+    Raw(UpdateMessagePollVote, func=lambda x: TRIVIA_CHATS and POLLS.get(x.poll_id))
+)
+async def pollish(eve: UpdateMessagePollVote):
+    if POLLS.get(eve.poll_id)["chat"] not in TRIVIA_CHATS.keys():
+        return
+    if not eve.options:
+        # Consider as correct answer if no options selected
+        chat = POLLS.get(eve.poll_id)["chat"]
+        user = eve.peer.user_id
+        if not TRIVIA_CHATS.get(chat, {}).get(user):
+            TRIVIA_CHATS[chat][user] = 1
+        else:
+            TRIVIA_CHATS[chat][user] += 1
+        return
+    if POLLS[eve.poll_id]["answer"] != eve.options[0]:
+        return
+    chat = POLLS.get(eve.poll_id)["chat"]
+    user = eve.peer.user_id
+    if not TRIVIA_CHATS.get(chat, {}).get(user):
+        TRIVIA_CHATS[chat][user] = 1
+    else:
+        TRIVIA_CHATS[chat][user] += 1
+
+
+@asst_cmd("cancel", owner=True, func=lambda x: TRIVIA_CHATS.get(x.chat_id))
+async def cancelish(event):
+    chat = TRIVIA_CHATS.get(event.chat_id)
+    chat.update({"cancel": True})
+    await event.respond("Cancelled!")

assistant/initial.py

@@ -0,0 +1,84 @@
+# Ultroid - UserBot
+# Copyright (C) 2021-2025 TeamUltroid
+#
+# This file is a part of < https://github.com/TeamUltroid/Ultroid/ >
+# PLease read the GNU Affero General Public License in
+# <https://www.github.com/TeamUltroid/Ultroid/blob/main/LICENSE/>.
+
+import re
+
+from . import *
+
+STRINGS = {
+    1: """🎇 **Thanks for Deploying Ultroid Userbot!**
+
+• Here, are the Some Basic stuff from, where you can Know, about its Usage.""",
+    2: """🎉** About Ultroid**
+
+🧿 Ultroid is Pluggable and powerful Telethon Userbot, made in Python from Scratch. It is Aimed to Increase Security along with Addition of Other Useful Features.
+
+❣ Made by **@TeamUltroid**""",
+    3: """**💡• FAQs •**
+
+-> [Username Tracker](https://t.me/UltroidUpdates/24)
+-> [Keeping Custom Addons Repo](https://t.me/UltroidUpdates/28)
+-> [Disabling Deploy message](https://t.me/UltroidUpdates/27)
+-> [Setting up TimeZone](https://t.me/UltroidUpdates/22)
+-> [About Inline PmPermit](https://t.me/UltroidUpdates/21)
+-> [About Dual Mode](https://t.me/UltroidUpdates/18)
+-> [Custom Thumbnail](https://t.me/UltroidUpdates/13)
+-> [About FullSudo](https://t.me/UltroidUpdates/11)
+-> [Setting Up PmBot](https://t.me/UltroidUpdates/2)
+-> [Also Check](https://t.me/UltroidUpdates/14)
+
+**• To Know About Updates**
+  - Join @TeamUltroid.""",
+    4: f"""• `To Know All Available Commands`
+
+  - `{HNDLR}help`
+  - `{HNDLR}cmds`""",
+    5: """• **For Any Other Query or Suggestion**
+  - Move to **@UltroidSupportChat**.
+
+• Thanks for Reaching till END.""",
+}
+
+
+@callback(re.compile("initft_(\\d+)"))
+async def init_depl(e):
+    CURRENT = int(e.data_match.group(1))
+    if CURRENT == 5:
+        return await e.edit(
+            STRINGS[5],
+            buttons=Button.inline("<< Back", "initbk_4"),
+            link_preview=False,
+        )
+
+    await e.edit(
+        STRINGS[CURRENT],
+        buttons=[
+            Button.inline("<<", f"initbk_{str(CURRENT - 1)}"),
+            Button.inline(">>", f"initft_{str(CURRENT + 1)}"),
+        ],
+        link_preview=False,
+    )
+
+
+@callback(re.compile("initbk_(\\d+)"))
+async def ineiq(e):
+    CURRENT = int(e.data_match.group(1))
+    if CURRENT == 1:
+        return await e.edit(
+            STRINGS[1],
+            buttons=Button.inline("Start Back >>", "initft_2"),
+            link_preview=False,
+        )
+
+    await e.edit(
+        STRINGS[CURRENT],
+        buttons=[
+            Button.inline("<<", f"initbk_{str(CURRENT - 1)}"),
+            Button.inline(">>", f"initft_{str(CURRENT + 1)}"),
+        ],
+        link_preview=False,
+    )

assistant/inlinestuff.py

@@ -0,0 +1,623 @@
+# Ultroid - UserBot
+# Copyright (C) 2021-2025 TeamUltroid
+#
+# This file is a part of < https://github.com/TeamUltroid/Ultroid/ >
+# PLease read the GNU Affero General Public License in
+# <https://www.github.com/TeamUltroid/Ultroid/blob/main/LICENSE/>.
+
+import base64
+import inspect
+from datetime import datetime
+from html import unescape
+from random import choice
+from re import compile as re_compile
+
+from bs4 import BeautifulSoup as bs
+from telethon import Button
+from telethon.tl.alltlobjects import LAYER, tlobjects
+from telethon.tl.types import DocumentAttributeAudio as Audio
+from telethon.tl.types import InputWebDocument as wb
+
+from pyUltroid.fns.misc import google_search
+from pyUltroid.fns.tools import (
+    _webupload_cache,
+    async_searcher,
+    get_ofox,
+    saavn_search,
+    webuploader,
+)
+
+from . import *
+from . import _ult_cache
+
+SUP_BUTTONS = [
+    [
+        Button.url("• Repo •", url="https://github.com/TeamUltroid/Ultroid"),
+        Button.url("• Support •", url="t.me/UltroidSupportChat"),
+    ],
+]
+
+ofox = "https://graph.org/file/231f0049fcd722824f13b.jpg"
+gugirl = "https://graph.org/file/0df54ae4541abca96aa11.jpg"
+ultpic = "https://graph.org/file/4136aa1650bc9d4109cc5.jpg"
+
+apis = [
+    "QUl6YVN5QXlEQnNZM1dSdEI1WVBDNmFCX3c4SkF5NlpkWE5jNkZV",
+    "QUl6YVN5QkYwenhMbFlsUE1wOXh3TVFxVktDUVJxOERnZHJMWHNn",
+    "QUl6YVN5RGRPS253blB3VklRX2xiSDVzWUU0Rm9YakFLSVFWMERR",
+]
+
+
+@in_pattern("ofox", owner=True)
+async def _(e):
+    try:
+        match = e.text.split(" ", maxsplit=1)[1]
+    except IndexError:
+        kkkk = e.builder.article(
+            title="Enter Device Codename",
+            thumb=wb(ofox, 0, "image/jpeg", []),
+            text="**OFᴏx🦊Rᴇᴄᴏᴠᴇʀʏ**\n\nYou didn't search anything",
+            buttons=Button.switch_inline("Sᴇᴀʀᴄʜ Aɢᴀɪɴ", query="ofox ", same_peer=True),
+        )
+        return await e.answer([kkkk])
+    device, releases = await get_ofox(match)
+    if device.get("detail") is None:
+        fox = []
+        fullname = device["full_name"]
+        codename = device["codename"]
+        str(device["supported"])
+        maintainer = device["maintainer"]["name"]
+        link = f"https://orangefox.download/device/{codename}"
+        for data in releases["data"]:
+            release = data["type"]
+            version = data["version"]
+            size = humanbytes(data["size"])
+            release_date = datetime.utcfromtimestamp(data["date"]).strftime("%Y-%m-%d")
+            text = f"[\xad]({ofox})**OʀᴀɴɢᴇFᴏx Rᴇᴄᴏᴠᴇʀʏ Fᴏʀ**\n\n"
+            text += f"`  Fᴜʟʟ Nᴀᴍᴇ: {fullname}`\n"
+            text += f"`  Cᴏᴅᴇɴᴀᴍᴇ: {codename}`\n"
+            text += f"`  Mᴀɪɴᴛᴀɪɴᴇʀ: {maintainer}`\n"
+            text += f"`  Bᴜɪʟᴅ Tʏᴘᴇ: {release}`\n"
+            text += f"`  Vᴇʀsɪᴏɴ: {version}`\n"
+            text += f"`  Sɪᴢᴇ: {size}`\n"
+            text += f"`  Bᴜɪʟᴅ Dᴀᴛᴇ: {release_date}`"
+            fox.append(
+                await e.builder.article(
+                    title=f"{fullname}",
+                    description=f"{version}\n{release_date}",
+                    text=text,
+                    thumb=wb(ofox, 0, "image/jpeg", []),
+                    link_preview=True,
+                    buttons=[
+                        Button.url("Dᴏᴡɴʟᴏᴀᴅ", url=f"{link}"),
+                        Button.switch_inline(
+                            "Sᴇᴀʀᴄʜ Aɢᴀɪɴ", query="ofox ", same_peer=True
+                        ),
+                    ],
+                )
+            )
+        await e.answer(
+            fox, switch_pm="OrangeFox Recovery Search.", switch_pm_param="start"
+        )
+    else:
+        await e.answer(
+            [], switch_pm="OrangeFox Recovery Search.", switch_pm_param="start"
+        )
+
+
+@in_pattern("fl2lnk ?(.*)", owner=True)
+async def _(e):
+    match = e.pattern_match.group(1)
+    chat_id, msg_id = match.split(":")
+    filename = _webupload_cache[int(chat_id)][int(msg_id)]
+    if "/" in filename:
+        filename = filename.split("/")[-1]
+    __cache = f"{chat_id}:{msg_id}"
+    buttons = [
+        [
+            Button.inline("anonfiles", data=f"flanonfiles//{__cache}"),
+            Button.inline("transfer", data=f"fltransfer//{__cache}"),
+        ],
+        [
+            Button.inline("bayfiles", data=f"flbayfiles//{__cache}"),
+            Button.inline("x0.at", data=f"flx0.at//{__cache}"),
+        ],
+        [
+            Button.inline("file.io", data=f"flfile.io//{__cache}"),
+            Button.inline("siasky", data=f"flsiasky//{__cache}"),
+        ],
+    ]
+    try:
+        lnk = [
+            await e.builder.article(
+                title=f"Upload {filename}",
+                text=f"**File:**\n{filename}",
+                buttons=buttons,
+            )
+        ]
+    except BaseException as er:
+        LOGS.exception(er)
+        lnk = [
+            await e.builder.article(
+                title="fl2lnk",
+                text="File not found",
+            )
+        ]
+    await e.answer(lnk, switch_pm="File to Link.", switch_pm_param="start")
+
+
+@callback(
+    re_compile(
+        "fl(.*)",
+    ),
+    owner=True,
+)
+async def _(e):
+    t = (e.data).decode("UTF-8")
+    data = t[2:]
+    host = data.split("//")[0]
+    chat_id, msg_id = data.split("//")[1].split(":")
+    filename = _webupload_cache[int(chat_id)][int(msg_id)]
+    if "/" in filename:
+        filename = filename.split("/")[-1]
+    await e.edit(f"Uploading `{filename}` on {host}")
+    link = (await webuploader(chat_id, msg_id, host)).strip().replace("\n", "")
+    await e.edit(f"Uploaded `{filename}` on {host}.", buttons=Button.url("View", link))
+
+
+@in_pattern("repo", owner=True)
+async def repo(e):
+    res = [
+        await e.builder.article(
+            title="Ultroid Userbot",
+            description="Userbot | Telethon",
+            thumb=wb(ultpic, 0, "image/jpeg", []),
+            text="• **ULTROID USERBOT** •",
+            buttons=SUP_BUTTONS,
+        ),
+    ]
+    await e.answer(res, switch_pm="Ultroid Repo.", switch_pm_param="start")
+
+
+@in_pattern("go", owner=True)
+async def gsearch(q_event):
+    try:
+        match = q_event.text.split(maxsplit=1)[1]
+    except IndexError:
+        return await q_event.answer(
+            [], switch_pm="Google Search. Enter a query!", switch_pm_param="start"
+        )
+    searcher = []
+    gresults = await google_search(match)
+    for i in gresults:
+        try:
+            title = i["title"]
+            link = i["link"]
+            desc = i["description"]
+            searcher.append(
+                await q_event.builder.article(
+                    title=title,
+                    description=desc,
+                    thumb=wb(gugirl, 0, "image/jpeg", []),
+                    text=f"**Gᴏᴏɢʟᴇ Sᴇᴀʀᴄʜ**\n\n**••Tɪᴛʟᴇ••**\n`{title}`\n\n**••Dᴇsᴄʀɪᴘᴛɪᴏɴ••**\n`{desc}`",
+                    link_preview=False,
+                    buttons=[
+                        [Button.url("Lɪɴᴋ", url=f"{link}")],
+                        [
+                            Button.switch_inline(
+                                "Sᴇᴀʀᴄʜ Aɢᴀɪɴ",
+                                query="go ",
+                                same_peer=True,
+                            ),
+                            Button.switch_inline(
+                                "Sʜᴀʀᴇ",
+                                query=f"go {match}",
+                                same_peer=False,
+                            ),
+                        ],
+                    ],
+                ),
+            )
+        except IndexError:
+            break
+    await q_event.answer(searcher, switch_pm="Google Search.", switch_pm_param="start")
+
+
+@in_pattern("mods", owner=True)
+async def _(e):
+    try:
+        quer = e.text.split(" ", maxsplit=1)[1]
+    except IndexError:
+        return await e.answer(
+            [], switch_pm="Mod Apps Search. Enter app name!", switch_pm_param="start"
+        )
+    start = 0 * 3 + 1
+    da = base64.b64decode(choice(apis)).decode("ascii")
+    url = f"https://www.googleapis.com/customsearch/v1?key={da}&cx=25b3b50edb928435b&q={quer}&start={start}"
+    data = await async_searcher(url, re_json=True)
+    search_items = data.get("items", [])
+    modss = []
+    for a in search_items:
+        title = a.get("title")
+        desc = a.get("snippet")
+        link = a.get("link")
+        text = f"**••Tɪᴛʟᴇ••** `{title}`\n\n"
+        text += f"**Dᴇsᴄʀɪᴘᴛɪᴏɴ** `{desc}`"
+        modss.append(
+            await e.builder.article(
+                title=title,
+                description=desc,
+                text=text,
+                link_preview=True,
+                buttons=[
+                    [Button.url("Dᴏᴡɴʟᴏᴀᴅ", url=f"{link}")],
+                    [
+                        Button.switch_inline(
+                            "Mᴏʀᴇ Mᴏᴅs",
+                            query="mods ",
+                            same_peer=True,
+                        ),
+                        Button.switch_inline(
+                            "Sʜᴀʀᴇ",
+                            query=f"mods {quer}",
+                            same_peer=False,
+                        ),
+                    ],
+                ],
+            ),
+        )
+    await e.answer(modss, switch_pm="Search Mod Applications.", switch_pm_param="start")
+
+
+APP_CACHE = {}
+RECENTS = {}
+PLAY_API = "https://googleplay.onrender.com/api/apps?q="
+
+
+@in_pattern("app", owner=True)
+async def _(e):
+    try:
+        f = e.text.split(maxsplit=1)[1].lower()
+    except IndexError:
+        get_string("instu_1")
+        res = []
+        if APP_CACHE and RECENTS.get(e.sender_id):
+            res.extend(
+                APP_CACHE[a][0] for a in RECENTS[e.sender_id] if APP_CACHE.get(a)
+            )
+        return await e.answer(
+            res, switch_pm=get_string("instu_2"), switch_pm_param="start"
+        )
+    try:
+        return await e.answer(
+            APP_CACHE[f], switch_pm="Application Searcher.", switch_pm_param="start"
+        )
+    except KeyError:
+        pass
+    foles = []
+    url = PLAY_API + f.replace(" ", "+")
+    aap = await async_searcher(url, re_json=True)
+    for z in aap["results"][:50]:
+        url = "https://play.google.com/store/apps/details?id=" + z["appId"]
+        name = z["title"]
+        desc = unescape(z["summary"])[:300].replace("<br>", "\n") + "..."
+        dev = z["developer"]["devId"]
+        text = f"**••Aᴘᴘ Nᴀᴍᴇ••** [{name}]({url})\n"
+        text += f"**••Dᴇᴠᴇʟᴏᴘᴇʀ••** `{dev}`\n"
+        text += f"**••Dᴇsᴄʀɪᴘᴛɪᴏɴ••**\n`{desc}`"
+        foles.append(
+            await e.builder.article(
+                title=name,
+                description=dev,
+                thumb=wb(z["icon"], 0, "image/jpeg", []),
+                text=text,
+                link_preview=True,
+                buttons=[
+                    [Button.url("Lɪɴᴋ", url=url)],
+                    [
+                        Button.switch_inline(
+                            "Mᴏʀᴇ Aᴘᴘs",
+                            query="app ",
+                            same_peer=True,
+                        ),
+                        Button.switch_inline(
+                            "Sʜᴀʀᴇ",
+                            query=f"app {f}",
+                            same_peer=False,
+                        ),
+                    ],
+                ],
+            ),
+        )
+    APP_CACHE.update({f: foles})
+    if RECENTS.get(e.sender_id):
+        RECENTS[e.sender_id].append(f)
+    else:
+        RECENTS.update({e.sender_id: [f]})
+    await e.answer(foles, switch_pm="Application Searcher.", switch_pm_param="start")
+
+
+PISTON_URI = "https://emkc.org/api/v2/piston/"
+PISTON_LANGS = {}
+
+
+@in_pattern("run", owner=True)
+async def piston_run(event):
+    try:
+        lang = event.text.split()[1]
+        code = event.text.split(maxsplit=2)[2]
+    except IndexError:
+        result = await event.builder.article(
+            title="Bad Query",
+            description="Usage: [Language] [code]",
+            thumb=wb(
+                "https://graph.org/file/e33c57fc5f1044547e4d8.jpg", 0, "image/jpeg", []
+            ),
+            text=f'**Inline Usage**\n\n`@{asst.me.username} run python print("hello world")`\n\n[Language List](https://graph.org/Ultroid-09-01-6)',
+        )
+        return await event.answer([result])
+    if not PISTON_LANGS:
+        se = await async_searcher(f"{PISTON_URI}runtimes", re_json=True)
+        PISTON_LANGS.update({lang.pop("language"): lang for lang in se})
+    if lang in PISTON_LANGS.keys():
+        version = PISTON_LANGS[lang]["version"]
+    else:
+        result = await event.builder.article(
+            title="Unsupported Language",
+            description="Usage: [Language] [code]",
+            thumb=wb(
+                "https://graph.org/file/e33c57fc5f1044547e4d8.jpg", 0, "image/jpeg", []
+            ),
+            text=f'**Inline Usage**\n\n`@{asst.me.username} run python print("hello world")`\n\n[Language List](https://graph.org/Ultroid-09-01-6)',
+        )
+        return await event.answer([result])
+    output = await async_searcher(
+        f"{PISTON_URI}execute",
+        post=True,
+        json={
+            "language": lang,
+            "version": version,
+            "files": [{"content": code}],
+        },
+        re_json=True,
+    )
+
+    output = output["run"]["output"] or get_string("instu_4")
+    if len(output) > 3000:
+        output = f"{output[:3000]}..."
+    result = await event.builder.article(
+        title="Result",
+        description=output,
+        text=f"• **Language:**\n`{lang}`\n\n• **Code:**\n`{code}`\n\n• **Result:**\n`{output}`",
+        thumb=wb(
+            "https://graph.org/file/871ee4a481f58117dccc4.jpg", 0, "image/jpeg", []
+        ),
+        buttons=Button.switch_inline("Fork", query=event.text, same_peer=True),
+    )
+    await event.answer([result], switch_pm="• Piston •", switch_pm_param="start")
+
+
+FDROID_ = {}
+
+
+@in_pattern("fdroid", owner=True)
+async def do_magic(event):
+    try:
+        match = event.text.split(" ", maxsplit=1)[1].lower()
+    except IndexError:
+        return await event.answer(
+            [], switch_pm="Enter Query to Search", switch_pm_param="start"
+        )
+    if FDROID_.get(match):
+        return await event.answer(
+            FDROID_[match], switch_pm=f"• Results for {match}", switch_pm_param="start"
+        )
+    link = "https://search.f-droid.org/?q=" + match.replace(" ", "+")
+    content = await async_searcher(link, re_content=True)
+    BSC = bs(content, "html.parser", from_encoding="utf-8")
+    ress = []
+    for dat in BSC.find_all("a", "package-header")[:10]:
+        image = dat.find("img", "package-icon")["src"]
+        if image.endswith("/"):
+            image = "https://graph.org/file/a8dd4a92c5a53a89d0eff.jpg"
+        title = dat.find("h4", "package-name").text.strip()
+        desc = dat.find("span", "package-summary").text.strip()
+        text = f"• **Name :** `{title}`\n\n"
+        text += f"• **Description :** `{desc}`\n"
+        text += f"• **License :** `{dat.find('span', 'package-license').text.strip()}`"
+        imga = wb(image, 0, "image/jpeg", [])
+        ress.append(
+            await event.builder.article(
+                title=title,
+                type="photo",
+                description=desc,
+                text=text,
+                content=imga,
+                thumb=imga,
+                include_media=True,
+                buttons=[
+                    Button.inline(
+                        "• Download •", "fd" + dat["href"].split("packages/")[-1]
+                    ),
+                    Button.switch_inline("• Share •", query=event.text),
+                ],
+            )
+        )
+    msg = f"Showing {len(ress)} Results!" if ress else "No Results Found"
+    FDROID_.update({match: ress})
+    await event.answer(ress, switch_pm=msg, switch_pm_param="start")
+
+
+# Thanks to OpenSource
+_bearer_collected = [
+    "AAAAAAAAAAAAAAAAAAAAALIKKgEAAAAA1DRuS%2BI7ZRKiagD6KHYmreaXomo%3DP5Vaje4UTtEkODg0fX7nCh5laSrchhtLxeyEqxXpv0w9ZKspLD",
+    "AAAAAAAAAAAAAAAAAAAAAL5iUAEAAAAAmo6FYRjqdKlI3cNziIm%2BHUQB9Xs%3DS31pj0mxARMTOk2g9dvQ1yP9wknvY4FPBPUlE00smJcncw4dPR",
+    "AAAAAAAAAAAAAAAAAAAAAN6sVgEAAAAAMMjMMWrwgGyv7YQOWN%2FSAsO5SGM%3Dg8MG9Jq93Rlllaok6eht7HvRCruN4Vpzp4NaVsZaaHHWSTzKI8",
+]
+
+
+@in_pattern("twitter", owner=True)
+async def twitter_search(event):
+    try:
+        match = event.text.split(maxsplit=1)[1].lower()
+    except IndexError:
+        return await event.answer(
+            [], switch_pm="Enter Query to Search", switch_pm_param="start"
+        )
+    try:
+        return await event.answer(
+            _ult_cache["twitter"][match],
+            switch_pm="• Twitter Search •",
+            switch_pm_param="start",
+        )
+    except KeyError:
+        pass
+    headers = {"Authorization": f"bearer {choice(_bearer_collected)}"}
+    res = await async_searcher(
+        f"https://api.twitter.com/1.1/users/search.json?q={match}",
+        headers=headers,
+        re_json=True,
+    )
+    reso = []
+    for user in res:
+        thumb = wb(user["profile_image_url_https"], 0, "image/jpeg", [])
+        if user.get("profile_banner_url"):
+            url = user["profile_banner_url"]
+            text = f"[\xad]({url})• **Name :** `{user['name']}`\n"
+        else:
+            text = f"• **Name :** `{user['name']}`\n"
+        text += f"• **Description :** `{user['description']}`\n"
+        text += f"• **Username :** `@{user['screen_name']}`\n"
+        text += f"• **Followers :** `{user['followers_count']}`    • **Following :** `{user['friends_count']}`\n"
+        pro_ = "https://twitter.com/" + user["screen_name"]
+        text += f"• **Link :** [Click Here]({pro_})\n_"
+        reso.append(
+            await event.builder.article(
+                title=user["name"],
+                description=user["description"],
+                url=pro_,
+                text=text,
+                thumb=thumb,
+            )
+        )
+    swi_ = f"🐦 Showing {len(reso)} Results!" if reso else "No User Found :("
+    await event.answer(reso, switch_pm=swi_, switch_pm_param="start")
+    if _ult_cache.get("twitter"):
+        _ult_cache["twitter"].update({match: reso})
+    else:
+        _ult_cache.update({"twitter": {match: reso}})
+
+
+_savn_cache = {}
+
+
+@in_pattern("saavn", owner=True)
+async def savn_s(event):
+    try:
+        query = event.text.split(maxsplit=1)[1].lower()
+    except IndexError:
+        return await event.answer(
+            [], switch_pm="Enter Query to search 🔍", switch_pm_param="start"
+        )
+    if query in _savn_cache:
+        return await event.answer(
+            _savn_cache[query],
+            switch_pm=f"Showing Results for {query}",
+            switch_pm_param="start",
+        )
+    results = await saavn_search(query)
+    swi = "🎵 Saavn Search" if results else "No Results Found!"
+    res = []
+    for song in results:
+        thumb = wb(song["image"], 0, "image/jpeg", [])
+        text = f"• **Title :** {song['title']}"
+        text += f"\n• **Year :** {song['year']}"
+        text += f"\n• **Lang :** {song['language']}"
+        text += f"\n• **Artist :** {song['artists']}"
+        text += f"\n• **Release Date :** {song['release_date']}"
+        res.append(
+            await event.builder.article(
+                title=song["title"],
+                description=song["artists"],
+                type="audio",
+                text=text,
+                include_media=True,
+                buttons=Button.switch_inline(
+                    "Search Again 🔍", query="saavn", same_peer=True
+                ),
+                thumb=thumb,
+                content=wb(
+                    song["url"],
+                    0,
+                    "audio/mp4",
+                    [
+                        Audio(
+                            title=song["title"],
+                            duration=int(song["duration"]),
+                            performer=song["artists"],
+                        )
+                    ],
+                ),
+            )
+        )
+    await event.answer(res, switch_pm=swi, switch_pm_param="start")
+    _savn_cache.update({query: res})
+
+
+@in_pattern("tl", owner=True)
+async def inline_tl(ult):
+    try:
+        match = ult.text.split(maxsplit=1)[1]
+    except IndexError:
+        text = f"**Telegram TlObjects Searcher.**\n__(Don't use if you don't know what it is!)__\n\n• Example Usage\n`@{asst.me.username} tl GetFullUserRequest`"
+        return await ult.answer(
+            [
+                await ult.builder.article(
+                    title="How to Use?",
+                    description="Tl Searcher by Ultroid",
+                    url="https://t.me/TeamUltroid",
+                    text=text,
+                )
+            ],
+            switch_pm="Tl Search 🔍",
+            switch_pm_param="start",
+        )
+    res = []
+    for key in tlobjects.values():
+        if match.lower() in key.__name__.lower():
+            tyyp = "Function" if "tl.functions." in str(key) else "Type"
+            text = f"**Name:** `{key.__name__}`\n"
+            text += f"**Category:** `{tyyp}`\n"
+            text += f"\n`from {key.__module__} import {key.__name__}`\n\n"
+            if args := str(inspect.signature(key))[1:][:-1]:
+                text += "**Parameter:**\n"
+                for para in args.split(","):
+                    text += " " * 4 + "`" + para + "`\n"
+            text += f"\n**Layer:** `{LAYER}`"
+            res.append(
+                await ult.builder.article(
+                    title=key.__name__,
+                    description=tyyp,
+                    url="https://t.me/TeamUltroid",
+                    text=text[:4000],
+                )
+            )
+    mo = f"Showing {len(res)} results!" if res else f"No Results for {match}!"
+    await ult.answer(res[:50], switch_pm=mo, switch_pm_param="start")
+
+
+InlinePlugin.update(
+    {
+        "Pʟᴀʏ Sᴛᴏʀᴇ Aᴘᴘs": "app telegram",
+        "Mᴏᴅᴅᴇᴅ Aᴘᴘs": "mods minecraft",
+        "Sᴇᴀʀᴄʜ Oɴ Gᴏᴏɢʟᴇ": "go TeamUltroid",
+        "WʜɪSᴘᴇʀ": "wspr @username Hello🎉",
+        "YᴏᴜTᴜʙᴇ Dᴏᴡɴʟᴏᴀᴅᴇʀ": "yt Ed Sheeran Perfect",
+        "Piston Eval": "run javascript console.log('Hello Ultroid')",
+        "OʀᴀɴɢᴇFᴏx🦊": "ofox beryllium",
+        "Tᴡɪᴛᴛᴇʀ Usᴇʀ": "twitter theultroid",
+        "Fᴅʀᴏɪᴅ Sᴇᴀʀᴄʜ": "fdroid telegram",
+        "Sᴀᴀᴠɴ sᴇᴀʀᴄʜ": "saavn",
+        "Tʟ Sᴇᴀʀᴄʜ": "tl",
+    }
+)

assistant/localization.py

@@ -0,0 +1,47 @@
+# Ultroid - UserBot
+# Copyright (C) 2021-2025 TeamUltroid
+#
+# This file is a part of < https://github.com/TeamUltroid/Ultroid/ >
+# PLease read the GNU Affero General Public License in
+# <https://www.github.com/TeamUltroid/Ultroid/blob/main/LICENSE/>.
+
+import re
+
+from . import (
+    Button,
+    ULTConfig,
+    callback,
+    get_back_button,
+    get_languages,
+    get_string,
+    udB,
+)
+
+
+@callback("lang", owner=True)
+async def setlang(event):
+    languages = get_languages()
+    tultd = [
+        Button.inline(
+            f"{languages[ult]['natively']} [{ult.lower()}]",
+            data=f"set_{ult}",
+        )
+        for ult in languages
+    ]
+    buttons = list(zip(tultd[::2], tultd[1::2]))
+    if len(tultd) % 2 == 1:
+        buttons.append((tultd[-1],))
+    buttons.append([Button.inline("« Back", data="mainmenu")])
+    await event.edit(get_string("ast_4"), buttons=buttons)
+
+
+@callback(re.compile(b"set_(.*)"), owner=True)
+async def settt(event):
+    lang = event.data_match.group(1).decode("UTF-8")
+    languages = get_languages()
+    ULTConfig.lang = lang
+    udB.del_key("language") if lang == "en" else udB.set_key("language", lang)
+    await event.edit(
+        f"Your language has been set to {languages[lang]['natively']} [{lang}].",
+        buttons=get_back_button("lang"),
+    )

assistant/manager/__init__.py

@@ -0,0 +1,11 @@
+# Ultroid - UserBot
+# Copyright (C) 2021-2025 TeamUltroid
+#
+# This file is a part of < https://github.com/TeamUltroid/Ultroid/ >
+# PLease read the GNU Affero General Public License in
+# <https://www.github.com/TeamUltroid/Ultroid/blob/main/LICENSE/>.
+
+from pyUltroid._misc._decorators import ultroid_cmd
+from pyUltroid.fns.helper import inline_mention
+
+from .. import *

assistant/manager/_help.py

@@ -0,0 +1,134 @@
+# Ultroid - UserBot
+# Copyright (C) 2021-2025 TeamUltroid
+#
+# This file is a part of < https://github.com/TeamUltroid/Ultroid/ >
+# PLease read the GNU Affero General Public License in
+# <https://www.github.com/TeamUltroid/Ultroid/blob/main/LICENSE/>.
+
+from . import *
+
+START = """
+🪅 **Help Menu** 🪅
+
+✘  /start : Check I am Alive or not.
+✘  /help : Get This Message.
+✘  /repo : Get Bot's Repo..
+
+🧑‍💻 Join **@TeamUltroid**
+"""
+
+ADMINTOOLS = """✘ **AdminTools** ✘
+
+• /pin : Pins the Replied Message
+• /pinned : Get Pinned message in chat.
+• /unpin : Unpin the Replied message
+• /unpin all : Unpin all Pinned Messages.
+
+• /ban (username/id/reply) : Ban the User
+• /unban (username/id/reply) : UnBan the User.
+
+• /mute (username/id/reply) : Mute the User.
+• /unmute (username/id/reply) : Unmute the User.
+
+• /tban (username/id/reply) (time) : Temporary ban a user
+• /tmute (username/id/reply) (time) : temporary Mutes a User.
+
+• /purge (purge messages)
+
+• /setgpic (reply photo) : keep Chat Photo of Group.
+• /delgpic : remove current chat Photo."""
+
+UTILITIES = """
+✘ ** Utilities ** ✘
+
+• /info (reply/username/id) : get detailed info of user.
+• /id : get chat/user id.
+• /tr : Translate Languages..
+• /q : Create Quotes.
+
+• /paste (reply file/text) : paste content on Spaceb.in
+• /meaning (text) : Get Meaning of that Word.
+• /google (query) : Search Something on Google..
+
+• /suggest (query/reply) : Creates a Yes / No Poll.
+"""
+
+LOCKS = """
+✘ ** Locks ** ✘
+
+• /lock (query) : lock particular content in chat.
+• /unlock (query) : Unlock some content.
+
+• All Queries
+- `msgs` : for messages.
+- `inlines` : for inline queries.
+- `media` : for all medias.
+- `games` : for games.
+- `sticker` : for stickers.
+- `polls` : for polls.
+- `gif` : for gifs.
+- `pin` : for pins.
+- `changeinfo` : for change info right.
+"""
+
+MISC = """
+✘  **Misc**  ✘
+
+• /joke : Get Random Jokes.
+• /decide : Decide Something..
+
+**✘ Stickertools ✘**
+• /kang : add sticker to your pack.
+• /listpack : get all of yours pack..
+"""
+
+STRINGS = {"Admintools": ADMINTOOLS, "locks": LOCKS, "Utils": UTILITIES, "Misc": MISC}
+
+MNGE = udB.get_key("MNGR_EMOJI") or "•"
+
+
+def get_buttons():
+    BTTS = []
+    keys = STRINGS.copy()
+    while keys:
+        BT = []
+        for i in list(keys)[:2]:
+            text = f"{MNGE} {i} {MNGE}"
+            BT.append(Button.inline(text, f"hlp_{i}"))
+            del keys[i]
+        BTTS.append(BT)
+    url = f"https://t.me/{asst.me.username}?startgroup=true"
+    BTTS.append([Button.url("Add me to Group", url)])
+    return BTTS
+
+
+@asst_cmd(pattern="help")
+async def helpish(event):
+    if not event.is_private:
+        url = f"https://t.me/{asst.me.username}?start=start"
+        return await event.reply(
+            "Contact me in PM for help!", buttons=Button.url("Click me for Help", url)
+        )
+    if str(event.sender_id) in owner_and_sudos() and (
+        udB.get_key("DUAL_MODE") and (udB.get_key("DUAL_HNDLR") == "/")
+    ):
+        return
+    await event.reply(START, buttons=get_buttons())
+
+
+@callback("mngbtn", owner=True)
+async def ehwhshd(e):
+    buttons = get_buttons()
+    buttons.append([Button.inline("<< Back", "open")])
+    await e.edit(buttons=buttons)
+
+
+@callback("mnghome")
+async def home_aja(e):
+    await e.edit(START, buttons=get_buttons())
+
+
+@callback(re.compile("hlp_(.*)"))
+async def do_something(event):
+    match = event.pattern_match.group(1).strip().decode("utf-8")
+    await event.edit(STRINGS[match], buttons=Button.inline("<< Back", "mnghome"))

assistant/manager/_on_adds.py

@@ -0,0 +1,23 @@
+# Ultroid - UserBot
+# Copyright (C) 2021-2025 TeamUltroid
+#
+# This file is a part of < https://github.com/TeamUltroid/Ultroid/ >
+# PLease read the GNU Affero General Public License in
+# <https://www.github.com/TeamUltroid/Ultroid/blob/main/LICENSE/>.
+
+from telethon import events
+
+from . import *
+
+
+@asst.on(events.ChatAction(func=lambda x: x.user_added))
+async def dueha(e):
+    user = await e.get_user()
+    if not user.is_self:
+        return
+    sm = udB.get_key("ON_MNGR_ADD")
+    if sm == "OFF":
+        return
+    if not sm:
+        sm = "Thanks for Adding me :)"
+    await e.reply(sm, link_preview=False)

assistant/manager/admins.py

@@ -0,0 +1,50 @@
+# Ultroid - UserBot
+# Copyright (C) 2021-2025 TeamUltroid
+#
+# This file is a part of < https://github.com/TeamUltroid/Ultroid/ >
+# PLease read the GNU Affero General Public License in
+# <https://www.github.com/TeamUltroid/Ultroid/blob/main/LICENSE/>.
+
+import re
+
+from telethon.errors.rpcerrorlist import UserNotParticipantError
+
+from pyUltroid import _ult_cache
+
+from . import *
+
+
+@ultroid_cmd(pattern="d(kick|ban)", manager=True, require="ban_users")
+async def dowj(e):
+    replied = await e.get_reply_message()
+    if replied:
+        user = replied.sender_id
+    else:
+        return await e.eor("Reply to a message...")
+    try:
+        await replied.delete()
+        if e.pattern_match.group(1).strip() == "kick":
+            await e.client.kick_participant(e.chat_id, user)
+            te = "Kicked"
+        else:
+            await e.client.edit_permissions(e.chat_id, user, view_messages=False)
+            te = "Banned"
+        await e.eor(f"{te} Successfully!")
+    except Exception as E:
+        await e.eor(str(E))
+
+
+@callback(re.compile("cc_(.*)"), func=_ult_cache.get("admin_callback"))
+async def callback_(event):
+    data = event.data_match.group(1).decode("utf-8")
+    if data not in _ult_cache.get("admin_callback", {}):
+        return
+    try:
+        perm = await event.client.get_permissions(event.chat_id, event.sender_id)
+    except UserNotParticipantError:
+        return await event.answer("Join the Group First!", alert=True)
+    if not perm.is_admin:
+        return await event.answer("You are not an Admin!", alert=True)
+    _ult_cache["admin_callback"].update({data: (event.sender, perm)})
+    await event.answer("Verification Done!")
+    await event.delete()

assistant/manager/afk.py

@@ -0,0 +1,110 @@
+# Ultroid - UserBot
+# Copyright (C) 2021-2025 TeamUltroid
+#
+# This file is a part of < https://github.com/TeamUltroid/Ultroid/ >
+# PLease read the GNU Affero General Public License in
+# <https://www.github.com/TeamUltroid/Ultroid/blob/main/LICENSE/>.
+
+from datetime import datetime as dt
+
+from telethon.events import NewMessage
+from telethon.tl.types import (
+    Message,
+    MessageEntityMention,
+    MessageEntityMentionName,
+    User,
+)
+from telethon.utils import get_display_name
+
+from pyUltroid.fns.helper import inline_mention, time_formatter
+
+from . import asst, asst_cmd
+
+AFK = {}
+
+
+@asst_cmd(pattern="afk", func=lambda x: not x.is_private)
+async def go_afk(event):
+    sender = await event.get_sender()
+    if (not isinstance(sender, User)) or sender.bot:
+        return
+    try:
+        reason = event.text.split(" ", maxsplit=1)[1]
+    except IndexError:
+        reason = None
+    if event.is_reply and not reason:
+        replied = await event.get_reply_message()
+        if not reason and replied.text and not replied.media:
+            reason = replied.text
+        else:
+            reason = replied
+    time_ = dt.now()
+    if AFK.get(event.chat_id):
+        AFK[event.chat_id].update({event.sender_id: {"reason": reason, "time": time_}})
+    else:
+        AFK.update(
+            {event.chat_id: {event.sender_id: {"reason": reason, "time": time_}}}
+        )
+    mention = inline_mention(sender)
+    msg = f"**{mention} went AFK Now!**"
+    if reason and not isinstance(reason, str):
+        await event.reply(reason)
+    else:
+        msg += f"\n\n**Reason : ** `{reason}`"
+    await event.reply(msg)
+
+
+@asst.on(NewMessage(func=lambda x: AFK.get(x.chat_id) and not x.is_private))
+async def make_change(event):
+    if event.text.startswith("/afk"):
+        return
+    sender = await event.get_sender()
+    if (not isinstance(sender, User)) or sender.bot:
+        return
+    chat_ = AFK[event.chat_id]
+    if event.sender_id in chat_.keys():
+        name = get_display_name(event.sender)
+        cha_send = chat_[event.sender_id]
+        time_ = time_formatter((dt.now() - cha_send["time"]).seconds * 1000)
+        msg = f"**{name}** is No Longer AFK!\n**Was AFK for** {time_}"
+        await event.reply(msg)
+        del chat_[event.sender_id]
+        if not chat_:
+            del AFK[event.chat_id]
+    ST_SPAM = []
+    replied = await event.get_reply_message()
+    if replied:
+        name = get_display_name(replied.sender)
+        if replied.sender_id in chat_.keys():
+            s_der = chat_[replied.sender_id]
+            res_ = s_der["reason"]
+            time_ = time_formatter((dt.now() - s_der["time"]).seconds * 1000)
+            msg = f"**{name}** is AFK Currently!\n**From :** {time_}"
+            if res_ and isinstance(res_, str):
+                msg += f"\n**Reason :** {res_}"
+            elif res_ and isinstance(res_, Message):
+                await event.reply(res_)
+            await event.reply(msg)
+        ST_SPAM.append(replied.sender_id)
+    for ent, text in event.get_entities_text():
+        dont_send, entity = None, None
+        if isinstance(ent, MessageEntityMentionName):
+            c_id = ent.user_id
+        elif isinstance(ent, MessageEntityMention):
+            c_id = text
+        else:
+            c_id = None
+        if c_id:
+            entity = await event.client.get_entity(c_id)
+        if entity and entity.id in chat_.keys() and entity.id not in ST_SPAM:
+            ST_SPAM.append(entity.id)
+            s_der = chat_[entity.id]
+            name = get_display_name(entity)
+            res_ = s_der["reason"]
+            time_ = time_formatter((dt.now() - s_der["time"]).seconds * 1000)
+            msg = f"**{name}** is AFK Currently!\n**From :** {time_}"
+            if res_ and isinstance(res_, str):
+                msg += f"\n**Reason :** {res_}"
+            elif res_ and isinstance(res_, Message):
+                await event.reply(res_)
+            await event.reply(msg)

assistant/manager/misc.py

@@ -0,0 +1,64 @@
+# Ultroid - UserBot
+# Copyright (C) 2021-2025 TeamUltroid
+#
+# This file is a part of < https://github.com/TeamUltroid/Ultroid/ >
+# PLease read the GNU Affero General Public License in
+# <https://www.github.com/TeamUltroid/Ultroid/blob/main/LICENSE/>.
+
+
+import random
+
+import aiohttp
+
+from pyUltroid.dB import DEVLIST
+from pyUltroid.fns.admins import admin_check
+
+from . import *
+
+
+@asst_cmd(pattern="decide")
+async def dheh(e):
+    text = ["Yes", "NoU", "Maybe", "IDK"]
+    text = random.choice(text)
+    ri = e.reply_to_msg_id or e.id
+    await e.client.send_message(e.chat_id, text, reply_to=ri)
+
+
+@asst_cmd(pattern="echo( (.*)|$)")
+async def oqha(e):
+    if not await admin_check(e):
+        return
+    if match := e.pattern_match.group(1).strip():
+        text = match
+        reply_to = e
+    elif e.is_reply:
+        text = (await e.get_reply_message()).text
+        reply_to = e.reply_to_msg_id
+    else:
+        return await e.eor("What to Echo?", time=5)
+    try:
+        await e.delete()
+    except BaseException as ex:
+        LOGS.error(ex)
+    await e.client.send_message(e.chat_id, text, reply_to=reply_to)
+
+
+@asst_cmd(pattern="kickme$")
+async def doit(e):
+    if e.sender_id in DEVLIST:
+        return await eod(e, "`I will Not Kick You, my Developer..`")
+    try:
+        await e.client.kick_participant(e.chat_id, e.sender_id)
+    except Exception as Fe:
+        return await e.eor(str(Fe), time=5)
+    await e.eor("Yes, You are right, get out.", time=5)
+
+
+@asst_cmd(pattern="joke$")
+async def do_joke(e):
+    e = await e.get_reply_message() if e.is_reply else e
+    link = "https://v2.jokeapi.dev/joke/Any?blacklistFlags=nsfw,religious,political,racist,sexist,explicit&type=single"
+    async with aiohttp.ClientSession() as ses:
+        async with ses.get(link) as out:
+            out = await out.json()
+    await e.reply(out["joke"])

assistant/manager/stickermanager.py

@@ -0,0 +1,180 @@
+# Ultroid - UserBot
+# Copyright (C) 2021-2025 TeamUltroid
+#
+# This file is a part of < https://github.com/TeamUltroid/Ultroid/ >
+# PLease read the GNU Affero General Public License in
+# <https://www.github.com/TeamUltroid/Ultroid/blob/main/LICENSE/>.
+
+import random
+
+from telethon import errors
+from telethon.errors.rpcerrorlist import StickersetInvalidError
+from telethon.tl.functions.messages import GetStickerSetRequest as GetSticker
+from telethon.tl.functions.messages import UploadMediaRequest
+from telethon.tl.functions.stickers import AddStickerToSetRequest as AddSticker
+from telethon.tl.functions.stickers import CreateStickerSetRequest
+from telethon.tl.types import InputPeerSelf
+from telethon.tl.types import InputStickerSetItem as SetItem
+from telethon.tl.types import InputStickerSetShortName, User
+from telethon.utils import get_display_name, get_input_document
+
+from pyUltroid.fns.misc import Quotly
+from pyUltroid.fns.tools import TgConverter
+
+from . import LOGS, asst, asst_cmd, udB
+
+
+@asst_cmd(
+    pattern="kang",
+)
+async def kang_cmd(ult):
+    sender = await ult.get_sender()
+    if not isinstance(sender, User):
+        return
+    if not ult.is_reply:
+        return await ult.eor("`Reply to a sticker/photo..`", time=5)
+    reply = await ult.get_reply_message()
+    if sender.username:
+        pre = sender.username[:4]
+    else:
+        pre = random.random_string(length=3)
+    animated, dl, video = None, None, None
+    try:
+        emoji = ult.text.split(maxsplit=1)[1]
+    except IndexError:
+        emoji = None
+    if reply.sticker:
+        file = get_input_document(reply.sticker)
+        emoji = emoji or reply.file.emoji
+        name = reply.file.name
+        if name.endswith(".tgs"):
+            animated = True
+            dl = await reply.download_media()
+        elif name.endswith(".webm"):
+            video = True
+            dl = await reply.download_media()
+    elif reply.photo:
+        dl = await reply.download_media()
+        name = "sticker.webp"
+        image = TgConverter.resize_photo_sticker(dl)
+        image.save(name, "WEBP")
+    elif reply.text:
+        dl = await Quotly().create_quotly(reply)
+    else:
+        return await ult.eor("`Reply to sticker or text to add it in your pack...`")
+    if not emoji:
+        emoji = "🏵"
+    if dl:
+        upl = await ult.client.upload_file(dl)
+        file = get_input_document(
+            await ult.client(UploadMediaRequest(InputPeerSelf(), upl))
+        )
+    get_ = udB.get_key("STICKERS") or {}
+    type_ = "anim" if animated else "static"
+    if not get_.get(ult.sender_id) or not get_.get(ult.sender_id, {}).get(type_):
+        sn = f"{pre}_{ult.sender_id}"
+        title = f"{get_display_name(sender)}'s Kang Pack"
+        if animated:
+            type_ = "anim"
+            sn += "_anim"
+            title += " (Animated)"
+        elif video:
+            type_ = "vid"
+            sn += "_vid"
+            title += " (Video)"
+        sn += f"_by_{asst.me.username}"
+        try:
+            await asst(GetSticker(InputStickerSetShortName(sn), hash=0))
+            sn = sn.replace(str(ult.sender_id), f"{ult.sender_id}_{ult.id}")
+        except StickersetInvalidError:
+            pass
+        try:
+            pack = await ult.client(
+                CreateStickerSetRequest(
+                    user_id=sender.id,
+                    title=title,
+                    short_name=sn,
+                    stickers=[SetItem(file, emoji=emoji)],
+                    videos=video,
+                    animated=animated,
+                    software="@TeamUltroid",
+                )
+            )
+        except Exception as er:
+            return await ult.eor(str(er))
+        sn = pack.set.short_name
+        if not get_.get(ult.sender_id):
+            get_.update({ult.sender_id: {type_: [sn]}})
+        else:
+            get_[ult.sender_id].update({type_: [sn]})
+        udB.set_key("STICKERS", get_)
+        return await ult.reply(
+            f"**Kanged Successfully!\nEmoji :** {emoji}\n**Link :** [Click Here](https://t.me/addstickers/{sn})"
+        )
+    name = get_[ult.sender_id][type_][-1]
+    try:
+        await asst(GetSticker(InputStickerSetShortName(name), hash=0))
+    except StickersetInvalidError:
+        get_[ult.sender_id][type_].remove(name)
+    try:
+        await asst(
+            AddSticker(InputStickerSetShortName(name), SetItem(file, emoji=emoji))
+        )
+    except (errors.StickerpackStickersTooMuchError, errors.StickersTooMuchError):
+        sn = f"{pre}{ult.sender_id}_{ult.id}"
+        title = f"{get_display_name(sender)}'s Kang Pack"
+        if animated:
+            sn += "_anim"
+            title += " (Animated)"
+        elif video:
+            sn += "_vid"
+            title += "(Video)"
+        sn += f"_by_{asst.me.username}"
+        try:
+            pack = await ult.client(
+                CreateStickerSetRequest(
+                    user_id=sender.id,
+                    title=title,
+                    short_name=sn,
+                    stickers=[SetItem(file, emoji=emoji)],
+                    animated=animated,
+                )
+            )
+        except Exception as er:
+            return await ult.eor(str(er))
+        get_[ult.sender_id][type_].append(pack.set.short_name)
+        udB.set_key("STICKERS", get_)
+        return await ult.reply(
+            f"**Created New Kang Pack!\nEmoji :** {emoji}\n**Link :** [Click Here](https://t.me/addstickers/{sn})"
+        )
+    except Exception as er:
+        LOGS.exception(er)
+        return await ult.reply(str(er))
+    await ult.reply(
+        f"Sticker Added to Pack Successfully\n**Link :** [Click Here](https://t.me/addstickers/{name})"
+    )
+
+
+@asst_cmd(pattern="listpack")
+async def do_magic(ult):
+    ko = udB.get_key("STICKERS") or {}
+    if not ko.get(ult.sender_id):
+        return await ult.reply("No Sticker Pack Found!")
+    al_ = []
+    ul = ko[ult.sender_id]
+    for _ in ul.keys():
+        al_.extend(ul[_])
+    msg = "• **Stickers Owned by You!**\n\n"
+    for _ in al_:
+        try:
+            pack = await ult.client(GetSticker(InputStickerSetShortName(_), hash=0))
+            msg += f"• [{pack.set.title}](https://t.me/addstickers/{_})\n"
+        except StickerSetInvalidError:
+            if ul.get("anim") and _ in ul["anim"]:
+                ul["anim"].remove(_)
+            elif ul.get("vid") and _ in ul["vid"]:
+                ul["vid"].remove(_)
+            else:
+                ul["static"].remove(_)
+            udB.set_key("STICKERS", ko)
+    await ult.reply(msg)

assistant/pmbot.py

@@ -0,0 +1,150 @@
+# Ultroid - UserBot
+# Copyright (C) 2021-2025 TeamUltroid
+#
+# This file is a part of < https://github.com/TeamUltroid/Ultroid/ >
+# PLease read the GNU Affero General Public License in
+# <https://www.github.com/TeamUltroid/Ultroid/blob/main/LICENSE/>.
+
+# https://github.com/xditya/TeleBot/blob/master/telebot/plugins/mybot/pmbot/incoming.py
+
+# --------------------------------------- Imports -------------------------------------------- #
+
+import os
+
+from telethon.errors.rpcerrorlist import UserNotParticipantError
+from telethon.tl.custom import Button
+from telethon.tl.functions.channels import GetFullChannelRequest
+from telethon.tl.functions.messages import GetFullChatRequest
+from telethon.tl.types import Channel, Chat
+from telethon.utils import get_display_name
+
+from pyUltroid.dB.base import KeyManager
+from pyUltroid.dB.botchat_db import *
+from pyUltroid.fns.helper import inline_mention
+
+from . import *
+
+botb = KeyManager("BOTBLS", cast=list)
+FSUB = udB.get_key("PMBOT_FSUB")
+CACHE = {}
+# --------------------------------------- Incoming -------------------------------------------- #
+
+
+@asst_cmd(
+    load=AST_PLUGINS,
+    incoming=True,
+    func=lambda e: e.is_private and not botb.contains(e.sender_id),
+)
+async def on_new_mssg(event):
+    who = event.sender_id
+    # doesn't reply to that user anymore
+    if event.text.startswith("/") or who == OWNER_ID:
+        return
+    if FSUB:
+        MSG = ""
+        BTTS = []
+        for chat in FSUB:
+            try:
+                await event.client.get_permissions(chat, event.sender_id)
+            except UserNotParticipantError:
+                if not MSG:
+                    MSG += get_string("pmbot_1")
+                try:
+                    uri = ""
+                    TAHC_ = await event.client.get_entity(chat)
+                    if hasattr(TAHC_, "username") and TAHC_.username:
+                        uri = f"t.me/{TAHC_.username}"
+                    elif CACHE.get(chat):
+                        uri = CACHE[chat]
+                    else:
+                        if isinstance(TAHC_, Channel):
+                            FUGB = await event.client(GetFullChannelRequest(chat))
+                        elif isinstance(TAHC_, Chat):
+                            FUGB = await event.client(GetFullChatRequest(chat))
+                        else:
+                            return
+                        if FUGB.full_chat.exported_invite:
+                            CACHE[chat] = FUGB.full_chat.exported_invite.link
+                            uri = CACHE[chat]
+                    BTTS.append(Button.url(get_display_name(TAHC_), uri))
+                except Exception as er:
+                    LOGS.exception(f"Error On PmBot Force Sub!\n - {chat} \n{er}")
+        if MSG and BTTS:
+            return await event.reply(MSG, buttons=BTTS)
+    xx = await event.forward_to(OWNER_ID)
+    if event.fwd_from:
+        await xx.reply(f"From {inline_mention(event.sender)} [`{event.sender_id}`]")
+    add_stuff(xx.id, who)
+
+
+# --------------------------------------- Outgoing -------------------------------------------- #
+
+
+@asst_cmd(
+    load=AST_PLUGINS,
+    from_users=[OWNER_ID],
+    incoming=True,
+    func=lambda e: e.is_private and e.is_reply,
+)
+async def on_out_mssg(event):
+    x = event.reply_to_msg_id
+    to_user = get_who(x)
+    if event.text.startswith("/who"):
+        try:
+            k = await asst.get_entity(to_user)
+            photu = await event.client.download_profile_photo(k.id)
+            await event.reply(
+                f"• **Name :** {get_display_name(k)}\n• **ID :** `{k.id}`\n• **Link :** {inline_mention(k)}",
+                file=photu,
+            )
+            if photu:
+                os.remove(photu)
+            return
+        except BaseException as er:
+            return await event.reply(f"**ERROR : **{str(er)}")
+    elif event.text.startswith("/"):
+        return
+    if to_user:
+        await asst.send_message(to_user, event.message)
+
+
+# --------------------------------------- Ban/Unban -------------------------------------------- #
+
+
+@asst_cmd(
+    pattern="ban",
+    load=AST_PLUGINS,
+    from_users=[OWNER_ID],
+    func=lambda x: x.is_private,
+)
+async def banhammer(event):
+    if not event.is_reply:
+        return await event.reply(get_string("pmbot_2"))
+    target = get_who(event.reply_to_msg_id)
+    if botb.contains(target):
+        return await event.reply(get_string("pmbot_3"))
+
+    botb.add(target)
+    await event.reply(f"#BAN\nUser : {target}")
+    await asst.send_message(target, get_string("pmbot_4"))
+
+
+@asst_cmd(
+    pattern="unban",
+    load=AST_PLUGINS,
+    from_users=[OWNER_ID],
+    func=lambda x: x.is_private,
+)
+async def unbanhammer(event):
+    if not event.is_reply:
+        return await event.reply(get_string("pmbot_5"))
+    target = get_who(event.reply_to_msg_id)
+    if not botb.contains(target):
+        return await event.reply(get_string("pmbot_6"))
+
+    botb.remove(target)
+    await event.reply(f"#UNBAN\nUser : {target}")
+    await asst.send_message(target, get_string("pmbot_7"))
+
+
+# --------------------------------------- END -------------------------------------------- #

assistant/start.py

@@ -0,0 +1,240 @@
+# Ultroid - UserBot
+# Copyright (C) 2021-2025 TeamUltroid
+#
+# This file is a part of < https://github.com/TeamUltroid/Ultroid/ >
+# PLease read the GNU Affero General Public License in
+# <https://www.github.com/TeamUltroid/Ultroid/blob/main/LICENSE/>.
+
+from datetime import datetime
+
+from pytz import timezone as tz
+from telethon import Button, events
+from telethon.errors.rpcerrorlist import MessageDeleteForbiddenError
+from telethon.utils import get_display_name
+
+from pyUltroid._misc import SUDO_M, owner_and_sudos
+from pyUltroid.dB.base import KeyManager
+from pyUltroid.fns.helper import inline_mention
+from strings import get_string
+
+from . import *
+
+Owner_info_msg = udB.get_key("BOT_INFO_START")
+custom_info = True
+if Owner_info_msg is None:
+    custom_info = False
+    Owner_info_msg = f"""
+**Owner** - {OWNER_NAME}
+**OwnerID** - `{OWNER_ID}`
+
+**Message Forwards** - {udB.get_key("PMBOT")}
+
+**Ultroid [v{ultroid_version}](https://github.com/TeamUltroid/Ultroid), powered by @TeamUltroid**
+"""
+
+
+_settings = [
+    [
+        Button.inline("API Kᴇʏs", data="cbs_apiset"),
+        Button.inline("Pᴍ Bᴏᴛ", data="cbs_chatbot"),
+    ],
+    [
+        Button.inline("Aʟɪᴠᴇ", data="cbs_alvcstm"),
+        Button.inline("PᴍPᴇʀᴍɪᴛ", data="cbs_ppmset"),
+    ],
+    [
+        Button.inline("Fᴇᴀᴛᴜʀᴇs", data="cbs_otvars"),
+        Button.inline("VC Sᴏɴɢ Bᴏᴛ", data="cbs_vcb"),
+    ],
+    [Button.inline("« Bᴀᴄᴋ", data="mainmenu")],
+]
+
+_start = [
+    [
+        Button.inline("Lᴀɴɢᴜᴀɢᴇ 🌐", data="lang"),
+        Button.inline("Sᴇᴛᴛɪɴɢs ⚙️", data="setter"),
+    ],
+    [
+        Button.inline("Sᴛᴀᴛs ✨", data="stat"),
+        Button.inline("Bʀᴏᴀᴅᴄᴀsᴛ 📻", data="bcast"),
+    ],
+    [Button.inline("TɪᴍᴇZᴏɴᴇ 🌎", data="tz")],
+]
+
+
+@callback("ownerinfo")
+async def own(event):
+    msg = Owner_info_msg.format(
+        mention=event.sender.mention, me=inline_mention(ultroid_bot.me)
+    )
+    if custom_info:
+        msg += "\n\n• Powered by **@TeamUltroid**"
+    await event.edit(
+        msg,
+        buttons=[Button.inline("Close", data="closeit")],
+        link_preview=False,
+    )
+
+
+@callback("closeit")
+async def closet(lol):
+    try:
+        await lol.delete()
+    except MessageDeleteForbiddenError:
+        await lol.answer("MESSAGE_TOO_OLD", alert=True)
+
+
+@asst_cmd(pattern="start( (.*)|$)", forwards=False, func=lambda x: not x.is_group)
+async def ultroid(event):
+    args = event.pattern_match.group(1).strip()
+    keym = KeyManager("BOT_USERS", cast=list)
+    if not keym.contains(event.sender_id) and event.sender_id not in owner_and_sudos():
+        keym.add(event.sender_id)
+        kak_uiw = udB.get_key("OFF_START_LOG")
+        if not kak_uiw or kak_uiw != True:
+            msg = f"{inline_mention(event.sender)} `[{event.sender_id}]` started your [Assistant bot](@{asst.me.username})."
+            buttons = [[Button.inline("Info", "itkkstyo")]]
+            if event.sender.username:
+                buttons[0].append(
+                    Button.mention(
+                        "User", await event.client.get_input_entity(event.sender_id)
+                    )
+                )
+            await event.client.send_message(
+                udB.get_key("LOG_CHANNEL"), msg, buttons=buttons
+            )
+    if event.sender_id not in SUDO_M.fullsudos:
+        ok = ""
+        me = inline_mention(ultroid_bot.me)
+        mention = inline_mention(event.sender)
+        if args and args != "set":
+            await get_stored_file(event, args)
+        if not udB.get_key("STARTMSG"):
+            if udB.get_key("PMBOT"):
+                ok = "You can contact my master using this bot!!\n\nSend your Message, I will Deliver it To Master."
+            await event.reply(
+                f"Hey there {mention}, this is Ultroid Assistant of {me}!\n\n{ok}",
+                file=udB.get_key("STARTMEDIA"),
+                buttons=[Button.inline("Info.", data="ownerinfo")]
+                if Owner_info_msg
+                else None,
+            )
+        else:
+            await event.reply(
+                udB.get_key("STARTMSG").format(me=me, mention=mention),
+                file=udB.get_key("STARTMEDIA"),
+                buttons=[Button.inline("Info.", data="ownerinfo")]
+                if Owner_info_msg
+                else None,
+            )
+    else:
+        name = get_display_name(event.sender)
+        if args == "set":
+            await event.reply(
+                "Choose from the below options -",
+                buttons=_settings,
+            )
+        elif args:
+            await get_stored_file(event, args)
+        else:
+            await event.reply(
+                get_string("ast_3").format(name),
+                buttons=_start,
+            )
+
+
+@callback("itkkstyo", owner=True)
+async def ekekdhdb(e):
+    text = f"When New Visitor will visit your Assistant Bot. You will get this log message!\n\nTo Disable : {HNDLR}setdb OFF_START_LOG True"
+    await e.answer(text, alert=True)
+
+
+@callback("mainmenu", owner=True, func=lambda x: not x.is_group)
+async def ultroid(event):
+    await event.edit(
+        get_string("ast_3").format(OWNER_NAME),
+        buttons=_start,
+    )
+
+
+@callback("stat", owner=True)
+async def botstat(event):
+    ok = len(udB.get_key("BOT_USERS") or [])
+    msg = """Ultroid Assistant - Stats
+Total Users - {}""".format(
+        ok,
+    )
+    await event.answer(msg, cache_time=0, alert=True)
+
+
+@callback("bcast", owner=True)
+async def bdcast(event):
+    keym = KeyManager("BOT_USERS", cast=list)
+    total = keym.count()
+    await event.edit(f"• Broadcast to {total} users.")
+    async with event.client.conversation(OWNER_ID) as conv:
+        await conv.send_message(
+            "Enter your broadcast message.\nUse /cancel to stop the broadcast.",
+        )
+        response = await conv.get_response()
+        if response.message == "/cancel":
+            return await conv.send_message("Cancelled!!")
+        success = 0
+        fail = 0
+        await conv.send_message(f"Starting a broadcast to {total} users...")
+        start = datetime.now()
+        for i in keym.get():
+            try:
+                await asst.send_message(int(i), response)
+                success += 1
+            except BaseException:
+                fail += 1
+        end = datetime.now()
+        time_taken = (end - start).seconds
+        await conv.send_message(
+            f"""
+**Broadcast completed in {time_taken} seconds.**
+Total Users in Bot - {total}
+**Sent to** : `{success} users.`
+**Failed for** : `{fail} user(s).`""",
+        )
+
+
+@callback("setter", owner=True)
+async def setting(event):
+    await event.edit(
+        "Choose from the below options -",
+        buttons=_settings,
+    )
+
+
+@callback("tz", owner=True)
+async def timezone_(event):
+    await event.delete()
+    pru = event.sender_id
+    var = "TIMEZONE"
+    name = "Timezone"
+    async with event.client.conversation(pru) as conv:
+        await conv.send_message(
+            "Send Your TimeZone From This List [Check From Here](http://www.timezoneconverter.com/cgi-bin/findzone.tzc)"
+        )
+        response = conv.wait_event(events.NewMessage(chats=pru))
+        response = await response
+        themssg = response.message.message
+        if themssg == "/cancel":
+            return await conv.send_message(
+                "Cancelled!!",
+                buttons=get_back_button("mainmenu"),
+            )
+        try:
+            tz(themssg)
+            await setit(event, var, themssg)
+            await conv.send_message(
+                f"{name} changed to {themssg}\n",
+                buttons=get_back_button("mainmenu"),
+            )
+        except BaseException:
+            await conv.send_message(
+                "Wrong TimeZone, Try again",
+                buttons=get_back_button("mainmenu"),
+            )

assistant/ytdl.py

@@ -0,0 +1,307 @@
+# Ultroid - UserBot
+# Copyright (C) 2021-2025 TeamUltroid
+#
+# This file is a part of < https://github.com/TeamUltroid/Ultroid/ >
+# PLease read the GNU Affero General Public License in
+# <https://www.github.com/TeamUltroid/Ultroid/blob/main/LICENSE/>.
+
+
+import os
+import re
+
+try:
+    from PIL import Image
+except ImportError:
+    Image = None
+from telethon import Button
+from telethon.errors.rpcerrorlist import FilePartLengthInvalidError, MediaEmptyError
+from telethon.tl.types import DocumentAttributeAudio, DocumentAttributeVideo
+from telethon.tl.types import InputWebDocument as wb
+
+from pyUltroid.fns.helper import (
+    bash,
+    fast_download,
+    humanbytes,
+    numerize,
+    time_formatter,
+)
+from pyUltroid.fns.ytdl import dler, get_buttons, get_formats
+
+from . import LOGS, asst, callback, in_pattern, udB
+
+try:
+    from youtubesearchpython import VideosSearch
+except ImportError:
+    LOGS.info("'youtubesearchpython' not installed!")
+    VideosSearch = None
+
+
+ytt = "https://graph.org/file/afd04510c13914a06dd03.jpg"
+_yt_base_url = "https://www.youtube.com/watch?v="
+BACK_BUTTON = {}
+
+
+@in_pattern("yt", owner=True)
+async def _(event):
+    try:
+        string = event.text.split(" ", maxsplit=1)[1]
+    except IndexError:
+        fuk = event.builder.article(
+            title="Search Something",
+            thumb=wb(ytt, 0, "image/jpeg", []),
+            text="**YᴏᴜTᴜʙᴇ Sᴇᴀʀᴄʜ**\n\nYou didn't search anything",
+            buttons=Button.switch_inline(
+                "Sᴇᴀʀᴄʜ Aɢᴀɪɴ",
+                query="yt ",
+                same_peer=True,
+            ),
+        )
+        await event.answer([fuk])
+        return
+    results = []
+    search = VideosSearch(string, limit=50)
+    nub = search.result()
+    nibba = nub["result"]
+    for v in nibba:
+        ids = v["id"]
+        link = _yt_base_url + ids
+        title = v["title"]
+        duration = v["duration"]
+        views = v["viewCount"]["short"]
+        publisher = v["channel"]["name"]
+        published_on = v["publishedTime"]
+        description = (
+            v["descriptionSnippet"][0]["text"]
+            if v.get("descriptionSnippet")
+            and len(v["descriptionSnippet"][0]["text"]) < 500
+            else "None"
+        )
+        thumb = f"https://i.ytimg.com/vi/{ids}/hqdefault.jpg"
+        text = f"**Title: [{title}]({link})**\n\n"
+        text += f"`Description: {description}\n\n"
+        text += f"「 Duration: {duration} 」\n"
+        text += f"「 Views: {views} 」\n"
+        text += f"「 Publisher: {publisher} 」\n"
+        text += f"「 Published on: {published_on} 」`"
+        desc = f"{title}\n{duration}"
+        file = wb(thumb, 0, "image/jpeg", [])
+        buttons = [
+            [
+                Button.inline("Audio", data=f"ytdl:audio:{ids}"),
+                Button.inline("Video", data=f"ytdl:video:{ids}"),
+            ],
+            [
+                Button.switch_inline(
+                    "Sᴇᴀʀᴄʜ Aɢᴀɪɴ",
+                    query="yt ",
+                    same_peer=True,
+                ),
+                Button.switch_inline(
+                    "Sʜᴀʀᴇ",
+                    query=f"yt {string}",
+                    same_peer=False,
+                ),
+            ],
+        ]
+        BACK_BUTTON.update({ids: {"text": text, "buttons": buttons}})
+        results.append(
+            await event.builder.article(
+                type="photo",
+                title=title,
+                description=desc,
+                thumb=file,
+                content=file,
+                text=text,
+                include_media=True,
+                buttons=buttons,
+            ),
+        )
+    await event.answer(results[:50])
+
+
+@callback(
+    re.compile(
+        "ytdl:(.*)",
+    ),
+    owner=True,
+)
+async def _(e):
+    _e = e.pattern_match.group(1).strip().decode("UTF-8")
+    _lets_split = _e.split(":")
+    _ytdl_data = await dler(e, _yt_base_url + _lets_split[1])
+    _data = get_formats(_lets_split[0], _lets_split[1], _ytdl_data)
+    _buttons = get_buttons(_data)
+    _text = (
+        "`Select Your Format.`"
+        if _buttons
+        else "`Error downloading from YouTube.\nTry Restarting your bot.`"
+    )
+
+    await e.edit(_text, buttons=_buttons)
+
+
+@callback(
+    re.compile(
+        "ytdownload:(.*)",
+    ),
+    owner=True,
+)
+async def _(event):
+    url = event.pattern_match.group(1).strip().decode("UTF-8")
+    lets_split = url.split(":")
+    vid_id = lets_split[2]
+    link = _yt_base_url + vid_id
+    format = lets_split[1]
+    try:
+        ext = lets_split[3]
+    except IndexError:
+        ext = "mp3"
+    if lets_split[0] == "audio":
+        opts = {
+            "format": "bestaudio",
+            "addmetadata": True,
+            "key": "FFmpegMetadata",
+            "prefer_ffmpeg": True,
+            "geo_bypass": True,
+            "outtmpl": f"%(id)s.{ext}",
+            "logtostderr": False,
+            "postprocessors": [
+                {
+                    "key": "FFmpegExtractAudio",
+                    "preferredcodec": ext,
+                    "preferredquality": format,
+                },
+                {"key": "FFmpegMetadata"},
+            ],
+        }
+
+        ytdl_data = await dler(event, link, opts, True)
+        title = ytdl_data["title"]
+        if ytdl_data.get("artist"):
+            artist = ytdl_data["artist"]
+        elif ytdl_data.get("creator"):
+            artist = ytdl_data["creator"]
+        elif ytdl_data.get("channel"):
+            artist = ytdl_data["channel"]
+        views = numerize(ytdl_data.get("view_count")) or 0
+        thumb, _ = await fast_download(ytdl_data["thumbnail"], filename=f"{vid_id}.jpg")
+
+        likes = numerize(ytdl_data.get("like_count")) or 0
+        duration = ytdl_data.get("duration") or 0
+        description = (
+            ytdl_data["description"]
+            if len(ytdl_data["description"]) < 100
+            else ytdl_data["description"][:100]
+        )
+        description = description or "None"
+        filepath = f"{vid_id}.{ext}"
+        if not os.path.exists(filepath):
+            filepath = f"{filepath}.{ext}"
+        size = os.path.getsize(filepath)
+        file, _ = await event.client.fast_uploader(
+            filepath,
+            filename=f"{title}.{ext}",
+            show_progress=True,
+            event=event,
+            to_delete=True,
+        )
+
+        attributes = [
+            DocumentAttributeAudio(
+                duration=int(duration),
+                title=title,
+                performer=artist,
+            ),
+        ]
+    elif lets_split[0] == "video":
+        opts = {
+            "format": str(format),
+            "addmetadata": True,
+            "key": "FFmpegMetadata",
+            "prefer_ffmpeg": True,
+            "geo_bypass": True,
+            "outtmpl": f"%(id)s.{ext}",
+            "logtostderr": False,
+            "postprocessors": [{"key": "FFmpegMetadata"}],
+        }
+
+        ytdl_data = await dler(event, link, opts, True)
+        title = ytdl_data["title"]
+        if ytdl_data.get("artist"):
+            artist = ytdl_data["artist"]
+        elif ytdl_data.get("creator"):
+            artist = ytdl_data["creator"]
+        elif ytdl_data.get("channel"):
+            artist = ytdl_data["channel"]
+        views = numerize(ytdl_data.get("view_count")) or 0
+        thumb, _ = await fast_download(ytdl_data["thumbnail"], filename=f"{vid_id}.jpg")
+
+        try:
+            Image.open(thumb).save(thumb, "JPEG")
+        except Exception as er:
+            LOGS.exception(er)
+            thumb = None
+        description = (
+            ytdl_data["description"]
+            if len(ytdl_data["description"]) < 100
+            else ytdl_data["description"][:100]
+        )
+        likes = numerize(ytdl_data.get("like_count")) or 0
+        hi, wi = ytdl_data.get("height") or 720, ytdl_data.get("width") or 1280
+        duration = ytdl_data.get("duration") or 0
+        filepath = f"{vid_id}.mkv"
+        if not os.path.exists(filepath):
+            filepath = f"{filepath}.webm"
+        size = os.path.getsize(filepath)
+        file, _ = await event.client.fast_uploader(
+            filepath,
+            filename=f"{title}.mkv",
+            show_progress=True,
+            event=event,
+            to_delete=True,
+        )
+
+        attributes = [
+            DocumentAttributeVideo(
+                duration=int(duration),
+                w=wi,
+                h=hi,
+                supports_streaming=True,
+            ),
+        ]
+    description = description if description != "" else "None"
+    text = f"**Title: [{title}]({_yt_base_url}{vid_id})**\n\n"
+    text += f"`📝 Description: {description}\n\n"
+    text += f"「 Duration: {time_formatter(int(duration)*1000)} 」\n"
+    text += f"「 Artist: {artist} 」\n"
+    text += f"「 Views: {views} 」\n"
+    text += f"「 Likes: {likes} 」\n"
+    text += f"「 Size: {humanbytes(size)} 」`"
+    button = Button.switch_inline("Search More", query="yt ", same_peer=True)
+    try:
+        await event.edit(
+            text,
+            file=file,
+            buttons=button,
+            attributes=attributes,
+            thumb=thumb,
+        )
+    except (FilePartLengthInvalidError, MediaEmptyError):
+        file = await asst.send_message(
+            udB.get_key("LOG_CHANNEL"),
+            text,
+            file=file,
+            buttons=button,
+            attributes=attributes,
+            thumb=thumb,
+        )
+        await event.edit(text, file=file.media, buttons=button)
+    await bash(f"rm {vid_id}.jpg")
+
+
+@callback(re.compile("ytdl_back:(.*)"), owner=True)
+async def ytdl_back(event):
+    id_ = event.data_match.group(1).decode("utf-8")
+    if not BACK_BUTTON.get(id_):
+        return await event.answer("Query Expired! Search again 🔍")
+    await event.edit(**BACK_BUTTON[id_])

docker-compose.yml

@@ -0,0 +1,14 @@
+services:
+  worker:
+    build: .
+    environment:
+      REDIS_URI: $REDIS_URI
+      REDIS_PASSWORD: $REDIS_PASSWORD
+      SESSION: $SESSION
+      API_ID: $API_ID  # defaults to None
+      API_HASH: $API_HASH  # defaults to None
+      MONGO_URI: $MONGO_URI  # defaults to None
+      BOT_TOKEN: $BOT_TOKEN # Not mandatory
+      LOG_CHANNEL: $LOG_CHANNEL # Not mandatory
+      DATABASE_URL: $DATABASE_URL  # defaults to None
+      OKTETO_TOKEN: $OKTETO_TOKEN

heroku.yml

@@ -0,0 +1,3 @@
+build:
+  docker:
+      ultroid: Dockerfile

install-termux

@@ -0,0 +1,16 @@
+#!/usr/bin/env bash
+# Ultroid - UserBot
+# Copyright (C) 2021-2025 TeamUltroid
+#
+# This file is a part of < https://github.com/TeamUltroid/Ultroid/ >
+# PLease read the GNU Affero General Public License in <https://www.github.com/TeamUltroid/Ultroid/blob/main/LICENSE/>.
+
+if [ -d "resources" ]
+then
+    echo "Current directory Identified.."
+else
+    apt install git -y
+    git clone https://github.com/TeamUltroid/Ultroid
+    cd Ultroid
+fi
+bash resources/startup/termux.sh

installer.sh

@@ -0,0 +1,241 @@
+#!/usr/bin/env bash
+
+REPO="https://github.com/TeamUltroid/Ultroid.git"
+CURRENT_DIR="$(pwd)"
+ENV_FILE_PATH=".env"
+DIR="/root/TeamUltroid"
+
+while [ $# -gt 0 ]; do
+    case "$1" in
+    --dir=*)
+        DIR="${1#*=}" || DIR="/root/TeamUltroid"
+        ;;
+    --branch=*)
+        BRANCH="${1#*=}" || BRANCH="main"
+        ;;
+    --env-file=*)
+        ENV_FILE_PATH="${1#*=}" || ENV_FILE_PATH=".env"
+        ;;
+    --no-root)
+        NO_ROOT=true
+        ;;
+    *)
+        echo "Unknown parameter passed: $1"
+        exit 1
+        ;;
+    esac
+    shift
+done
+
+check_dependencies() {
+    # check if debian
+    echo "Checking dependencies..."
+    # read file with root access
+    if ! [[ $(ls -l "/etc/sudoers" | cut -d " " -f1) =~ "r" ]]; then
+        # check dependencies if installed
+        echo -e "Root access not found. Checking if dependencies are installed." >&2
+        if ! [ -x "$(command -v python3)" ] || ! [ -x "$(command -v python)" ]; then
+            echo -e "Python3 isn't installed. Please install python3.8 or higher to run this bot." >&2
+            exit 1
+        fi
+        if [ $(python3 -c "import sys; print(sys.version_info[1])") -lt 8 ] || [ $(python -c "import sys; print(sys.version_info[1])") -lt 8 ]; then
+            echo -e "Python 3.8 or higher is required to run this bot." >&2
+            exit 1
+        fi
+        # check if any of ffmpeg, mediainfo, neofetch, git is not installed
+        if ! command -v ffmpeg &>/dev/null || ! command -v mediainfo &>/dev/null || ! command -v neofetch &>/dev/null || ! command -v git &>/dev/null; then
+            echo -e "Some dependencies aren't installed. Please install ffmpeg, mediainfo, neofetch and git to run this bot." >&2
+            exit 1
+        fi
+    fi
+    if [ -x "$(command -v apt-get)" ]; then
+        echo -e "Installing dependencies..."
+        # check if any of ffmpeg, mediainfo, neofetch, git is not installed via dpkg
+        if dpkg -l | grep -q ffmpeg || dpkg -l | grep -q mediainfo || dpkg -l | grep -q neofetch || dpkg -l | grep -q git; then
+            sudo apt-get -qq -o=Dpkg::Use-Pty=0 update
+            sudo apt-get install -qq -o=Dpkg::Use-Pty=0 python3 python3-pip ffmpeg mediainfo neofetch git -y
+        fi
+    elif [ -x "$(command -v pacman)" ]; then
+        echo -e "Installing dependencies..."
+        if pacman -Q | grep -q ffmpeg || pacman -Q | grep -q mediainfo || pacman -Q | grep -q neofetch || pacman -Q | grep -q git; then
+            sudo pacman -Sy python python-pip git ffmpeg mediainfo neofetch --noconfirm
+        fi
+    else
+        echo -e "Unknown OS. Checking if dependecies are installed" >&2
+        if ! [ -x "$(command -v python3)" ] || ! [ -x "$(command -v python)" ]; then
+            echo -e "Python3 isn't installed. Please install python3.8 or higher to run this bot." >&2
+            exit 1
+        fi
+        if [ $(python3 -c "import sys; print(sys.version_info[1])") -lt 8 ] || [ $(python -c "import sys; print(sys.version_info[1])") -lt 8 ]; then
+            echo -e "Python 3.8 or higher is required to run this bot." >&2
+            exit 1
+        fi
+        if ! command -v ffmpeg &>/dev/null || ! command -v mediainfo &>/dev/null || ! command -v neofetch &>/dev/null || ! command -v git &>/dev/null; then
+            echo -e "Some dependencies aren't installed. Please install ffmpeg, mediainfo, neofetch and git to run this bot." >&2
+            exit 1
+        fi
+    fi
+}
+
+check_python() {
+    # check if python is installed
+    if ! command -v python3 &>/dev/null; then
+        echo -e "Python3 isn't installed. Please install python3.8 or higher to run this bot."
+        exit 1
+    elif ! command -v python &>/dev/null; then
+        echo -e "Python3 isn't installed. Please install python3.8 or higher to run this bot."
+        exit 1
+    fi
+    if [ $(python3 -c "import sys; print(sys.version_info[1])") -lt 8 ]; then
+        echo -e "Python 3.8 or higher is required to run this bot."
+        exit 1
+    elif [ $(python -c "import sys; print(sys.version_info[1])") -lt 3 ]; then
+        if [ $(python -c "import sys; print(sys.version_info[1])") -lt 8 ]; then
+            echo -e "Python 3.8 or higher is required to run this bot."
+            exit 1
+        fi
+    fi
+}
+
+clone_repo() {
+    # check if pyultroid, startup, plugins folders exist
+    cd $DIR
+    if [ -d $DIR ]; then
+        if [ -d $DIR/.git ]; then
+            echo -e "Updating Ultroid ${BRANCH}... "
+            cd $DIR
+            git pull
+            currentbranch="$(git rev-parse --abbrev-ref HEAD)"
+            if [ ! $BRANCH ]; then
+                export BRANCH=$currentbranch
+            fi
+            case $currentbranch in
+            $BRANCH)
+                # do nothing
+                ;;
+            *)
+                echo -e "Switching to branch ${BRANCH}... "
+                echo -e $currentbranch
+                git checkout $BRANCH
+                ;;
+            esac
+        else
+            rm -rf $DIR
+            exit 1
+        fi
+        if [ -d "addons" ]; then
+            cd addons
+            git pull
+        fi
+        return
+    else
+        if [ ! $BRANCH ]; then
+            export BRANCH="main"
+        fi
+        mkdir -p $DIR
+        echo -e "Cloning Ultroid ${BRANCH}... "
+        git clone -b $BRANCH $REPO $DIR
+    fi
+}
+
+install_requirements() {
+    pip3 install -q --upgrade pip
+    echo -e "\n\nInstalling requirements... "
+    pip3 install -q --no-cache-dir -r $DIR/requirements.txt
+    pip3 install -q -r $DIR/resources/startup/optional-requirements.txt
+}
+
+railways_dep() {
+    if [ $RAILWAY_STATIC_URL ]; then
+        echo -e "Installing YouTube dependency... "
+        pip3 install -q yt-dlp
+    fi
+}
+
+misc_install() {
+    if [ $SETUP_PLAYWRIGHT ]
+    then
+        echo -e "Installing playwright."
+        pip3 install playwright
+        playwright install
+    fi
+    if [ $OKTETO_TOKEN ]; then
+        echo -e "Installing Okteto-CLI... "
+        curl https://get.okteto.com -sSfL | sh
+    elif [ $VCBOT ]; then
+        if [ -d $DIR/vcbot ]; then
+            cd $DIR/vcbot
+            git pull
+        else
+            echo -e "Cloning VCBOT.."
+            git clone https://github.com/TeamUltroid/VcBot $DIR/vcbot
+        fi
+        pip3 install pytgcalls==3.0.0.dev23 && pip3 install av -q --no-binary av
+    fi
+}
+
+dep_install() {
+    echo -e "\n\nInstalling DB Requirement..."
+    if [ $MONGO_URI ]; then
+        echo -e "   Installing MongoDB Requirements..."
+        pip3 install -q pymongo[srv]
+    elif [ $DATABASE_URL ]; then
+        echo -e "   Installing PostgreSQL Requirements..."
+        pip3 install -q psycopg2-binary
+    elif [ $REDIS_URI ]; then
+        echo -e "   Installing Redis Requirements..."
+        pip3 install -q redis hiredis
+    fi
+}
+
+main() {
+    echo -e "Starting Ultroid Setup..."
+    if [ -d "pyUltroid" ] && [ -d "resources" ] && [ -d "plugins" ]; then
+        DIR=$CURRENT_DIR
+    fi
+    if [ -f $ENV_FILE_PATH ]
+    then
+        set -a
+        source <(cat $ENV_FILE_PATH | sed -e '/^#/d;/^\s*$/d' -e "s/'/'\\\''/g" -e "s/=\(.*\)/='\1'/g")
+        set +a
+        cp $ENV_FILE_PATH .env
+    fi
+    (check_dependencies)
+    (check_python)
+    (clone_repo)
+    (install_requirements)
+    (railways_dep)
+    (dep_install)
+    (misc_install)
+    echo -e "\n\nSetup Completed."
+}
+
+if [ $NO_ROOT ]; then
+    echo -e "Running with non root"
+    main
+    return 0
+elif [ -t 0 ]; then
+    unameOut="$(uname -s)"
+    case "${unameOut}" in
+        Linux*)     machine=Linux;;
+        Darwin*)    machine=Mac;;
+        CYGWIN*)    machine=Cygwin;;
+        MINGW*)     machine=MinGw;;
+        *)          machine="UNKNOWN:${unameOut}"
+    esac
+    if machine != "Linux"; then
+        echo -e "This script is only for Linux. Please use the Windows installer."
+        exit 1
+    fi
+    # check if sudo is installed
+    if ! command -v sudo &>/dev/null; then
+        echo -e "Sudo isn't installed. Please install sudo to run this bot."
+        exit 1
+    fi
+    sudo echo "Sudo permission granted."
+    main
+else
+    echo "Not an interactive terminal, skipping sudo."
+    # run main function
+    main
+fi

multi_client.py

@@ -0,0 +1,39 @@
+import asyncio
+import os
+import subprocess
+import sys
+
+vars = ["API_ID", "API_HASH", "SESSION"]
+
+def _check(z):
+    new = []
+    for var in vars:
+        ent = os.environ.get(var + z)
+        if not ent:
+            return False, new
+        new.append(ent)
+    return True, new
+
+for z in range(5):
+    n = str(z + 1)
+    if z == 0:
+        z = ""
+    fine, out = _check(str(z))
+    if fine:
+        subprocess.Popen(
+            [sys.executable, "-m", "pyUltroid", out[0], out[1], out[2], out[3], out[4], n],
+            stdin=None,
+            stderr=None,
+            stdout=None,
+            cwd=None,
+        )
+
+loop = asyncio.get_event_loop()
+
+try:
+    loop.run_forever()
+except Exception as er:
+    print(er)
+finally:
+    loop.close()
+

okteto-pipeline.yml

@@ -0,0 +1,3 @@
+icon: https://raw.githubusercontent.com/TeamUltroid/Ultroid/main/resources/extras/logo_readme.jpg
+deploy:
+    - okteto deploy --build -f docker-compose.yml

plugins/__init__.py

@@ -0,0 +1,105 @@
+# Ultroid - UserBot
+# Copyright (C) 2021-2025 TeamUltroid
+#
+# This file is a part of < https://github.com/TeamUltroid/Ultroid/ >
+# PLease read the GNU Affero General Public License in
+# <https://www.github.com/TeamUltroid/Ultroid/blob/main/LICENSE/>.
+
+import asyncio
+import os
+import time
+from random import choice
+
+import requests
+from telethon import Button, events
+from telethon.tl import functions, types  # pylint:ignore
+
+from pyUltroid import *
+from pyUltroid._misc._assistant import asst_cmd, callback, in_pattern
+from pyUltroid._misc._decorators import ultroid_cmd
+from pyUltroid._misc._wrappers import eod, eor
+from pyUltroid.dB import DEVLIST, ULTROID_IMAGES
+from pyUltroid.fns.helper import *
+from pyUltroid.fns.misc import *
+from pyUltroid.fns.tools import *
+from pyUltroid.startup._database import _BaseDatabase as Database
+from pyUltroid.version import __version__, ultroid_version
+from strings import get_help, get_string
+from catbox import CatboxUploader
+
+udB: Database
+
+Redis = udB.get_key
+con = TgConverter
+quotly = Quotly()
+OWNER_NAME = ultroid_bot.full_name
+OWNER_ID = ultroid_bot.uid
+
+ultroid_bot: UltroidClient
+asst: UltroidClient
+
+LOG_CHANNEL = udB.get_key("LOG_CHANNEL")
+
+
+def inline_pic():
+    INLINE_PIC = udB.get_key("INLINE_PIC")
+    if INLINE_PIC is None:
+        INLINE_PIC = choice(ULTROID_IMAGES)
+    elif INLINE_PIC == False:
+        INLINE_PIC = None
+    return INLINE_PIC
+
+
+Telegraph = telegraph_client()
+cat_uploader = CatboxUploader()
+
+upload_file = cat_uploader.upload_file
+
+List = []
+Dict = {}
+InlinePlugin = {}
+N = 0
+cmd = ultroid_cmd
+STUFF = {}
+
+# Chats, which needs to be ignore for some cases
+# Considerably, there can be many
+# Feel Free to Add Any other...
+
+NOSPAM_CHAT = [
+    -1001361294038,  # UltroidSupportChat
+    -1001387666944,  # PyrogramChat
+    -1001109500936,  # TelethonChat
+    -1001050982793,  # Python
+    -1001256902287,  # DurovsChat
+    -1001473548283,  # SharingUserbot
+]
+
+KANGING_STR = [
+    "Using Witchery to kang this sticker...",
+    "Plagiarising hehe...",
+    "Inviting this sticker over to my pack...",
+    "Kanging this sticker...",
+    "Hey that's a nice sticker!\nMind if I kang?!..",
+    "Hehe me stel ur stiker...",
+    "Ay look over there (☉｡☉)!→\nWhile I kang this...",
+    "Roses are red violets are blue, kanging this sticker so my pack looks cool",
+    "Imprisoning this sticker...",
+    "Mr.Steal-Your-Sticker is stealing this sticker... ",
+]
+
+
+ATRA_COL = [
+    "DarkCyan",
+    "DeepSkyBlue",
+    "DarkTurquoise",
+    "Cyan",
+    "LightSkyBlue",
+    "Turquoise",
+    "MediumVioletRed",
+    "Aquamarine",
+    "Lightcyan",
+    "Azure",
+    "Moccasin",
+    "PowderBlue",
+]

plugins/_chatactions.py

@@ -0,0 +1,253 @@
+# Ultroid - UserBot
+# Copyright (C) 2021-2025 TeamUltroid
+#
+# This file is a part of < https://github.com/TeamUltroid/Ultroid/ >
+# PLease read the GNU Affero General Public License in
+# <https://www.github.com/TeamUltroid/Ultroid/blob/main/LICENSE/>.
+
+import asyncio
+
+from telethon import events
+from telethon.errors.rpcerrorlist import UserNotParticipantError
+from telethon.tl.functions.channels import GetParticipantRequest
+from telethon.utils import get_display_name
+
+from pyUltroid.dB import stickers
+from pyUltroid.dB.echo_db import check_echo
+from pyUltroid.dB.forcesub_db import get_forcesetting
+from pyUltroid.dB.gban_mute_db import is_gbanned
+from pyUltroid.dB.greetings_db import get_goodbye, get_welcome, must_thank
+from pyUltroid.dB.nsfw_db import is_profan
+from pyUltroid.fns.helper import inline_mention
+from pyUltroid.fns.tools import async_searcher, create_tl_btn, get_chatbot_reply
+
+try:
+    from ProfanityDetector import detector
+except ImportError:
+    detector = None
+from . import LOG_CHANNEL, LOGS, asst, get_string, types, udB, ultroid_bot
+from ._inline import something
+
+
+@ultroid_bot.on(events.ChatAction())
+async def Function(event):
+    try:
+        await DummyHandler(event)
+    except Exception as er:
+        LOGS.exception(er)
+
+
+async def DummyHandler(ult):
+    # clean chat actions
+    key = udB.get_key("CLEANCHAT") or []
+    if ult.chat_id in key:
+        try:
+            await ult.delete()
+        except BaseException:
+            pass
+
+    # thank members
+    if must_thank(ult.chat_id):
+        chat_count = (await ult.client.get_participants(ult.chat_id, limit=0)).total
+        if chat_count % 100 == 0:
+            stik_id = chat_count / 100 - 1
+            sticker = stickers[stik_id]
+            await ult.respond(file=sticker)
+    # force subscribe
+    if (
+        udB.get_key("FORCESUB")
+        and ((ult.user_joined or ult.user_added))
+        and get_forcesetting(ult.chat_id)
+    ):
+        user = await ult.get_user()
+        if not user.bot:
+            joinchat = get_forcesetting(ult.chat_id)
+            try:
+                await ultroid_bot(GetParticipantRequest(int(joinchat), user.id))
+            except UserNotParticipantError:
+                await ultroid_bot.edit_permissions(
+                    ult.chat_id, user.id, send_messages=False
+                )
+                res = await ultroid_bot.inline_query(
+                    asst.me.username, f"fsub {user.id}_{joinchat}"
+                )
+                await res[0].click(ult.chat_id, reply_to=ult.action_message.id)
+
+    if ult.user_joined or ult.added_by:
+        user = await ult.get_user()
+        chat = await ult.get_chat()
+        # gbans and @UltroidBans checks
+        if udB.get_key("ULTROID_BANS"):
+            try:
+                is_banned = await async_searcher(
+                    "https://bans.ultroid.tech/api/status",
+                    json={"userId": user.id},
+                    post=True,
+                    re_json=True,
+                )
+                if is_banned["is_banned"]:
+                    await ult.client.edit_permissions(
+                        chat.id,
+                        user.id,
+                        view_messages=False,
+                    )
+                    await ult.respond(
+                        f'**@UltroidBans:** Banned user detected and banned!\n`{str(is_banned)}`.\nBan reason: {is_banned["reason"]}',
+                    )
+
+            except BaseException:
+                pass
+        reason = is_gbanned(user.id)
+        if reason and chat.admin_rights:
+            try:
+                await ult.client.edit_permissions(
+                    chat.id,
+                    user.id,
+                    view_messages=False,
+                )
+                gban_watch = get_string("can_1").format(inline_mention(user), reason)
+                await ult.reply(gban_watch)
+            except Exception as er:
+                LOGS.exception(er)
+
+        # greetings
+        elif get_welcome(ult.chat_id):
+            user = await ult.get_user()
+            chat = await ult.get_chat()
+            title = chat.title or "this chat"
+            count = (
+                chat.participants_count
+                or (await ult.client.get_participants(chat, limit=0)).total
+            )
+            mention = inline_mention(user)
+            name = user.first_name
+            fullname = get_display_name(user)
+            uu = user.username
+            username = f"@{uu}" if uu else mention
+            wel = get_welcome(ult.chat_id)
+            msgg = wel["welcome"]
+            med = wel["media"] or None
+            userid = user.id
+            msg = None
+            if msgg:
+                msg = msgg.format(
+                    mention=mention,
+                    group=title,
+                    count=count,
+                    name=name,
+                    fullname=fullname,
+                    username=username,
+                    userid=userid,
+                )
+            if wel.get("button"):
+                btn = create_tl_btn(wel["button"])
+                await something(ult, msg, med, btn)
+            elif msg:
+                send = await ult.reply(
+                    msg,
+                    file=med,
+                )
+                await asyncio.sleep(150)
+                await send.delete()
+            else:
+                await ult.reply(file=med)
+    elif (ult.user_left or ult.user_kicked) and get_goodbye(ult.chat_id):
+        user = await ult.get_user()
+        chat = await ult.get_chat()
+        title = chat.title or "this chat"
+        count = (
+            chat.participants_count
+            or (await ult.client.get_participants(chat, limit=0)).total
+        )
+        mention = inline_mention(user)
+        name = user.first_name
+        fullname = get_display_name(user)
+        uu = user.username
+        username = f"@{uu}" if uu else mention
+        wel = get_goodbye(ult.chat_id)
+        msgg = wel["goodbye"]
+        med = wel["media"]
+        userid = user.id
+        msg = None
+        if msgg:
+            msg = msgg.format(
+                mention=mention,
+                group=title,
+                count=count,
+                name=name,
+                fullname=fullname,
+                username=username,
+                userid=userid,
+            )
+        if wel.get("button"):
+            btn = create_tl_btn(wel["button"])
+            await something(ult, msg, med, btn)
+        elif msg:
+            send = await ult.reply(
+                msg,
+                file=med,
+            )
+            await asyncio.sleep(150)
+            await send.delete()
+        else:
+            await ult.reply(file=med)
+
+
+@ultroid_bot.on(events.NewMessage(incoming=True))
+async def chatBot_replies(e):
+    sender = await e.get_sender()
+    if not isinstance(sender, types.User) or sender.bot:
+        return
+    if check_echo(e.chat_id, e.sender_id):
+        try:
+            await e.respond(e.message)
+        except Exception as er:
+            LOGS.exception(er)
+    key = udB.get_key("CHATBOT_USERS") or {}
+    if e.text and key.get(e.chat_id) and sender.id in key[e.chat_id]:
+        msg = await get_chatbot_reply(e.message.message)
+        if msg:
+            sleep = udB.get_key("CHATBOT_SLEEP") or 1.5
+            await asyncio.sleep(sleep)
+            await e.reply(msg)
+    chat = await e.get_chat()
+    if e.is_group and sender.username:
+        await uname_stuff(e.sender_id, sender.username, sender.first_name)
+    elif e.is_private and chat.username:
+        await uname_stuff(e.sender_id, chat.username, chat.first_name)
+    if detector and is_profan(e.chat_id) and e.text:
+        x, y = detector(e.text)
+        if y:
+            await e.delete()
+
+
+@ultroid_bot.on(events.Raw(types.UpdateUserName))
+async def uname_change(e):
+    await uname_stuff(e.user_id, e.usernames[0] if e.usernames else None, e.first_name)
+
+
+async def uname_stuff(id, uname, name):
+    if udB.get_key("USERNAME_LOG"):
+        old_ = udB.get_key("USERNAME_DB") or {}
+        old = old_.get(id)
+        # Ignore Name Logs
+        if old and old == uname:
+            return
+        if old and uname:
+            await asst.send_message(
+                LOG_CHANNEL,
+                get_string("can_2").format(old, uname),
+            )
+        elif old:
+            await asst.send_message(
+                LOG_CHANNEL,
+                get_string("can_3").format(f"[{name}](tg://user?id={id})", old),
+            )
+        elif uname:
+            await asst.send_message(
+                LOG_CHANNEL,
+                get_string("can_4").format(f"[{name}](tg://user?id={id})", uname),
+            )
+
+        old_[id] = uname
+        udB.set_key("USERNAME_DB", old_)

plugins/_help.py

@@ -0,0 +1,136 @@
+# Ultroid - UserBot
+# Copyright (C) 2021-2025 TeamUltroid
+#
+# This file is a part of < https://github.com/TeamUltroid/Ultroid/ >
+# PLease read the GNU Affero General Public License in
+# <https://www.github.com/TeamUltroid/Ultroid/blob/main/LICENSE/>.
+
+from telethon.errors.rpcerrorlist import (
+    BotInlineDisabledError,
+    BotMethodInvalidError,
+    BotResponseTimeoutError,
+)
+from telethon.tl.custom import Button
+
+from pyUltroid.dB._core import HELP, LIST
+from pyUltroid.fns.tools import cmd_regex_replace
+
+from . import HNDLR, LOGS, OWNER_NAME, asst, get_string, inline_pic, udB, ultroid_cmd
+
+_main_help_menu = [
+    [
+        Button.inline(get_string("help_4"), data="uh_Official_"),
+        Button.inline(get_string("help_5"), data="uh_Addons_"),
+    ],
+    [
+        Button.inline(get_string("help_6"), data="uh_VCBot_"),
+        Button.inline(get_string("help_7"), data="inlone"),
+    ],
+    [
+        Button.inline(get_string("help_8"), data="ownr"),
+        Button.url(
+            get_string("help_9"), url=f"https://t.me/{asst.me.username}?start=set"
+        ),
+    ],
+    [Button.inline(get_string("help_10"), data="close")],
+]
+
+
+@ultroid_cmd(pattern="help( (.*)|$)")
+async def _help(ult):
+    plug = ult.pattern_match.group(1).strip()
+    chat = await ult.get_chat()
+    if plug:
+        try:
+            if plug in HELP["Official"]:
+                output = f"**Plugin** - `{plug}`\n"
+                for i in HELP["Official"][plug]:
+                    output += i
+                output += "\n© @TeamUltroid"
+                await ult.eor(output)
+            elif HELP.get("Addons") and plug in HELP["Addons"]:
+                output = f"**Plugin** - `{plug}`\n"
+                for i in HELP["Addons"][plug]:
+                    output += i
+                output += "\n© @TeamUltroid"
+                await ult.eor(output)
+            elif HELP.get("VCBot") and plug in HELP["VCBot"]:
+                output = f"**Plugin** - `{plug}`\n"
+                for i in HELP["VCBot"][plug]:
+                    output += i
+                output += "\n© @TeamUltroid"
+                await ult.eor(output)
+            else:
+                try:
+                    x = get_string("help_11").format(plug)
+                    for d in LIST[plug]:
+                        x += HNDLR + d
+                        x += "\n"
+                    x += "\n© @TeamUltroid"
+                    await ult.eor(x)
+                except BaseException:
+                    file = None
+                    compare_strings = []
+                    for file_name in LIST:
+                        compare_strings.append(file_name)
+                        value = LIST[file_name]
+                        for j in value:
+                            j = cmd_regex_replace(j)
+                            compare_strings.append(j)
+                            if j.strip() == plug:
+                                file = file_name
+                                break
+                    if not file:
+                        # the enter command/plugin name is not found
+                        text = f"`{plug}` is not a valid plugin!"
+                        best_match = None
+                        for _ in compare_strings:
+                            if plug in _ and not _.startswith("_"):
+                                best_match = _
+                                break
+                        if best_match:
+                            text += f"\nDid you mean `{best_match}`?"
+                        return await ult.eor(text)
+                    output = f"**Command** `{plug}` **found in plugin** - `{file}`\n"
+                    if file in HELP["Official"]:
+                        for i in HELP["Official"][file]:
+                            output += i
+                    elif HELP.get("Addons") and file in HELP["Addons"]:
+                        for i in HELP["Addons"][file]:
+                            output += i
+                    elif HELP.get("VCBot") and file in HELP["VCBot"]:
+                        for i in HELP["VCBot"][file]:
+                            output += i
+                    output += "\n© @TeamUltroid"
+                    await ult.eor(output)
+        except BaseException as er:
+            LOGS.exception(er)
+            await ult.eor("Error 🤔 occured.")
+    else:
+        try:
+            results = await ult.client.inline_query(asst.me.username, "ultd")
+        except BotMethodInvalidError:
+            z = []
+            for x in LIST.values():
+                z.extend(x)
+            cmd = len(z) + 10
+            if udB.get_key("MANAGER") and udB.get_key("DUAL_HNDLR") == "/":
+                _main_help_menu[2:3] = [[Button.inline("• Manager Help •", "mngbtn")]]
+            return await ult.reply(
+                get_string("inline_4").format(
+                    OWNER_NAME,
+                    len(HELP["Official"]),
+                    len(HELP["Addons"] if "Addons" in HELP else []),
+                    cmd,
+                ),
+                file=inline_pic(),
+                buttons=_main_help_menu,
+            )
+        except BotResponseTimeoutError:
+            return await ult.eor(
+                get_string("help_2").format(HNDLR),
+            )
+        except BotInlineDisabledError:
+            return await ult.eor(get_string("help_3"))
+        await results[0].click(chat.id, reply_to=ult.reply_to_msg_id, hide_via=True)
+        await ult.delete()

plugins/_inline.py

@@ -0,0 +1,455 @@
+# Ultroid - UserBot
+# Copyright (C) 2021-2025 TeamUltroid
+#
+# This file is a part of < https://github.com/TeamUltroid/Ultroid/ >
+# PLease read the GNU Affero General Public License in
+# <https://www.github.com/TeamUltroid/Ultroid/blob/main/LICENSE/>.
+
+import re
+import time
+from datetime import datetime
+from os import remove
+
+from git import Repo
+from telethon import Button
+from telethon.tl.types import InputWebDocument, Message
+from telethon.utils import resolve_bot_file_id
+
+from pyUltroid._misc._assistant import callback, in_pattern
+from pyUltroid.dB._core import HELP, LIST
+from pyUltroid.fns.helper import gen_chlog, time_formatter, updater
+from pyUltroid.fns.misc import split_list
+
+from . import (
+    HNDLR,
+    LOGS,
+    OWNER_NAME,
+    InlinePlugin,
+    asst,
+    get_string,
+    inline_pic,
+    split_list,
+    start_time,
+    udB,
+)
+from ._help import _main_help_menu
+
+# ================================================#
+
+helps = get_string("inline_1")
+
+add_ons = udB.get_key("ADDONS")
+
+zhelps = get_string("inline_3") if add_ons is False else get_string("inline_2")
+PLUGINS = HELP.get("Official", [])
+ADDONS = HELP.get("Addons", [])
+upage = 0
+# ============================================#
+
+# --------------------BUTTONS--------------------#
+
+SUP_BUTTONS = [
+    [
+        Button.url("• Repo •", url="https://github.com/TeamUltroid/Ultroid"),
+        Button.url("• Support •", url="t.me/UltroidSupportChat"),
+    ],
+]
+
+# --------------------BUTTONS--------------------#
+
+
+@in_pattern(owner=True, func=lambda x: not x.text)
+async def inline_alive(o):
+    TLINK = inline_pic() or "https://graph.org/file/74d6259983e0642923fdb.jpg"
+    MSG = "• **Ultroid Userbot •**"
+    WEB0 = InputWebDocument(
+        "https://graph.org/file/acd4f5d61369f74c5e7a7.jpg", 0, "image/jpg", []
+    )
+    RES = [
+        await o.builder.article(
+            type="photo",
+            text=MSG,
+            include_media=True,
+            buttons=SUP_BUTTONS,
+            title="Ultroid Userbot",
+            description="Userbot | Telethon",
+            url=TLINK,
+            thumb=WEB0,
+            content=InputWebDocument(TLINK, 0, "image/jpg", []),
+        )
+    ]
+    await o.answer(
+        RES,
+        private=True,
+        cache_time=300,
+        switch_pm="👥 ULTROID PORTAL",
+        switch_pm_param="start",
+    )
+
+
+@in_pattern("ultd", owner=True)
+async def inline_handler(event):
+    z = []
+    for x in LIST.values():
+        z.extend(x)
+    text = get_string("inline_4").format(
+        OWNER_NAME,
+        len(HELP.get("Official", [])),
+        len(HELP.get("Addons", [])),
+        len(z),
+    )
+    if inline_pic():
+        result = await event.builder.photo(
+            file=inline_pic(),
+            link_preview=False,
+            text=text,
+            buttons=_main_help_menu,
+        )
+    else:
+        result = await event.builder.article(
+            title="Ultroid Help Menu", text=text, buttons=_main_help_menu
+        )
+    await event.answer([result], private=True, cache_time=300, gallery=True)
+
+
+@in_pattern("pasta", owner=True)
+async def _(event):
+    ok = event.text.split("-")[1]
+    if not ok.startswith("http"):
+        link = f"https://spaceb.in/{ok}"
+        raw = f"https://spaceb.in/api/v1/documents/{ok}/raw"
+    else:
+        link = ok
+        raw = f"{ok}/raw"
+    result = await event.builder.article(
+        title="Paste",
+        text="Pasted to Spacebin 🌌",
+        buttons=[
+            [
+                Button.url("SpaceBin", url=link),
+                Button.url("Raw", url=raw),
+            ],
+        ],
+    )
+    await event.answer([result])
+
+
+@callback("ownr", owner=True)
+async def setting(event):
+    z = []
+    for x in LIST.values():
+        z.extend(x)
+    await event.edit(
+        get_string("inline_4").format(
+            OWNER_NAME,
+            len(HELP.get("Official", [])),
+            len(HELP.get("Addons", [])),
+            len(z),
+        ),
+        file=inline_pic(),
+        link_preview=False,
+        buttons=[
+            [
+                Button.inline("•Pɪɴɢ•", data="pkng"),
+                Button.inline("•Uᴘᴛɪᴍᴇ•", data="upp"),
+            ],
+            [
+                Button.inline("•Stats•", data="alive"),
+                Button.inline("•Uᴘᴅᴀᴛᴇ•", data="doupdate"),
+            ],
+            [Button.inline("« Bᴀᴄᴋ", data="open")],
+        ],
+    )
+
+
+_strings = {"Official": helps, "Addons": zhelps, "VCBot": get_string("inline_6")}
+
+
+@callback(re.compile("uh_(.*)"), owner=True)
+async def help_func(ult):
+    key, count = ult.data_match.group(1).decode("utf-8").split("_")
+    if key == "VCBot" and HELP.get("VCBot") is None:
+        return await ult.answer(get_string("help_12"), alert=True)
+    elif key == "Addons" and HELP.get("Addons") is None:
+        return await ult.answer(get_string("help_13").format(HNDLR), alert=True)
+    if "|" in count:
+        _, count = count.split("|")
+    count = int(count) if count else 0
+    text = _strings.get(key, "").format(OWNER_NAME, len(HELP.get(key)))
+    await ult.edit(text, buttons=page_num(count, key), link_preview=False)
+
+
+@callback(re.compile("uplugin_(.*)"), owner=True)
+async def uptd_plugin(event):
+    key, file = event.data_match.group(1).decode("utf-8").split("_")
+    index = None
+    if "|" in file:
+        file, index = file.split("|")
+    key_ = HELP.get(key, [])
+    hel_p = f"Plugin Name - `{file}`\n"
+    help_ = ""
+    try:
+        for i in key_[file]:
+            help_ += i
+    except BaseException:
+        if file in LIST:
+            help_ = get_string("help_11").format(file)
+            for d in LIST[file]:
+                help_ += HNDLR + d
+                help_ += "\n"
+    if not help_:
+        help_ = f"{file} has no Detailed Help!"
+    help_ += "\n© @TeamUltroid"
+    buttons = []
+    if inline_pic():
+        data = f"sndplug_{key}_{file}"
+        if index is not None:
+            data += f"|{index}"
+        buttons.append(
+            [
+                Button.inline(
+                    "« Sᴇɴᴅ Pʟᴜɢɪɴ »",
+                    data=data,
+                )
+            ]
+        )
+    data = f"uh_{key}_"
+    if index is not None:
+        data += f"|{index}"
+    buttons.append(
+        [
+            Button.inline("« Bᴀᴄᴋ", data=data),
+        ]
+    )
+    try:
+        await event.edit(help_, buttons=buttons)
+    except Exception as er:
+        LOGS.exception(er)
+        help = f"Do `{HNDLR}help {key}` to get list of commands."
+        await event.edit(help, buttons=buttons)
+
+
+@callback(data="doupdate", owner=True)
+async def _(event):
+    if not await updater():
+        return await event.answer(get_string("inline_9"), cache_time=0, alert=True)
+    if not inline_pic():
+        return await event.answer(f"Do '{HNDLR}update' to update..")
+    repo = Repo.init()
+    changelog, tl_chnglog = await gen_chlog(
+        repo, f"HEAD..upstream/{repo.active_branch}"
+    )
+    changelog_str = changelog + "\n\n" + get_string("inline_8")
+    if len(changelog_str) > 1024:
+        await event.edit(get_string("upd_4"))
+        with open("ultroid_updates.txt", "w+") as file:
+            file.write(tl_chnglog)
+        await event.edit(
+            get_string("upd_5"),
+            file="ultroid_updates.txt",
+            buttons=[
+                [Button.inline("• Uᴘᴅᴀᴛᴇ Nᴏᴡ •", data="updatenow")],
+                [Button.inline("« Bᴀᴄᴋ", data="ownr")],
+            ],
+        )
+        remove("ultroid_updates.txt")
+    else:
+        await event.edit(
+            changelog_str,
+            buttons=[
+                [Button.inline("Update Now", data="updatenow")],
+                [Button.inline("« Bᴀᴄᴋ", data="ownr")],
+            ],
+            parse_mode="html",
+        )
+
+
+@callback(data="pkng", owner=True)
+async def _(event):
+    start = datetime.now()
+    end = datetime.now()
+    ms = (end - start).microseconds
+    pin = f"🌋Pɪɴɢ = {ms} microseconds"
+    await event.answer(pin, cache_time=0, alert=True)
+
+
+@callback(data="upp", owner=True)
+async def _(event):
+    uptime = time_formatter((time.time() - start_time) * 1000)
+    pin = f"🙋Uᴘᴛɪᴍᴇ = {uptime}"
+    await event.answer(pin, cache_time=0, alert=True)
+
+
+@callback(data="inlone", owner=True)
+async def _(e):
+    _InButtons = [
+        Button.switch_inline(_, query=InlinePlugin[_], same_peer=True)
+        for _ in list(InlinePlugin.keys())
+    ]
+    InButtons = split_list(_InButtons, 2)
+
+    button = InButtons.copy()
+    button.append(
+        [
+            Button.inline("« Bᴀᴄᴋ", data="open"),
+        ],
+    )
+    await e.edit(buttons=button, link_preview=False)
+
+
+@callback(data="open", owner=True)
+async def opner(event):
+    z = []
+    for x in LIST.values():
+        z.extend(x)
+    await event.edit(
+        get_string("inline_4").format(
+            OWNER_NAME,
+            len(HELP.get("Official", [])),
+            len(HELP.get("Addons", [])),
+            len(z),
+        ),
+        buttons=_main_help_menu,
+        link_preview=False,
+    )
+
+
+@callback(data="close", owner=True)
+async def on_plug_in_callback_query_handler(event):
+    await event.edit(
+        get_string("inline_5"),
+        buttons=Button.inline("Oᴘᴇɴ Aɢᴀɪɴ", data="open"),
+    )
+
+
+def page_num(index, key):
+    rows = udB.get_key("HELP_ROWS") or 5
+    cols = udB.get_key("HELP_COLUMNS") or 2
+    loaded = HELP.get(key, [])
+    emoji = udB.get_key("EMOJI_IN_HELP") or "✘"
+    List = [
+        Button.inline(f"{emoji} {x} {emoji}", data=f"uplugin_{key}_{x}|{index}")
+        for x in sorted(loaded)
+    ]
+    all_ = split_list(List, cols)
+    fl_ = split_list(all_, rows)
+    try:
+        new_ = fl_[index]
+    except IndexError:
+        new_ = fl_[0] if fl_ else []
+        index = 0
+    if index == 0 and len(fl_) == 1:
+        new_.append([Button.inline("« Bᴀᴄᴋ »", data="open")])
+    else:
+        new_.append(
+            [
+                Button.inline(
+                    "« Pʀᴇᴠɪᴏᴜs",
+                    data=f"uh_{key}_{index-1}",
+                ),
+                Button.inline("« Bᴀᴄᴋ »", data="open"),
+                Button.inline(
+                    "Nᴇxᴛ »",
+                    data=f"uh_{key}_{index+1}",
+                ),
+            ]
+        )
+    return new_
+
+
+# --------------------------------------------------------------------------------- #
+
+
+STUFF = {}
+
+
+@in_pattern("stf(.*)", owner=True)
+async def ibuild(e):
+    n = e.pattern_match.group(1).strip()
+    builder = e.builder
+    if not (n and n.isdigit()):
+        return
+    ok = STUFF.get(int(n))
+    txt = ok.get("msg")
+    pic = ok.get("media")
+    btn = ok.get("button")
+    if not (pic or txt):
+        txt = "Hey!"
+    if pic:
+        try:
+            include_media = True
+            mime_type, _pic = None, None
+            cont, results = None, None
+            try:
+                ext = str(pic).split(".")[-1].lower()
+            except BaseException:
+                ext = None
+            if ext in ["img", "jpg", "png"]:
+                _type = "photo"
+                mime_type = "image/jpg"
+            elif ext in ["mp4", "mkv", "gif"]:
+                mime_type = "video/mp4"
+                _type = "gif"
+            else:
+                try:
+                    if "telethon.tl.types" in str(type(pic)):
+                        _pic = pic
+                    else:
+                        _pic = resolve_bot_file_id(pic)
+                except BaseException:
+                    pass
+                if _pic:
+                    results = [
+                        await builder.document(
+                            _pic,
+                            title="Ultroid Op",
+                            text=txt,
+                            description="@TeamUltroid",
+                            buttons=btn,
+                            link_preview=False,
+                        )
+                    ]
+                else:
+                    _type = "article"
+                    include_media = False
+            if not results:
+                if include_media:
+                    cont = InputWebDocument(pic, 0, mime_type, [])
+                results = [
+                    await builder.article(
+                        title="Ultroid Op",
+                        type=_type,
+                        text=txt,
+                        description="@TeamUltroid",
+                        include_media=include_media,
+                        buttons=btn,
+                        thumb=cont,
+                        content=cont,
+                        link_preview=False,
+                    )
+                ]
+            return await e.answer(results)
+        except Exception as er:
+            LOGS.exception(er)
+    result = [
+        await builder.article("Ultroid Op", text=txt, link_preview=False, buttons=btn)
+    ]
+    await e.answer(result)
+
+
+async def something(e, msg, media, button, reply=True, chat=None):
+    if e.client._bot:
+        return await e.reply(msg, file=media, buttons=button)
+    num = len(STUFF) + 1
+    STUFF.update({num: {"msg": msg, "media": media, "button": button}})
+    try:
+        res = await e.client.inline_query(asst.me.username, f"stf{num}")
+        return await res[0].click(
+            chat or e.chat_id,
+            reply_to=bool(isinstance(e, Message) and reply),
+            hide_via=True,
+            silent=True,
+        )
+
+    except Exception as er:
+        LOGS.exception(er)

plugins/_ultroid.py

@@ -0,0 +1,66 @@
+# Ultroid - UserBot
+# Copyright (C) 2021-2025 TeamUltroid
+#
+# This file is a part of < https://github.com/TeamUltroid/Ultroid/ >
+# PLease read the GNU Affero General Public License in
+# <https://www.github.com/TeamUltroid/Ultroid/blob/main/LICENSE/>.
+
+from telethon.errors import (
+    BotMethodInvalidError,
+    ChatSendInlineForbiddenError,
+    ChatSendMediaForbiddenError,
+)
+
+from . import LOG_CHANNEL, LOGS, Button, asst, eor, get_string, ultroid_cmd
+
+REPOMSG = """
+• **ULTROID USERBOT** •\n
+• Repo - [Click Here](https://github.com/TeamUltroid/Ultroid)
+• Addons - [Click Here](https://github.com/TeamUltroid/UltroidAddons)
+• Support - @UltroidSupportChat
+"""
+
+RP_BUTTONS = [
+    [
+        Button.url(get_string("bot_3"), "https://github.com/TeamUltroid/Ultroid"),
+        Button.url("Addons", "https://github.com/TeamUltroid/UltroidAddons"),
+    ],
+    [Button.url("Support Group", "t.me/UltroidSupportChat")],
+]
+
+ULTSTRING = """🎇 **Thanks for Deploying Ultroid Userbot!**
+
+• Here, are the Some Basic stuff from, where you can Know, about its Usage."""
+
+
+@ultroid_cmd(
+    pattern="repo$",
+    manager=True,
+)
+async def repify(e):
+    try:
+        q = await e.client.inline_query(asst.me.username, "")
+        await q[0].click(e.chat_id)
+        return await e.delete()
+    except (
+        ChatSendInlineForbiddenError,
+        ChatSendMediaForbiddenError,
+        BotMethodInvalidError,
+    ):
+        pass
+    except Exception as er:
+        LOGS.info(f"Error while repo command : {str(er)}")
+    await e.eor(REPOMSG)
+
+
+@ultroid_cmd(pattern="ultroid$")
+async def useUltroid(rs):
+    button = Button.inline("Start >>", "initft_2")
+    msg = await asst.send_message(
+        LOG_CHANNEL,
+        ULTSTRING,
+        file="https://graph.org/file/54a917cc9dbb94733ea5f.jpg",
+        buttons=button,
+    )
+    if not (rs.chat_id == LOG_CHANNEL and rs.client._bot):
+        await eor(rs, f"**[Click Here]({msg.message_link})**")

plugins/_userlogs.py

@@ -0,0 +1,299 @@
+# Ultroid - UserBot
+# Copyright (C) 2021-2025 TeamUltroid
+#
+# This file is a part of < https://github.com/TeamUltroid/Ultroid/ >
+# PLease read the GNU Affero General Public License in
+# <https://www.github.com/TeamUltroid/Ultroid/blob/main/LICENSE/>.
+
+import os
+import re
+
+from telethon.errors.rpcerrorlist import (
+    ChannelPrivateError,
+    ChatWriteForbiddenError,
+    MediaCaptionTooLongError,
+    MediaEmptyError,
+    MessageTooLongError,
+    PeerIdInvalidError,
+    UserNotParticipantError,
+)
+from telethon.tl.types import MessageEntityMention, MessageEntityMentionName, User
+from telethon.utils import get_display_name
+
+from pyUltroid.dB.botchat_db import tag_add, who_tag
+
+from . import (
+    LOG_CHANNEL,
+    LOGS,
+    Button,
+    asst,
+    callback,
+    events,
+    get_string,
+    inline_mention,
+    udB,
+    ultroid_bot,
+)
+
+CACHE_SPAM = {}
+TAG_EDITS = {}
+
+
+@ultroid_bot.on(
+    events.NewMessage(
+        incoming=True,
+        func=lambda e: (e.mentioned),
+    ),
+)
+async def all_messages_catcher(e):
+    x = await e.get_sender()
+    if isinstance(x, User) and (x.bot or x.verified):
+        return
+    if not udB.get_key("TAG_LOG"):
+        return
+    NEEDTOLOG = udB.get_key("TAG_LOG")
+    if e.chat_id == NEEDTOLOG:
+        return
+    buttons = await parse_buttons(e)
+    try:
+        sent = await asst.send_message(NEEDTOLOG, e.message, buttons=buttons)
+        if TAG_EDITS.get(e.chat_id):
+            TAG_EDITS[e.chat_id].update({e.id: {"id": sent.id, "msg": e}})
+        else:
+            TAG_EDITS.update({e.chat_id: {e.id: {"id": sent.id, "msg": e}}})
+        tag_add(sent.id, e.chat_id, e.id)
+    except MediaEmptyError as er:
+        LOGS.debug(f"handling {er}.")
+        try:
+            msg = await asst.get_messages(e.chat_id, ids=e.id)
+            sent = await asst.send_message(NEEDTOLOG, msg, buttons=buttons)
+            if TAG_EDITS.get(e.chat_id):
+                TAG_EDITS[e.chat_id].update({e.id: {"id": sent.id, "msg": e}})
+            else:
+                TAG_EDITS.update({e.chat_id: {e.id: {"id": sent.id, "msg": e}}})
+            tag_add(sent.id, e.chat_id, e.id)
+        except Exception as me:
+            if not isinstance(me, (PeerIdInvalidError, ValueError)):
+                LOGS.exception(me)
+            if e.photo or e.sticker or e.gif:
+                try:
+                    media = await e.download_media()
+                    sent = await asst.send_message(
+                        NEEDTOLOG, e.message.text, file=media, buttons=buttons
+                    )
+                    if TAG_EDITS.get(e.chat_id):
+                        TAG_EDITS[e.chat_id].update({e.id: {"id": sent.id, "msg": e}})
+                    else:
+                        TAG_EDITS.update({e.chat_id: {e.id: {"id": sent.id, "msg": e}}})
+                    return os.remove(media)
+                except Exception as er:
+                    LOGS.exception(er)
+            await asst.send_message(NEEDTOLOG, get_string("com_4"), buttons=buttons)
+    except (PeerIdInvalidError, ValueError) as er:
+        LOGS.exception(er)
+        try:
+            CACHE_SPAM[NEEDTOLOG]
+        except KeyError:
+            await asst.send_message(
+                udB.get_key("LOG_CHANNEL"), get_string("userlogs_1")
+            )
+            CACHE_SPAM.update({NEEDTOLOG: True})
+    except ChatWriteForbiddenError:
+        try:
+            await asst.get_permissions(NEEDTOLOG, "me")
+            MSG = get_string("userlogs_4")
+        except UserNotParticipantError:
+            MSG = get_string("userlogs_2")
+        try:
+            CACHE_SPAM[NEEDTOLOG]
+        except KeyError:
+            await asst.send_message(LOG_CHANNEL, MSG)
+            CACHE_SPAM.update({NEEDTOLOG: True})
+    except Exception as er:
+        LOGS.exception(er)
+
+
+if udB.get_key("TAG_LOG"):
+
+    @ultroid_bot.on(events.MessageEdited(func=lambda x: not x.out))
+    async def upd_edits(event):
+        x = event.sender
+        if isinstance(x, User) and (x.bot or x.verified):
+            return
+        if event.chat_id not in TAG_EDITS:
+            if event.sender_id == udB.get_key("TAG_LOG"):
+                return
+            if event.is_private:
+                return
+            if entities := event.get_entities_text():
+                is_self = False
+                username = event.client.me.username
+                if username:
+                    username = username.lower()
+                for ent, text in entities:
+                    if isinstance(ent, MessageEntityMention):
+                        is_self = text[1:].lower() == username
+                    elif isinstance(ent, MessageEntityMentionName):
+                        is_self = ent.user_id == event.client.me.id
+                if is_self:
+                    text = f"**#Edited & #Mentioned**\n\n{event.text}"
+                    try:
+                        sent = await asst.send_message(
+                            udB.get_key("TAG_LOG"),
+                            text,
+                            buttons=await parse_buttons(event),
+                        )
+                    except Exception as er:
+                        return LOGS.exception(er)
+                    if TAG_EDITS.get(event.chat_id):
+                        TAG_EDITS[event.chat_id].update({event.id: {"id": sent.id}})
+                    else:
+                        TAG_EDITS.update({event.chat_id: {event.id: {"id": sent.id}}})
+            return
+        d_ = TAG_EDITS[event.chat_id]
+        if not d_.get(event.id):
+            return
+        d_ = d_[event.id]
+        if d_["msg"].text == event.text:
+            return
+        msg = None
+        if d_.get("count"):
+            d_["count"] += 1
+        else:
+            msg = True
+            d_.update({"count": 1})
+        if d_["count"] > 10:
+            return  # some limit to take edits
+        try:
+            MSG = await asst.get_messages(udB.get_key("TAG_LOG"), ids=d_["id"])
+        except Exception as er:
+            return LOGS.exception(er)
+        TEXT = MSG.text
+        if msg:
+            TEXT += "\n\n🖋 **Later Edited to !**"
+        strf = event.edit_date.strftime("%H:%M:%S")
+        if "\n" not in event.text:
+            TEXT += f"\n• `{strf}` : {event.text}"
+        else:
+            TEXT += f"\n• `{strf}` :\n-> {event.text}"
+        if d_["count"] == 10:
+            TEXT += "\n\n• __Only the first 10 Edits are shown.__"
+        try:
+            msg = await MSG.edit(TEXT, buttons=await parse_buttons(event))
+            d_["msg"] = msg
+        except (MessageTooLongError, MediaCaptionTooLongError):
+            del TAG_EDITS[event.chat_id][event.id]
+        except Exception as er:
+            LOGS.exception(er)
+
+    @ultroid_bot.on(
+        events.NewMessage(
+            outgoing=True,
+            chats=[udB.get_key("TAG_LOG")],
+            func=lambda e: e.reply_to,
+        )
+    )
+    async def idk(e):
+        id = e.reply_to_msg_id
+        chat, msg = who_tag(id)
+        if chat and msg:
+            try:
+                await ultroid_bot.send_message(chat, e.message, reply_to=msg)
+            except BaseException as er:
+                LOGS.exception(er)
+
+
+# log for assistant/user joins/add
+
+
+async def when_added_or_joined(event):
+    user = await event.get_user()
+    chat = await event.get_chat()
+    if not (user and user.is_self):
+        return
+    if getattr(chat, "username", None):
+        chat = f"[{chat.title}](https://t.me/{chat.username}/{event.action_message.id})"
+    else:
+        chat = f"[{chat.title}](https://t.me/c/{chat.id}/{event.action_message.id})"
+    key = "bot" if event.client._bot else "user"
+    buttons = Button.inline(
+        get_string("userlogs_3"), data=f"leave_ch_{event.chat_id}|{key}"
+    )
+    if event.user_added:
+        tmp = event.added_by
+        text = f"#ADD_LOG\n\n{inline_mention(tmp)} just added {inline_mention(user)} to {chat}."
+    elif event.from_request:
+        text = f"#APPROVAL_LOG\n\n{inline_mention(user)} just got Chat Join Approval to {chat}."
+    else:
+        text = f"#JOIN_LOG\n\n{inline_mention(user)} just joined {chat}."
+    await asst.send_message(udB.get_key("LOG_CHANNEL"), text, buttons=buttons)
+
+
+asst.add_event_handler(
+    when_added_or_joined, events.ChatAction(func=lambda x: x.user_added)
+)
+ultroid_bot.add_event_handler(
+    when_added_or_joined,
+    events.ChatAction(func=lambda x: x.user_added or x.user_joined),
+)
+_client = {"bot": asst, "user": ultroid_bot}
+
+
+@callback(
+    re.compile(
+        "leave_ch_(.*)",
+    ),
+    from_users=[ultroid_bot.uid],
+)
+async def leave_ch_at(event):
+    cht = event.data_match.group(1).decode("UTF-8")
+    ch_id, client = cht.split("|")
+    try:
+        client = _client[client]
+    except KeyError:
+        return
+    try:
+        name = (await client.get_entity(int(ch_id))).title
+        await client.delete_dialog(int(ch_id))
+    except UserNotParticipantError:
+        pass
+    except ChannelPrivateError:
+        return await event.edit(
+            "`[CANT_ACCESS_CHAT]` `Maybe already left or got banned.`"
+        )
+    except Exception as er:
+        LOGS.exception(er)
+        return await event.answer(str(er))
+    await event.edit(get_string("userlogs_5").format(name))
+
+
+@callback("do_nothing")
+async def _(event):
+    await event.answer()
+
+
+async def parse_buttons(event):
+    y, x = event.chat, event.sender
+    where_n, who_n = get_display_name(y), get_display_name(x)
+    where_l = event.message_link
+    buttons = [[Button.url(where_n, where_l)]]
+    if isinstance(x, User) and x.username:
+        try:
+            buttons.append(
+                [Button.mention(who_n, await asst.get_input_entity(x.username))]
+            )
+        except Exception as er:
+            LOGS.exception(er)
+            buttons.append([Button.url(who_n, f"t.me/{x.username}")])
+    elif getattr(x, "username"):
+        buttons.append([Button.url(who_n, f"t.me/{x.username}")])
+    else:
+        buttons.append([Button.url(who_n, where_l)])
+    replied = await event.get_reply_message()
+    if replied and replied.out:
+        button = Button.url("Replied to", replied.message_link)
+        if len(who_n) > 7:
+            buttons.append([button])
+        else:
+            buttons[-1].append(button)
+    return buttons

plugins/_wspr.py

@@ -0,0 +1,204 @@
+# Ultroid - UserBot
+# Copyright (C) 2021-2025 TeamUltroid
+#
+# This file is a part of < https://github.com/TeamUltroid/Ultroid/ >
+# PLease read the GNU Affero General Public License in
+# <https://www.github.com/TeamUltroid/Ultroid/blob/main/LICENSE/>.
+
+import re
+
+from telethon import Button
+from telethon.errors.rpcerrorlist import (
+    BotInlineDisabledError,
+    BotResponseTimeoutError,
+    MessageNotModifiedError,
+)
+from telethon.tl import types
+from telethon.tl.functions.users import GetFullUserRequest as gu
+
+from . import (
+    HNDLR,
+    LOGS,
+    asst,
+    callback,
+    get_string,
+    in_pattern,
+    inline_mention,
+    ultroid_bot,
+    ultroid_cmd,
+)
+
+buddhhu = {}
+
+
+@ultroid_cmd(
+    pattern="wspr( (.*)|$)",
+)
+async def _(e):
+    if e.reply_to_msg_id:
+        okk = await e.get_reply_message()
+        put = f"@{okk.sender.username}" if okk.sender.username else okk.sender_id
+    else:
+        put = e.pattern_match.group(1).strip()
+    if put:
+        try:
+            results = await e.client.inline_query(asst.me.username, f"msg {put}")
+        except BotResponseTimeoutError:
+            return await e.eor(
+                get_string("help_2").format(HNDLR),
+            )
+        except BotInlineDisabledError:
+            return await e.eor(get_string("help_3"))
+        await results[0].click(e.chat_id, reply_to=e.reply_to_msg_id, hide_via=True)
+        return await e.delete()
+    await e.eor(get_string("wspr_3"))
+
+
+@in_pattern("wspr", owner=True)
+async def _(e):
+    iuser = e.query.user_id
+    zzz = e.text.split(maxsplit=2)
+    try:
+        query = zzz[1]
+        if query.isdigit():
+            query = int(query)
+        logi = await ultroid_bot.get_entity(query)
+        if not isinstance(logi, types.User):
+            raise ValueError("Invalid Username.")
+    except IndexError:
+        sur = await e.builder.article(
+            title="Give Username",
+            description="You Didn't Type Username or id.",
+            text="You Didn't Type Username or id.",
+        )
+        return await e.answer([sur])
+    except ValueError as er:
+        LOGS.exception(er)
+        sur = await e.builder.article(
+            title="User Not Found",
+            description="Make sure username or id is correct.",
+            text="Make sure username or id is correct.",
+        )
+        return await e.answer([sur])
+    try:
+        desc = zzz[2]
+    except IndexError:
+        sur = await e.builder.article(
+            title="Type ur msg", text="You Didn't Type Your Msg"
+        )
+        return await e.answer([sur])
+    button = [
+        [
+            Button.inline("Secret Msg", data=f"dd_{e.id}"),
+            Button.inline("Delete Msg", data=f"del_{e.id}"),
+        ],
+        [
+            Button.switch_inline(
+                "New", query=f"wspr {logi.username or logi.id}", same_peer=True
+            )
+        ],
+    ]
+    us = logi.username or logi.first_name
+    sur = await e.builder.article(
+        title=logi.first_name,
+        description=desc,
+        text=get_string("wspr_1").format(us),
+        buttons=button,
+    )
+    buddhhu.update({e.id: [logi.id, iuser, desc]})
+    await e.answer([sur])
+
+
+@in_pattern("msg", owner=True)
+async def _(e):
+    zzz = e.text.split(maxsplit=1)
+    desc = "Touch me"
+    try:
+        query = zzz[1]
+        if query.isdigit():
+            query = int(query)
+        logi = await ultroid_bot(gu(id=query))
+        user = logi.users[0]
+        mention = inline_mention(user)
+        x = user.status
+        if isinstance(x, types.UserStatusOnline):
+            status = "Online"
+        elif isinstance(x, types.UserStatusOffline):
+            status = "Offline"
+        elif isinstance(x, types.UserStatusRecently):
+            status = "Last Seen Recently"
+        elif isinstance(x, types.UserStatusLastMonth):
+            status = "Last seen months ago"
+        elif isinstance(x, types.UserStatusLastWeek):
+            status = "Last seen weeks ago"
+        else:
+            status = "Can't Tell"
+        text = f"**Name:**    `{user.first_name}`\n"
+        text += f"**Id:**    `{user.id}`\n"
+        if user.username:
+            text += f"**Username:**    `{user.username}`\n"
+            url = f"https://t.me/{user.username}"
+        else:
+            text += f"**Mention:**    `{mention}`\n"
+            url = f"tg://user?id={user.id}"
+        text += f"**Status:**    `{status}`\n"
+        text += f"**About:**    `{logi.full_user.about}`"
+        button = [
+            Button.url("Private", url=url),
+            Button.switch_inline(
+                "Secret msg",
+                query=f"wspr {query} Hello 👋",
+                same_peer=True,
+            ),
+        ]
+        sur = e.builder.article(
+            title=user.first_name,
+            description=desc,
+            text=text,
+            buttons=button,
+        )
+    except IndexError:
+        sur = e.builder.article(
+            title="Give Username",
+            description="You Didn't Type Username or id.",
+            text="You Didn't Type Username or id.",
+        )
+    except BaseException as er:
+        LOGS.exception(er)
+        name = get_string("wspr_4").format(query)
+        sur = e.builder.article(
+            title=name,
+            text=name,
+        )
+
+    await e.answer([sur])
+
+
+@callback(
+    re.compile(
+        "dd_(.*)",
+    ),
+)
+async def _(e):
+    ids = int(e.pattern_match.group(1).strip().decode("UTF-8"))
+    if buddhhu.get(ids):
+        if e.sender_id in buddhhu[ids]:
+            await e.answer(buddhhu[ids][-1], alert=True)
+        else:
+            await e.answer("Not For You", alert=True)
+    else:
+        await e.answer(get_string("wspr_2"), alert=True)
+
+
+@callback(re.compile("del_(.*)"))
+async def _(e):
+    ids = int(e.pattern_match.group(1).strip().decode("UTF-8"))
+    if buddhhu.get(ids):
+        if e.sender_id in buddhhu[ids]:
+            buddhhu.pop(ids)
+            try:
+                await e.edit(get_string("wspr_2"))
+            except MessageNotModifiedError:
+                pass
+        else:
+            await e.answer(get_string("wspr_5"), alert=True)

plugins/admintools.py

@@ -0,0 +1,471 @@
+# Ultroid - UserBot
+# Copyright (C) 2021-2025 TeamUltroid
+#
+# This file is a part of < https://github.com/TeamUltroid/Ultroid/ >
+# PLease read the GNU Affero General Public License in
+# <https://www.github.com/TeamUltroid/Ultroid/blob/main/LICENSE/>.
+
+from . import get_help
+
+__doc__ = get_help("help_admintools")
+
+import asyncio
+
+from telethon.errors import BadRequestError
+from telethon.errors.rpcerrorlist import ChatNotModifiedError, UserIdInvalidError
+from telethon.tl.functions.channels import EditAdminRequest, GetFullChannelRequest
+from telethon.tl.functions.messages import GetFullChatRequest, SetHistoryTTLRequest
+from telethon.tl.types import InputMessagesFilterPinned
+from telethon.utils import get_display_name
+
+from pyUltroid.dB import DEVLIST
+from pyUltroid.fns.admins import ban_time
+from pyUltroid.fns.info import get_uinfo
+
+from . import HNDLR, LOGS, eod, eor, get_string, inline_mention, types, ultroid_cmd
+
+
+@ultroid_cmd(
+    pattern="promote( (.*)|$)",
+    admins_only=True,
+    manager=True,
+    require="add_admins",
+    fullsudo=True,
+)
+async def prmte(ult):
+    xx = await ult.eor(get_string("com_1"))
+    user, rank = await get_uinfo(ult)
+    rank = rank or "Admin"
+    FullRight = False
+    if not user:
+        return await xx.edit(get_string("pro_1"))
+    if rank.split()[0] == "-f":
+        try:
+            rank = rank.split(maxsplit=1)[1]
+        except IndexError:
+            rank = "Admin"
+        FullRight = True
+    try:
+        if FullRight:
+            await ult.client(
+                EditAdminRequest(ult.chat_id, user.id, ult.chat.admin_rights, rank)
+            )
+        else:
+            await ult.client.edit_admin(
+                ult.chat_id,
+                user.id,
+                invite_users=True,
+                ban_users=True,
+                delete_messages=True,
+                pin_messages=True,
+                manage_call=True,
+                title=rank,
+            )
+        await eod(
+            xx, get_string("pro_2").format(inline_mention(user), ult.chat.title, rank)
+        )
+    except Exception as ex:
+        return await xx.edit(f"`{ex}`")
+
+
+@ultroid_cmd(
+    pattern="demote( (.*)|$)",
+    admins_only=True,
+    manager=True,
+    require="add_admins",
+    fullsudo=True,
+)
+async def dmote(ult):
+    xx = await ult.eor(get_string("com_1"))
+    user, rank = await get_uinfo(ult)
+    if not rank:
+        rank = "Not Admin"
+    if not user:
+        return await xx.edit(get_string("de_1"))
+    try:
+        await ult.client.edit_admin(
+            ult.chat_id,
+            user.id,
+            invite_users=None,
+            ban_users=None,
+            delete_messages=None,
+            pin_messages=None,
+            manage_call=None,
+            title=rank,
+        )
+        await eod(xx, get_string("de_2").format(inline_mention(user), ult.chat.title))
+    except Exception as ex:
+        return await xx.edit(f"`{ex}`")
+
+
+@ultroid_cmd(
+    pattern="ban( (.*)|$)",
+    admins_only=True,
+    manager=True,
+    require="ban_users",
+    fullsudo=True,
+)
+async def bban(ult):
+    something = await get_uinfo(ult)
+    if not something:
+        return
+    user, reason = something
+    if not user:
+        return await eod(ult, get_string("ban_1"))
+    if user.id in DEVLIST:
+        return await eod(ult, get_string("ban_2"))
+    try:
+        await ult.client.edit_permissions(ult.chat_id, user.id, view_messages=False)
+    except UserIdInvalidError:
+        return await eod(ult, get_string("adm_1"))
+    except BadRequestError:
+        return await eod(ult, get_string("ban_3"))
+    senderme = inline_mention(await ult.get_sender())
+    userme = inline_mention(user)
+    text = get_string("ban_4").format(userme, senderme, ult.chat.title)
+    if reason:
+        text += get_string("ban_5").format(reason)
+    await eod(ult, text)
+
+
+@ultroid_cmd(
+    pattern="unban( (.*)|$)",
+    admins_only=True,
+    manager=True,
+    require="ban_users",
+    fullsudo=True,
+)
+async def uunban(ult):
+    xx = await ult.eor(get_string("com_1"))
+    if ult.text[1:].startswith("unbanall"):
+        return
+    something = await get_uinfo(ult)
+    if not something:
+        return
+    user, reason = something
+    if not user:
+        return await xx.edit(get_string("unban_1"))
+    try:
+        await ult.client.edit_permissions(ult.chat_id, user.id, view_messages=True)
+    except UserIdInvalidError:
+        return await eod(ult, get_string("adm_1"))
+    except BadRequestError:
+        return await xx.edit(get_string("adm_2"))
+    sender = inline_mention(await ult.get_sender())
+    text = get_string("unban_3").format(inline_mention(user), sender, ult.chat.title)
+    if reason:
+        text += get_string("ban_5").format(reason)
+    await xx.edit(text)
+
+
+@ultroid_cmd(
+    pattern="kick( (.*)|$)",
+    manager=True,
+    require="ban_users",
+    fullsudo=True,
+)
+async def kck(ult):
+    if "kickme" in ult.text:
+        return
+    if ult.is_private:
+        return await ult.eor("`Use this in Group/Channel.`", time=5)
+    ml = ult.text.split(" ", maxsplit=1)[0]
+    xx = await ult.eor(get_string("com_1"))
+    something = await get_uinfo(ult)
+    if not something:
+        return
+    user, reason = something
+    if not user:
+        return await xx.edit(get_string("adm_1"))
+    if user.id in DEVLIST:
+        return await xx.edit(get_string("kick_2"))
+    if getattr(user, "is_self", False):
+        return await xx.edit(get_string("kick_3"))
+    try:
+        await ult.client.kick_participant(ult.chat_id, user.id)
+    except BadRequestError as er:
+        LOGS.info(er)
+        return await xx.edit(get_string("kick_1"))
+    except Exception as e:
+        LOGS.exception(e)
+        return
+    text = get_string("kick_4").format(
+        inline_mention(user), inline_mention(await ult.get_sender()), ult.chat.title
+    )
+    if reason:
+        text += get_string("ban_5").format(reason)
+    await xx.edit(text)
+
+
+@ultroid_cmd(
+    pattern="tban( (.*)|$)",
+    admins_only=True,
+    manager=True,
+    require="ban_users",
+    fullsudo=True,
+)
+async def tkicki(e):
+    huh = e.text.split()
+    inputt = None
+    try:
+        tme = huh[1]
+    except IndexError:
+        return await e.eor(get_string("adm_3"), time=15)
+    try:
+        inputt = huh[2]
+    except IndexError:
+        if e.reply_to_msg_id:
+            inputt = (await e.get_reply_message()).sender_id
+    if not inputt:
+        return await e.eor(get_string("tban_1"))
+    userid = await e.client.parse_id(inputt)
+    try:
+        user = await e.client.get_entity(userid)
+    except Exception as ex:
+        return await eor(e, f"`{ex}`")
+    try:
+        bun = ban_time(tme)
+        await e.client.edit_permissions(
+            e.chat_id, user.id, until_date=bun, view_messages=False
+        )
+        await eod(
+            e,
+            get_string("tban_2").format(inline_mention(user), e.chat.title, tme),
+            time=15,
+        )
+    except Exception as m:
+        return await e.eor(str(m))
+
+
+@ultroid_cmd(pattern="pin$", manager=True, require="pin_messages", fullsudo=True)
+async def pin(msg):
+    if not msg.is_reply:
+        return await eor(msg, get_string("pin_1"))
+    me = await msg.get_reply_message()
+    if me.is_private:
+        text = "`Pinned.`"
+    else:
+        text = f"Pinned [This Message]({me.message_link}) !"
+    try:
+        await msg.client.pin_message(msg.chat_id, me.id, notify=False)
+    except BadRequestError:
+        return await eor(msg, get_string("adm_2"))
+    except Exception as e:
+        return await eor(msg, f"**ERROR:**`{e}`")
+    await eor(msg, text)
+
+
+@ultroid_cmd(
+    pattern="unpin($| (.*))",
+    manager=True,
+    require="pin_messages",
+    fullsudo=True,
+)
+async def unp(ult):
+    xx = await ult.eor(get_string("com_1"))
+    ch = (ult.pattern_match.group(1).strip()).strip()
+    msg = None
+    if ult.is_reply:
+        msg = ult.reply_to_msg_id
+    elif ch != "all":
+        return await xx.edit(get_string("unpin_1").format(HNDLR))
+    try:
+        await ult.client.unpin_message(ult.chat_id, msg)
+    except BadRequestError:
+        return await xx.edit(get_string("adm_2"))
+    except Exception as e:
+        return await xx.edit(f"**ERROR:**`{e}`")
+    await xx.edit("`Unpinned!`")
+
+
+@ultroid_cmd(
+    pattern="tpin( (.*)|$)",
+    admins_only=True,
+    manager=True,
+    require="pin_messages",
+    fullsudo=True,
+)
+async def pin_message(ult):
+    match = ult.pattern_match.group(1).strip()
+    if not ult.is_reply:
+        return await ult.eor("`Reply to message..`", time=6)
+    if not match:
+        return await ult.eor("`Please provide time..`", time=8)
+    msg = await ult.eor(get_string("com_1"))
+    msg_id = ult.reply_to_msg_id
+    try:
+        time = ban_time(match)
+        await ult.client.pin_message(ult.chat_id, msg_id)
+        await msg.eor(f"`pinned for time` `{time}`", time=8)
+    except Exception as er:
+        return await msg.edit(str(er))
+    await asyncio.sleep(time)
+    try:
+        await ult.client.unpin_message(ult.chat_id, msg_id)
+    except Exception as er:
+        LOGS.exception(er)
+
+
+@ultroid_cmd(pattern="purge( (.*)|$)", manager=True, require="delete_messages")
+async def fastpurger(purg):
+    match = purg.pattern_match.group(1).strip()
+    try:
+        ABC = purg.text[6]
+    except IndexError:
+        ABC = None
+    if ABC and purg.text[6] in ["m", "a"]:
+        return
+    if not purg._client._bot and (
+        (match)
+        or (purg.is_reply and (purg.is_private or isinstance(purg.chat, types.Chat)))
+    ):
+        p = 0
+        async for msg in purg.client.iter_messages(
+            purg.chat_id,
+            limit=int(match) if match else None,
+            min_id=purg.reply_to_msg_id if purg.is_reply else None,
+        ):
+            await msg.delete()
+            p += 0
+        return await eor(purg, f"Purged {p} Messages! ", time=5)
+    if not purg.reply_to_msg_id:
+        return await eor(purg, get_string("purge_1"), time=10)
+    try:
+        await purg.client.delete_messages(
+            purg.chat_id, list(range(purg.reply_to_msg_id, purg.id))
+        )
+
+    except Exception as er:
+        LOGS.info(er)
+    await purg.eor("__Fast purge complete!__", time=5)
+
+
+@ultroid_cmd(
+    pattern="purgeme( (.*)|$)",
+)
+async def fastpurgerme(purg):
+    if num := purg.pattern_match.group(1).strip():
+        try:
+            nnt = int(num)
+        except BaseException:
+            await eor(purg, get_string("com_3"), time=5)
+            return
+        mp = 0
+        async for mm in purg.client.iter_messages(
+            purg.chat_id, limit=nnt, from_user="me"
+        ):
+            await mm.delete()
+            mp += 1
+        await eor(purg, f"Purged {mp} Messages!", time=5)
+        return
+    elif not purg.reply_to_msg_id:
+        return await eod(
+            purg,
+            "`Reply to a message to purge from or use it like ``purgeme <num>`",
+            time=10,
+        )
+    chat = await purg.get_input_chat()
+    msgs = []
+    async for msg in purg.client.iter_messages(
+        chat,
+        from_user="me",
+        min_id=purg.reply_to_msg_id,
+    ):
+        msgs.append(msg)
+    if msgs:
+        await purg.client.delete_messages(chat, msgs)
+    await purg.eor(
+        "__Fast purge complete!__\n**Purged** `" + str(len(msgs)) + "` **messages.**",
+        time=5,
+    )
+
+
+@ultroid_cmd(
+    pattern="purgeall$",
+)
+async def _(e):
+    if not e.is_reply:
+        return await eod(
+            e,
+            get_string("purgeall_1"),
+        )
+
+    msg = await e.get_reply_message()
+    name = msg.sender
+    try:
+        await e.client.delete_messages(e.chat_id, from_user=msg.sender_id)
+        await e.eor(get_string("purgeall_2").format(name.first_name), time=5)
+    except Exception as er:
+        return await e.eor(str(er), time=5)
+
+@ultroid_cmd(pattern="pinned", manager=True, groups_only=True)
+async def djshsh(event):
+    chat = await event.get_chat()
+    if isinstance(chat, types.Chat):
+        FChat = await event.client(GetFullChatRequest(chat.id))
+    elif isinstance(chat, types.Channel):
+        FChat = await event.client(GetFullChannelRequest(chat.id))
+    else:
+        return
+    msg_id = FChat.full_chat.pinned_msg_id
+    if not msg_id:
+        return await event.eor(get_string("pinned_1"))
+    msg = await event.client.get_messages(chat.id, ids=msg_id)
+    if msg:
+        await event.eor(get_string("pinned_2").format(msg.message_link))
+
+
+@ultroid_cmd(
+    pattern="listpinned$",
+)
+async def get_all_pinned(event):
+    x = await event.eor(get_string("com_1"))
+    chat_id = (str(event.chat_id)).replace("-100", "")
+    chat_name = get_display_name(event.chat)
+    a = ""
+    c = 1
+    async for i in event.client.iter_messages(
+        event.chat_id, filter=InputMessagesFilterPinned
+    ):
+        if i.message:
+            t = " ".join(i.message.split()[:4])
+            txt = f"{t}...."
+        else:
+            txt = "Go to message."
+        a += f"{c}. <a href=https://t.me/c/{chat_id}/{i.id}>{txt}</a>\n"
+        c += 1
+
+    if c == 1:
+        m = f"<b>The pinned message in {chat_name}:</b>\n\n"
+    else:
+        m = f"<b>List of pinned message(s) in {chat_name}:</b>\n\n"
+
+    if not a:
+        return await eor(x, get_string("listpin_1"), time=5)
+
+    await x.edit(m + a, parse_mode="html")
+
+
+@ultroid_cmd(
+    pattern="autodelete( (.*)|$)",
+    admins_only=True,
+)
+async def autodelte(ult):
+    match = ult.pattern_match.group(1).strip()
+    if not match or match not in ["24h", "7d", "1m", "off"]:
+        return await ult.eor("`Please Use in Proper Format..`", time=5)
+    if match == "24h":
+        tt = 3600 * 24
+    elif match == "7d":
+        tt = 3600 * 24 * 7
+    elif match == "1m":
+        tt = 3600 * 24 * 31
+    else:
+        tt = 0
+    try:
+        await ult.client(SetHistoryTTLRequest(ult.chat_id, period=tt))
+    except ChatNotModifiedError:
+        return await ult.eor(
+            f"Auto Delete Setting is Already same to `{match}`", time=5
+        )
+    await ult.eor(f"Auto Delete Status Changed to `{match}` !")

plugins/afk.py

@@ -0,0 +1,165 @@
+# Ultroid - UserBot
+# Copyright (C) 2021-2025 TeamUltroid
+#
+# This file is a part of < https://github.com/TeamUltroid/Ultroid/ >
+# PLease read the GNU Affero General Public License in
+# <https://www.github.com/TeamUltroid/Ultroid/blob/main/LICENSE/>.
+
+from . import get_help
+
+__doc__ = get_help("help_afk")
+
+
+import asyncio
+
+from telethon import events
+
+from pyUltroid.dB.afk_db import add_afk, del_afk, is_afk
+from pyUltroid.dB.base import KeyManager
+
+from . import (
+    LOG_CHANNEL,
+    NOSPAM_CHAT,
+    Redis,
+    asst,
+    get_string,
+    mediainfo,
+    udB,
+    ultroid_bot,
+    ultroid_cmd,
+    upload_file
+)
+
+old_afk_msg = []
+
+is_approved = KeyManager("PMPERMIT", cast=list).contains
+
+
+@ultroid_cmd(pattern="afk( (.*)|$)", owner_only=True)
+async def set_afk(event):
+    if event.client._bot or is_afk():
+        return
+    text, media, media_type = None, None, None
+    if event.pattern_match.group(1).strip():
+        text = event.text.split(maxsplit=1)[1]
+    reply = await event.get_reply_message()
+    if reply:
+        if reply.text and not text:
+            text = reply.text
+        if reply.media:
+            media_type = mediainfo(reply.media)
+            if media_type.startswith(("pic", "gif")):
+                file = await event.client.download_media(reply.media)
+                media = upload_file(file)
+            else:
+                media = reply.file.id
+    await event.eor("`Done`", time=2)
+    add_afk(text, media_type, media)
+    ultroid_bot.add_handler(remove_afk, events.NewMessage(outgoing=True))
+    ultroid_bot.add_handler(
+        on_afk,
+        events.NewMessage(
+            incoming=True, func=lambda e: bool(e.mentioned or e.is_private)
+        ),
+    )
+    msg1, msg2 = None, None
+    if text and media:
+        if "sticker" in media_type:
+            msg1 = await ultroid_bot.send_file(event.chat_id, file=media)
+            msg2 = await ultroid_bot.send_message(
+                event.chat_id, get_string("afk_5").format(text)
+            )
+        else:
+            msg1 = await ultroid_bot.send_message(
+                event.chat_id, get_string("afk_5").format(text), file=media
+            )
+    elif media:
+        if "sticker" in media_type:
+            msg1 = await ultroid_bot.send_file(event.chat_id, file=media)
+            msg2 = await ultroid_bot.send_message(event.chat_id, get_string("afk_6"))
+        else:
+            msg1 = await ultroid_bot.send_message(
+                event.chat_id, get_string("afk_6"), file=media
+            )
+    elif text:
+        msg1 = await event.respond(get_string("afk_5").format(text))
+    else:
+        msg1 = await event.respond(get_string("afk_6"))
+    old_afk_msg.append(msg1)
+    if msg2:
+        old_afk_msg.append(msg2)
+        return await asst.send_message(LOG_CHANNEL, msg2.text)
+    await asst.send_message(LOG_CHANNEL, msg1.text)
+
+
+async def remove_afk(event):
+    if event.is_private and udB.get_key("PMSETTING") and not is_approved(event.chat_id):
+        return
+    elif "afk" in event.text.lower():
+        return
+    elif event.chat_id in NOSPAM_CHAT:
+        return
+    if is_afk():
+        _, _, _, afk_time = is_afk()
+        del_afk()
+        off = await event.reply(get_string("afk_1").format(afk_time))
+        await asst.send_message(LOG_CHANNEL, get_string("afk_2").format(afk_time))
+        for x in old_afk_msg:
+            try:
+                await x.delete()
+            except BaseException:
+                pass
+        await asyncio.sleep(10)
+        await off.delete()
+
+
+async def on_afk(event):
+    if event.is_private and Redis("PMSETTING") and not is_approved(event.chat_id):
+        return
+    elif "afk" in event.text.lower():
+        return
+    elif not is_afk():
+        return
+    if event.chat_id in NOSPAM_CHAT:
+        return
+    sender = await event.get_sender()
+    if sender.bot or sender.verified:
+        return
+    text, media_type, media, afk_time = is_afk()
+    msg1, msg2 = None, None
+    if text and media:
+        if "sticker" in media_type:
+            msg1 = await event.reply(file=media)
+            msg2 = await event.reply(get_string("afk_3").format(afk_time, text))
+        else:
+            msg1 = await event.reply(
+                get_string("afk_3").format(afk_time, text), file=media
+            )
+    elif media:
+        if "sticker" in media_type:
+            msg1 = await event.reply(file=media)
+            msg2 = await event.reply(get_string("afk_4").format(afk_time))
+        else:
+            msg1 = await event.reply(get_string("afk_4").format(afk_time), file=media)
+    elif text:
+        msg1 = await event.reply(get_string("afk_3").format(afk_time, text))
+    else:
+        msg1 = await event.reply(get_string("afk_4").format(afk_time))
+    for x in old_afk_msg:
+        try:
+            await x.delete()
+        except BaseException:
+            pass
+    old_afk_msg.append(msg1)
+    if msg2:
+        old_afk_msg.append(msg2)
+
+
+if udB.get_key("AFK_DB"):
+    ultroid_bot.add_handler(remove_afk, events.NewMessage(outgoing=True))
+    ultroid_bot.add_handler(
+        on_afk,
+        events.NewMessage(
+            incoming=True, func=lambda e: bool(e.mentioned or e.is_private)
+        ),
+    )

plugins/aiwrapper.py

@@ -0,0 +1,445 @@
+# Ultroid - UserBot
+# Copyright (C) 2021-2025 TeamUltroid
+#
+# This file is a part of < https://github.com/TeamUltroid/Ultroid/ >
+# PLease read the GNU Affero General Public License in
+# <https://www.github.com/TeamUltroid/Ultroid/blob/main/LICENSE/>.
+
+"""
+✘ Commands Available -
+
+• `{i}gemini <prompt>`
+    Get response from Google Gemini.
+
+• `{i}antr <prompt>`
+    Get response from Anthropic Claude.
+
+• `{i}gpt <prompt>`
+    Get response from OpenAI GPT.
+
+• `{i}deepseek <prompt>`
+    Get response from DeepSeek AI.
+
+Set custom models using:
+    • OPENAI_MODEL: default: gpt-4o-mini
+    • ANTHROPIC_MODEL: claude-3-opus-20240229
+    • GEMINI_MODEL: gemini-1.5-flash
+    • DEEPSEEK_MODEL: deepseek-chat
+"""
+
+import json
+from . import LOGS, eor, get_string, udB, ultroid_cmd, async_searcher
+import aiohttp
+import asyncio
+
+
+ENDPOINTS = {
+    "gpt": "https://api.openai.com/v1/chat/completions",
+    "antr": "https://api.anthropic.com/v1/messages",
+    "gemini": "https://generativelanguage.googleapis.com/v1beta/chat/completions",
+    "deepseek": "https://api.deepseek.com/chat/completions"
+}
+
+DEFAULT_MODELS = {
+    "gpt": "gpt-4o-mini",
+    "antr": "claude-3-opus-20240229",
+    "gemini": "gemini-1.5-flash",
+    "deepseek": "deepseek-chat"
+}
+
+
+def get_model(provider):
+    """Get model name from database or use default"""
+    model_keys = {
+        "gpt": "OPENAI_MODEL",
+        "antr": "ANTHROPIC_MODEL",
+        "gemini": "GEMINI_MODEL",
+        "deepseek": "DEEPSEEK_MODEL"
+    }
+    return udB.get_key(model_keys[provider]) or DEFAULT_MODELS[provider]
+
+
+async def stream_response(msg, text):
+    """Stream response by editing message"""
+    current = ""
+    # Split into chunks of ~100 characters at word boundaries
+    words = text.split()
+    chunks = []
+    current_chunk = []
+    
+    for word in words:
+        current_chunk.append(word)
+        if len(" ".join(current_chunk)) > 100:
+            chunks.append(" ".join(current_chunk[:-1]))
+            current_chunk = [word]
+    if current_chunk:
+        chunks.append(" ".join(current_chunk))
+    
+    for chunk in chunks:
+        current += chunk + " "
+        try:
+            await msg.edit(current)
+        except Exception:
+            pass
+        await asyncio.sleep(0.5)
+    return current
+
+
+async def get_ai_response(provider, prompt, api_key, stream=False):
+    """Get response from AI provider"""
+    try:
+        headers = {"Content-Type": "application/json"}
+        model = get_model(provider)
+        
+        if provider == "gpt":
+            headers["Authorization"] = f"Bearer {api_key}"
+            data = {
+                "model": model,
+                "messages": [{"role": "user", "content": prompt}],
+                "stream": stream
+            }
+            if not stream:
+                response = await async_searcher(
+                    ENDPOINTS[provider],
+                    headers=headers,
+                    post=True,
+                    json=data,
+                    re_json=True
+                )
+                yield response["choices"][0]["message"]["content"]
+                return
+                
+            async with aiohttp.ClientSession() as session:
+                async with session.post(
+                    ENDPOINTS[provider],
+                    headers=headers,
+                    json=data
+                ) as resp:
+                    async for line in resp.content:
+                        if line:
+                            try:
+                                json_line = json.loads(line.decode('utf-8').strip().strip('data:').strip())
+                                if 'choices' in json_line and json_line['choices']:
+                                    content = json_line['choices'][0].get('delta', {}).get('content', '')
+                                    if content:
+                                        yield content
+                            except Exception:
+                                continue
+
+        elif provider == "antr":
+            headers["x-api-key"] = api_key
+            headers["anthropic-version"] = "2023-06-01"
+            data = {
+                "model": model,
+                "messages": [{"role": "user", "content": prompt}],
+                "stream": stream
+            }
+            if not stream:
+                response = await async_searcher(
+                    ENDPOINTS[provider],
+                    headers=headers,
+                    post=True,
+                    json=data,
+                    re_json=True
+                )
+                yield response["content"][0]["text"]
+                return
+                
+            async with aiohttp.ClientSession() as session:
+                async with session.post(
+                    ENDPOINTS[provider],
+                    headers=headers,
+                    json=data
+                ) as resp:
+                    async for line in resp.content:
+                        if line:
+                            try:
+                                json_line = json.loads(line.decode('utf-8').strip())
+                                if 'content' in json_line:
+                                    content = json_line['content'][0]['text']
+                                    if content:
+                                        yield content
+                            except Exception:
+                                continue
+
+        elif provider == "gemini":
+            headers["Authorization"] = f"Bearer {api_key}"
+            data = {
+                "model": model,
+                "messages": [
+                    {"role": "system", "content": "You are a helpful assistant."},
+                    {"role": "user", "content": prompt}
+                ],
+                "stream": stream
+            }
+            
+            if not stream:
+                try:
+                    response = await async_searcher(
+                        ENDPOINTS[provider],
+                        headers=headers,
+                        post=True,
+                        json=data,
+                        re_json=True
+                    )
+                    if "error" in response:
+                        error = response["error"]
+                        if error.get("code") == 429:
+                            retry_delay = None
+                            for detail in error.get("details", []):
+                                if detail.get("@type") == "type.googleapis.com/google.rpc.RetryInfo":
+                                    retry_delay = detail.get("retryDelay", "60s").rstrip("s")
+                            error_msg = f"⚠️ Rate limit exceeded. Please try again in {retry_delay} seconds."
+                            if "free_tier" in str(error):
+                                error_msg += "\nConsider upgrading to a paid tier for higher quotas."
+                            yield error_msg
+                            return
+                        yield f"Error: {error.get('message', 'Unknown error occurred')}"
+                        return
+                    yield response["choices"][0]["message"]["content"]
+                except Exception as e:
+                    LOGS.exception(e)
+                    yield f"Error: {str(e)}"
+                return
+
+            async with aiohttp.ClientSession() as session:
+                try:
+                    async with session.post(
+                        ENDPOINTS[provider],
+                        headers=headers,
+                        json=data
+                    ) as resp:
+                        if resp.status == 429:
+                            error_data = await resp.json()
+                            retry_delay = "60"
+                            for detail in error_data.get("error", {}).get("details", []):
+                                if detail.get("@type") == "type.googleapis.com/google.rpc.RetryInfo":
+                                    retry_delay = detail.get("retryDelay", "60s").rstrip("s")
+                            yield f"⚠️ Rate limit exceeded. Please try again in {retry_delay} seconds."
+                            return
+
+                        if resp.status != 200:
+                            error_data = await resp.json()
+                            yield f"Error: {error_data.get('error', {}).get('message', 'Unknown error occurred')}"
+                            return
+
+                        async for line in resp.content:
+                            if line:
+                                text = line.decode('utf-8').strip()
+                                if text.startswith('data: '):
+                                    data = text[6:]  # Remove 'data: ' prefix
+                                    if data == '[DONE]':
+                                        break
+                                    try:
+                                        json_data = json.loads(data)
+                                        if 'choices' in json_data and json_data['choices']:
+                                            content = json_data['choices'][0].get('delta', {}).get('content', '')
+                                            if content:
+                                                yield content
+                                    except json.JSONDecodeError:
+                                        continue
+                except Exception as e:
+                    LOGS.exception(e)
+                    yield f"Error: {str(e)}"
+
+        elif provider == "deepseek":
+            headers["Authorization"] = f"Bearer {api_key}"
+            data = {
+                "model": model,
+                "messages": [{"role": "user", "content": prompt}],
+                "stream": stream
+            }
+            if not stream:
+                response = await async_searcher(
+                    ENDPOINTS[provider],
+                    headers=headers,
+                    post=True,
+                    json=data,
+                    re_json=True
+                )
+                yield response["choices"][0]["message"]["content"]
+                return
+                
+            async with aiohttp.ClientSession() as session:
+                async with session.post(
+                    ENDPOINTS[provider],
+                    headers=headers,
+                    json=data
+                ) as resp:
+                    async for line in resp.content:
+                        if line:
+                            try:
+                                json_line = json.loads(line.decode('utf-8').strip())
+                                if 'choices' in json_line and json_line['choices']:
+                                    content = json_line['choices'][0].get('delta', {}).get('content', '')
+                                    if content:
+                                        yield content
+                            except Exception:
+                                continue
+
+    except Exception as e:
+        LOGS.exception(e)
+        yield f"Error: {str(e)}"
+
+
+@ultroid_cmd(pattern="gemini( (.*)|$)")
+async def gemini_ai(event):
+    """Use Google Gemini"""
+    prompt = event.pattern_match.group(1).strip()
+    if not prompt:
+        return await event.eor("❌ Please provide a prompt!")
+
+    api_key = udB.get_key("GEMINI_API_KEY")
+    if not api_key:
+        return await event.eor("⚠️ Please set Gemini API key using `setdb GEMINI_API_KEY your_api_key`")
+
+    msg = await event.eor("🤔 Thinking...")
+    model = get_model("gemini")
+    
+    header = (
+        "🤖 **Google Gemini**\n"
+        f"**Model:** `{model}`\n"
+        "➖➖➖➖➖➖➖➖➖➖\n\n"
+        f"**🔍 Prompt:**\n{prompt}\n\n"
+        "**💡 Response:**\n"
+    )
+    
+    if event.client.me.bot:
+        await msg.edit(header)
+        response = ""
+        async for chunk in get_ai_response("gemini", prompt, api_key, stream=True):
+            response += chunk
+            try:
+                await msg.edit(header + response)
+            except Exception:
+                pass
+    else:
+        response = ""
+        async for chunk in get_ai_response("gemini", prompt, api_key, stream=True):
+            response += chunk
+        try:
+                await msg.edit(header + response)
+        except Exception:
+                pass
+
+@ultroid_cmd(pattern="antr( (.*)|$)")
+async def anthropic_ai(event):
+    """Use Anthropic Claude"""
+    prompt = event.pattern_match.group(1).strip()
+    if not prompt:
+        return await event.eor("❌ Please provide a prompt!")
+
+    api_key = udB.get_key("ANTHROPIC_KEY")
+    if not api_key:
+        return await event.eor("⚠️ Please set Anthropic API key using `setdb ANTHROPIC_KEY your_api_key`")
+
+    msg = await event.eor("🤔 Thinking...")
+    model = get_model("antr")
+    
+    formatted_response = (
+        "🧠 **Anthropic Claude**\n"
+        f"**Model:** `{model}`\n"
+        "➖➖➖➖➖➖➖➖➖➖\n\n"
+        f"**🔍 Prompt:**\n{prompt}\n\n"
+        f"**💡 Response:**\n"
+    )
+    
+    if event.client.me.bot:
+        await msg.edit(formatted_response)
+        response = ""
+        async for chunk in get_ai_response("antr", prompt, api_key, stream=True):
+            response += chunk
+            try:
+                await msg.edit(formatted_response + response)
+            except Exception:
+                pass
+    else:
+        response = ""
+        async for chunk in get_ai_response("antr", prompt, api_key, stream=True):
+            response += chunk
+        try:
+            await msg.edit(formatted_response + response)
+        except Exception:
+            pass
+
+@ultroid_cmd(pattern="gpt( (.*)|$)")
+async def openai_ai(event):
+    """Use OpenAI GPT"""
+    prompt = event.pattern_match.group(1).strip()
+    if not prompt:
+        return await event.eor("❌ Please provide a prompt!")
+
+    api_key = udB.get_key("OPENAI_API_KEY")
+    if not api_key:
+        return await event.eor("⚠️ Please set GPT API key using `setdb OPENAI_API_KEY your_api_key`")
+
+    msg = await event.eor("🤔 Thinking...")
+    model = get_model("gpt")
+    
+    header = (
+        "🌟 **OpenAI GPT**\n"
+        f"**Model:** `{model}`\n"
+        "➖➖➖➖➖➖➖➖➖➖\n\n"
+        f"**🔍 Prompt:**\n{prompt}\n\n"
+        "**💡 Response:**\n"
+    )
+    
+    if event.client.me.bot:
+        await msg.edit(header)
+        response = ""
+        async for chunk in get_ai_response("gpt", prompt, api_key, stream=True):
+            response += chunk
+            try:
+                await msg.edit(header + response)
+            except Exception:
+                pass
+    else:
+        response =""
+        async for chunk in get_ai_response("gpt", prompt, api_key, stream=True):
+            response += chunk
+        try:
+            await msg.edit(header + response)
+        except Exception:
+            pass
+
+@ultroid_cmd(pattern="deepseek( (.*)|$)")
+async def deepseek_ai(event):
+    """Use DeepSeek AI"""
+    prompt = event.pattern_match.group(1).strip()
+    if not prompt:
+        return await event.eor("❌ Please provide a prompt!")
+
+    api_key = udB.get_key("DEEPSEEK_API_KEY")
+    if not api_key:
+        return await event.eor("⚠️ Please set DeepSeek API key using `setdb DEEPSEEK_API_KEY your_api_key`")
+
+    msg = await event.eor("🤔 Thinking...")
+    model = get_model("deepseek")
+    
+    formatted_response = (
+        "🤖 **DeepSeek AI**\n"
+        f"**Model:** `{model}`\n"
+        "➖➖➖➖➖➖➖➖➖➖\n\n"
+        f"**🔍 Prompt:**\n{prompt}\n\n"
+        f"**💡 Response:**\n"
+    )
+    
+    if event.client.me.bot:
+        await msg.edit(formatted_response)
+        response = ""
+        async for chunk in get_ai_response("deepseek", prompt, api_key, stream=True):
+            response += chunk
+            try:
+                await msg.edit(formatted_response + response)
+            except Exception:
+                pass
+    else:
+        response = ""
+        async for chunk in get_ai_response("deepseek", prompt, api_key, stream=True):
+            response += chunk
+
+        try:
+            await msg.edit(formatted_response + response)
+        except Exception:
+            pass
+

plugins/antiflood.py

@@ -0,0 +1,121 @@
+# Ultroid - UserBot
+# Copyright (C) 2021-2025 TeamUltroid
+#
+# This file is a part of < https://github.com/TeamUltroid/Ultroid/ >
+# PLease read the GNU Affero General Public License in
+# <https://www.github.com/TeamUltroid/Ultroid/blob/main/LICENSE/>.
+
+from . import get_help
+
+__doc__ = get_help("help_antiflood")
+
+
+import re
+
+from telethon.events import NewMessage as NewMsg
+
+from pyUltroid.dB import DEVLIST
+from pyUltroid.dB.antiflood_db import get_flood, get_flood_limit, rem_flood, set_flood
+from pyUltroid.fns.admins import admin_check
+
+from . import Button, Redis, asst, callback, eod, get_string, ultroid_bot, ultroid_cmd
+
+_check_flood = {}
+
+if Redis("ANTIFLOOD"):
+
+    @ultroid_bot.on(
+        NewMsg(
+            chats=list(get_flood().keys()),
+        ),
+    )
+    async def flood_checm(event):
+        count = 1
+        chat = (await event.get_chat()).title
+        if event.chat_id in _check_flood.keys():
+            if event.sender_id == list(_check_flood[event.chat_id].keys())[0]:
+                count = _check_flood[event.chat_id][event.sender_id]
+                _check_flood[event.chat_id] = {event.sender_id: count + 1}
+            else:
+                _check_flood[event.chat_id] = {event.sender_id: count}
+        else:
+            _check_flood[event.chat_id] = {event.sender_id: count}
+        if await admin_check(event, silent=True) or getattr(event.sender, "bot", None):
+            return
+        if event.sender_id in DEVLIST:
+            return
+        if _check_flood[event.chat_id][event.sender_id] >= int(
+            get_flood_limit(event.chat_id)
+        ):
+            try:
+                name = event.sender.first_name
+                await event.client.edit_permissions(
+                    event.chat_id, event.sender_id, send_messages=False
+                )
+                del _check_flood[event.chat_id]
+                await event.reply(f"#AntiFlood\n\n{get_string('antiflood_3')}")
+                await asst.send_message(
+                    int(Redis("LOG_CHANNEL")),
+                    f"#Antiflood\n\n`Muted `[{name}](tg://user?id={event.sender_id})` in {chat}`",
+                    buttons=Button.inline(
+                        "Unmute", data=f"anti_{event.sender_id}_{event.chat_id}"
+                    ),
+                )
+            except BaseException:
+                pass
+
+
+@callback(
+    re.compile(
+        "anti_(.*)",
+    ),
+)
+async def unmuting(e):
+    ino = (e.data_match.group(1)).decode("UTF-8").split("_")
+    user = int(ino[0])
+    chat = int(ino[1])
+    user_name = (await ultroid_bot.get_entity(user)).first_name
+    chat_title = (await ultroid_bot.get_entity(chat)).title
+    await ultroid_bot.edit_permissions(chat, user, send_messages=True)
+    await e.edit(
+        f"#Antiflood\n\n`Unmuted `[{user_name}](tg://user?id={user})` in {chat_title}`"
+    )
+
+
+@ultroid_cmd(
+    pattern="setflood ?(\\d+)",
+    admins_only=True,
+)
+async def setflood(e):
+    input_ = e.pattern_match.group(1).strip()
+    if not input_:
+        return await e.eor("`What?`", time=5)
+    if not input_.isdigit():
+        return await e.eor(get_string("com_3"), time=5)
+    if m := set_flood(e.chat_id, input_):
+        return await eod(e, get_string("antiflood_4").format(input_))
+
+
+@ultroid_cmd(
+    pattern="remflood$",
+    admins_only=True,
+)
+async def remove_flood(e):
+    hmm = rem_flood(e.chat_id)
+    try:
+        del _check_flood[e.chat_id]
+    except BaseException:
+        pass
+    if hmm:
+        return await e.eor(get_string("antiflood_1"), time=5)
+    await e.eor(get_string("antiflood_2"), time=5)
+
+
+@ultroid_cmd(
+    pattern="getflood$",
+    admins_only=True,
+)
+async def getflood(e):
+    if ok := get_flood_limit(e.chat_id):
+        return await e.eor(get_string("antiflood_5").format(ok), time=5)
+    await e.eor(get_string("antiflood_2"), time=5)

plugins/asstcmd.py

@@ -0,0 +1,100 @@
+# Ultroid - UserBot
+# Copyright (C) 2021-2025 TeamUltroid
+#
+# This file is a part of < https://github.com/TeamUltroid/Ultroid/ >
+# PLease read the GNU Affero General Public License in
+# <https://www.github.com/TeamUltroid/Ultroid/blob/main/LICENSE/>.
+
+from . import get_help
+
+__doc__ = get_help("help_asstcmd")
+
+import os
+
+from pyUltroid.dB.asstcmd_db import add_cmd, cmd_reply, list_cmds, rem_cmd
+from pyUltroid.fns.tools import create_tl_btn, format_btn, get_msg_button
+from telethon import events, utils
+
+from . import asst, get_string, mediainfo, udB, ultroid_cmd, upload_file
+
+
+@ultroid_cmd(pattern="addcmd( (.*)|$)")
+async def ac(e):
+    wrd = (e.pattern_match.group(1).strip()).lower()
+    wt = await e.get_reply_message()
+    if not (wt and wrd):
+        return await e.eor(get_string("asstcmd_1"), time=5)
+    if "/" in wrd:
+        wrd = wrd.replace("/", "")
+    btn = format_btn(wt.buttons) if wt.buttons else None
+    if wt and wt.media:
+        wut = mediainfo(wt.media)
+        if wut.startswith(("pic", "gif")):
+            dl = await e.client.download_media(wt.media)
+            m = upload_file(dl)
+            os.remove(dl)
+        elif wut == "video":
+            if wt.media.document.size > 8 * 1000 * 1000:
+                return await e.eor(get_string("com_4"), time=5)
+            dl = await e.client.download_media(wt.media)
+            m = upload_file(dl)
+            os.remove(dl)
+        else:
+            m = utils.pack_bot_file_id(wt.media)
+        if wt.text:
+            txt = wt.text
+            if not btn:
+                txt, btn = get_msg_button(wt.text)
+            add_cmd(wrd, txt, m, btn)
+        else:
+            add_cmd(wrd, None, m, btn)
+    else:
+        txt = wt.text
+        if not btn:
+            txt, btn = get_msg_button(wt.text)
+        add_cmd(wrd, txt, None, btn)
+    asst.add_handler(
+        astcmds,
+        events.NewMessage(
+            func=lambda x: x.text.startswith("/") and x.text[1:] in list(list_cmds())
+        ),
+    )
+    await e.eor(get_string("asstcmd_4").format(wrd))
+
+
+@ultroid_cmd(pattern="remcmd( (.*)|$)")
+async def rc(e):
+    wrd = (e.pattern_match.group(1).strip()).lower()
+    if not wrd:
+        return await e.eor(get_string("asstcmd_2"), time=5)
+    wrd = wrd.replace("/", "")
+    rem_cmd(wrd)
+    await e.eor(get_string("asstcmd_3").format(wrd))
+
+
+@ultroid_cmd(pattern="listcmd$")
+async def lscmd(e):
+    if list_cmds():
+        ok = get_string("asstcmd_6")
+        for x in list_cmds():
+            ok += f"/{x}" + "\n"
+        return await e.eor(ok)
+    return await e.eor(get_string("asstcmd_5"))
+
+
+async def astcmds(e):
+    xx = (e.text.replace("/", "")).lower().split()[0]
+    if cmd_reply(xx):
+        msg, media, bt = cmd_reply(xx)
+        if bt:
+            bt = create_tl_btn(bt)
+        await e.reply(msg, file=media, buttons=bt)
+
+
+if udB.get_key("ASST_CMDS"):
+    asst.add_handler(
+        astcmds,
+        events.NewMessage(
+            func=lambda x: x.text.startswith("/") and x.text[1:] in list(list_cmds())
+        ),
+    )

plugins/audiotools.py

@@ -0,0 +1,163 @@
+# Ultroid - UserBot
+# Copyright (C) 2021-2025 TeamUltroid
+#
+# This file is a part of < https://github.com/TeamUltroid/Ultroid/ >
+# PLease read the GNU Affero General Public License in
+# <https://www.github.com/TeamUltroid/Ultroid/blob/main/LICENSE/>.
+
+
+import os
+import time
+from datetime import datetime as dt
+
+from pyUltroid.fns.tools import set_attributes
+
+from . import (
+    LOGS,
+    ULTConfig,
+    bash,
+    downloader,
+    eod,
+    eor,
+    genss,
+    get_help,
+    get_string,
+    humanbytes,
+    mediainfo,
+    stdr,
+    time_formatter,
+    ultroid_cmd
+)
+
+__doc__ = get_help("help_audiotools")
+
+
+@ultroid_cmd(pattern="makevoice$")
+async def vnc(e):
+    if not e.reply_to:
+        return await eod(e, get_string("audiotools_1"))
+    r = await e.get_reply_message()
+    if not mediainfo(r.media).startswith(("audio", "video")):
+        return await eod(e, get_string("spcltool_1"))
+    xxx = await e.eor(get_string("com_1"))
+    file, _ = await e.client.fast_downloader(
+        r.document,
+    )
+    await xxx.edit(get_string("audiotools_2"))
+    await bash(
+        f"ffmpeg -i '{file.name}' -map 0:a -codec:a libopus -b:a 100k -vbr on out.opus"
+    )
+    try:
+        await e.client.send_message(
+            e.chat_id, file="out.opus", force_document=False, reply_to=r
+        )
+    except Exception as er:
+        LOGS.exception(er)
+        return await xxx.edit("`Failed to convert in Voice...`")
+    await xxx.delete()
+    os.remove(file.name)
+    os.remove("out.opus")
+
+
+@ultroid_cmd(pattern="atrim( (.*)|$)")
+async def trim_aud(e):
+    sec = e.pattern_match.group(1).strip()
+    if not sec or "-" not in sec:
+        return await eod(e, get_string("audiotools_3"))
+    a, b = sec.split("-")
+    if int(a) >= int(b):
+        return await eod(e, get_string("audiotools_4"))
+    vido = await e.get_reply_message()
+    if vido and vido.media and mediainfo(vido.media).startswith(("video", "audio")):
+        if hasattr(vido.media, "document"):
+            vfile = vido.media.document
+            name = vido.file.name
+        else:
+            vfile = vido.media
+            name = ""
+        if not name:
+            name = dt.now().isoformat("_", "seconds") + ".mp4"
+        xxx = await e.eor(get_string("audiotools_5"))
+        c_time = time.time()
+        file = await downloader(
+            f"resources/downloads/{name}",
+            vfile,
+            xxx,
+            c_time,
+            f"Downloading {name}...",
+        )
+
+        o_size = os.path.getsize(file.name)
+        d_time = time.time()
+        diff = time_formatter((d_time - c_time) * 1000)
+        file_name = (file.name).split("/")[-1]
+        out = file_name.replace(file_name.split(".")[-1], "_trimmed.aac")
+        if int(b) > int(await genss(file.name)):
+            os.remove(file.name)
+            return await eod(xxx, get_string("audiotools_6"))
+        ss, dd = stdr(int(a)), stdr(int(b))
+        xxx = await xxx.edit(
+            f"Downloaded `{file.name}` of `{humanbytes(o_size)}` in `{diff}`.\n\nNow Trimming Audio from `{ss}` to `{dd}`..."
+        )
+        cmd = f'ffmpeg -i "{file.name}" -preset ultrafast -ss {ss} -to {dd} -vn -acodec copy "{out}" -y'
+        await bash(cmd)
+        os.remove(file.name)
+        f_time = time.time()
+        n_file, _ = await e.client.fast_uploader(
+            out, show_progress=True, event=e, message="Uploading...", to_delete=True
+        )
+        attributes = await set_attributes(out)
+
+        caption = get_string("audiotools_7").format(ss, dd)
+        await e.client.send_file(
+            e.chat_id,
+            n_file,
+            thumb=ULTConfig.thumb,
+            caption=caption,
+            attributes=attributes,
+            force_document=False,
+            reply_to=e.reply_to_msg_id,
+        )
+        await xxx.delete()
+    else:
+        await e.eor(get_string("audiotools_1"), time=5)
+
+
+@ultroid_cmd(pattern="extractaudio$")
+async def ex_aud(e):
+    reply = await e.get_reply_message()
+    if not (reply and reply.media and mediainfo(reply.media).startswith("video")):
+        return await e.eor(get_string("audiotools_8"))
+    name = reply.file.name or "video.mp4"
+    vfile = reply.media.document
+    msg = await e.eor(get_string("com_1"))
+    c_time = time.time()
+    file = await downloader(
+        f"resources/downloads/{name}",
+        vfile,
+        msg,
+        c_time,
+        f"Downloading {name}...",
+    )
+
+    out_file = f"{file.name}.aac"
+    cmd = f"ffmpeg -i {file.name} -vn -acodec copy {out_file}"
+    o, err = await bash(cmd)
+    os.remove(file.name)
+    attributes = await set_attributes(out_file)
+
+    f_time = time.time()
+    try:
+        n_file, _ = await e.client.fast_uploader(
+            out_file, show_progress=True, event=e, message="Uploading...", to_delete=True
+        )
+
+    except FileNotFoundError:
+        return await eor(msg, get_string("audiotools_9"))
+    await e.reply(
+        get_string("audiotools_10"),
+        file=n_file,
+        thumb=ULTConfig.thumb,
+        attributes=attributes,
+    )
+    await msg.delete()