from dotenv import dotenv_values from hata import Client, wait_for_interruption from hata.ext.extension_loader import EXTENSION_LOADER config = dotenv_values('.env') Sakuya = Client( config['TOKEN'], extensions='commands_v2', prefix='!', ) @Sakuya.events async def ready(client): print(f'{client:f} is connected!') # Registered variables to extension loader, show up in each loaded extension file. EXTENSION_LOADER.add_default_variables(Sakuya=Sakuya) # Adds the extensions file or the extensions files recursive in the folder EXTENSION_LOADER.add('modules') # Loads all the added extension files. EXTENSION_LOADER.load_all() Sakuya.start() wait_for_interruption()
from hata import Client, Message, Embed import json from hata.ext.commands import setup_ext_commands from character import * from hata import KOKORO, Lock, enter_executor import cattr FILE_LOCK = Lock(KOKORO) secrets = json.load(open('secrets.json')) Faito = Client(secrets['token']) setup_ext_commands(Faito, '!') # dictionary pointing user.id -> character characters = {} # list of battles battles = [] battle_locks = [] characters_lock = Lock(KOKORO) @Faito.events async def ready(client): print(f'{client:f} logged in.') @Faito.commands async def ping(client, message): await client.message_create(message.channel, 'pong')
from hata import Client, start_clients, ClientWrapper TOKEN_1 = '' TOKEN_2 = '' TOKEN_3 = '' Sakuya = Client(TOKEN_1) Remilia = Client(TOKEN_2) Flandre = Client(TOKEN_3) # With `ClientWrapper` you can add event handler to all clients... ALL = ClientWrapper() # ...or just for specific clients. ONLY_SAKUYA_AND_REMILIA = ClientWrapper(Sakuya, Remilia) @ALL.events async def ready(client): # This event is registered for all (currently 3) clients print(f'{client:f} is connected!') @ONLY_SAKUYA_AND_REMILIA.events async def message_create(client, message): # This event is registered only to Sakuya and Remilia # When either of them see message that is '!basement' they will reply with 'nope' if message.content == '!basement': await client.message_create(message.channel, 'nope')
from hata import Client, BUILTIN_EMOJIS, DiscordException from hata.ext.commands_v2 import checks, CommandCheckError, CommandParameterParsingError from hata.ext.commands_v2.helps.subterranean import SubterraneanHelpCommand TOKEN = '' # To setup an extension for the client, just pass its name to the `Client` constructor. # # Each extension has required and optional parameters. Do not forget to pass sufficient parameters for your needs. Sakuya = Client( TOKEN, extensions='commands_v2', prefix='!', ) @Sakuya.events async def ready(client): print(f'{client:f} is connected!') # If the client is using the commands extension, you can register commands to it by using the `.commands` decorator. @Sakuya.commands async def about(): """About me.""" return 'This is a small test-bot! : )' # The above about command will be triggered when someone sends '!about' in the chat (prefix ! is because we used that # when we constructed the client above).
# # We're using `commands_v2` extension since it provides an easy API to access user voice state or the local voice client # # The example will showcase the following actions: # => Connecting to voice channel. # => Changing volume. # => Playing audio from youtube. # => Disconnecting. from hata import Client, YTAudio, DownloadError from hata.ext.commands_v2 import checks TOKEN = '' Sakuya = Client(TOKEN, extensions = 'commands_v2', prefix = '!', ) @Sakuya.events async def ready(client): print(f'{client:f} is connected!') @Sakuya.commands @checks.guild_only() async def join(ctx): """Joins to voice channel.""" # Getting the author voice state voice_state = ctx.voice_state if voice_state is None:
import os from hata import Client, start_clients, ActivityRich, ActivityTypes, Status from hata.ext.extension_loader import EXTENSION_LOADER from bot_utils.database import My_Database import config MINT = Client(token=config.MINT_TOKEN, client_id=config.MINT_ID, status=None, activity=ActivityRich("Nihongo Quest", type_=ActivityTypes.watching)) MELON = Client(token=config.MELON_TOKEN, client_id=config.MELON_ID, status="dnd", activity=ActivityRich("The Server", type_=ActivityTypes.watching)) MELON_MINT = Client(token=config.MELON_MINT_TOKEN, client_id=config.MELON_MINT_ID, status='idle', activity=ActivityRich("My Creator", type_=ActivityTypes.watching)) #Connecting to database MELON_MINT.loop.run(My_Database.setup_firebase(config.FIREBASE_CONFIG)) EXTENSION_LOADER.add_default_variables(
from hata import Client, Guild TOKEN = '' # The `slash` framework # # Your bot needs to have `applications.commands` scope in the guilds, or it's slash commands wont show up. Note, that # if you have 50 or more bots in the guild, it still wont work. Sakuya = Client(TOKEN, extensions = 'slash', ) # Using `Guild.precreate(guild_id, ...)` is a great way to get a reference to a not yet loaded entity. MY_GUILD = Guild.precreate(123456) @Sakuya.events async def ready(client): print(f'{client:f} is connected!') # Slash commands can be registered with the `.interactions` decorator if the client has slash extension setuped. # # Passing `is_global=True` will make the command global. These commands are available in each guild and in dm as well. # Global command updates are distributed after 1 hour. @Sakuya.interactions(is_global=True) async def ping(): """A ping command""" return 'pong' # `guild=...` parameter will make the command guild bound.
from hata import Client, Guild, sleep, Embed, Color, Emoji from hata.ext.slash import setup_ext_slash from dotenv import load_dotenv from random import random, choice import os, re # loading the .env file load_dotenv() Token = os.environ.get('Token') APPLICATION_ID = os.environ.get('APPLICATION_ID') GUILD = Guild.precreate(os.environ.get('GUILD_ID')) Pichu = Client(Token, application_id=APPLICATION_ID) setup_ext_slash(Pichu) # emotes CAT_FISH = Emoji.precreate(os.environ.get('CAT_FISH')) CAT_SAD = Emoji.precreate(os.environ.get('CAT_SAD')) CAT_WAY = Emoji.precreate(os.environ.get('CAT_WAY')) NEKOGIRL_KISS = Emoji.precreate(os.environ.get("NEKOGIRL_KISS")) NEKOGIRL_PEEK = Emoji.precreate(os.environ.get('NEKOGIRL_PEEK')) # colors CAT_FACT_COLOR = Color.from_html('#F6D33C') OwO_COLOR = Color.from_html('#FF69B4') NEKOGIRL_COLOR = Color.from_html('#FFB6C1') CAT_COLOR = Color.from_html('#000000') # data CAT_FACTS = [
from hata import Client, ActivityRich, ACTIVITY_TYPES from hata.ext.extension_loader import EXTENSION_LOADER from bot_utils.shared import PATH__KOISHI from bot_utils.shared import category_name_rule, DEFAULT_CATEGORY_NAME, PREFIX__MARISA, PREFIX__FLAN, PREFIX__SATORI MARISA_MODE = config.MARISA_MODE EXTENSION_LOADER.add_default_variables(MARISA_MODE=MARISA_MODE) if MARISA_MODE: Marisa = Client( config.MARISA_TOKEN, client_id=config.MARISA_ID, http_debug_options='canary', extensions=('command_utils', 'slash', 'commands_v2'), prefix=PREFIX__MARISA, default_category_name=DEFAULT_CATEGORY_NAME, category_name_rule=category_name_rule, ) EXTENSION_LOADER.add_default_variables(Marisa=Marisa, COMMAND_CLIENT=Marisa, SLASH_CLIENT=Marisa) EXTENSION_LOADER.load_extension('bots.marisa', locked=True) EXTENSION_LOADER.add('bots.testers', MAIN_CLIENT=Marisa) else: Koishi = Client(
from hata import Client, start_clients, sleep from hata.events import CommandProcesser, ContentParser from HaxLib import client, embeds import json with open('token.txt') as f: HaxBotToken = f.read().strip('\n') f.close() Gateway = Client(HaxBotToken) HaxBot = client(HaxBotToken) embeds = embeds.embeds on_command = Gateway.events(CommandProcesser('hl:')).shortcut from string import ascii_lowercase, ascii_uppercase emojis = [ '🇦', '🇧', '🇨', '🇩', '🇪', '🇫', '🇬', 'ðŸ‡', '🇮', '🇯', '🇰', '🇱', '🇲', '🇳', '🇴', '🇵', '🇶', '🇷', '🇸', '🇹', '🇺', '🇻', '🇼', '🇽', '🇾', '🇿' ]
import os from hata import Client, start_clients from hata.ext.slash import setup_ext_slash from hata.ext import asyncio as hata_asyncio # noqa from hata.ext.commands import setup_ext_commands from hata.ext.extension_loader import EXTENSION_LOADER from database_handler import DatabaseHandler braindead = Client("YOUR_TOKEN_HERE") setup_ext_commands(braindead, "!") setup_ext_slash(braindead) @braindead.events async def ready(client): print(f"{client:f} logged in.") EXTENSION_LOADER.add_default_variables(braindead=braindead) for name in os.listdir("modules"): if name.endswith(".py"): EXTENSION_LOADER.add(f"modules.{name[:-3]}") braindead.loop.run(DatabaseHandler.create_connection()) EXTENSION_LOADER.load_all() start_clients()
del (hata, flask) except: os.system( 'pip3 install https://github.com/HuyaneMatsu/hata/archive/master.zip flask' ) from flask import Flask, request import json from hata import Client, start_clients, events, Embed, enter_executor from hata.events import Pagination, ReactionAddWaitfor, ReactionDeleteWaitfor from hata.extension_loader import ExtensionLoader, ExtensionError from pdaddons.python.hata.interpreter import Interpreter token = os.environ.get('TOKEN') pdbot = Client(token) on_command = pdbot.events(events.CommandProcesser( os.environ.get('PREFIX'))).shortcut pdbot.events(ReactionAddWaitfor) pdbot.events(ReactionDeleteWaitfor) EXTENSION_LOADER = ExtensionLoader(pdbot) def add_extensions(): async def entry(client, lib): commands = getattr(lib, 'commands', None) if commands is not None: pdbot.events.message_create.shortcut.extend(commands)
import os import importlib from dotenv import load_dotenv from hata import Client, start_clients, events, Embed extensions = ("mew", "fun") load_dotenv() hata_client = Client(os.getenv("BOT_TOKEN")) on_command = hata_client.events(events.CommandProcesser("!")).shortcut for extension in extensions: module = importlib.import_module(f"extensions.{extension}") on_command.extend(module.extension) @hata_client.events class Ready: def __init__(self): self.called = False async def __call__(self, client): login_message = f" --> {client:f} ({client.id}) logged in UwU" if self.called: print(f"Reconnected {login_message}") return self.called = True await client.update_application_info() print(f"Hello {client.owner:f} {login_message}")
# -*- coding: utf-8 -*- import os import config from hata import Client, start_clients, ActivityRich, ActivityTypes from hata.ext.extension_loader import EXTENSION_LOADER from bot_utils.shared import KOISHI_PATH MARISA_MODE = config.MARISA_MODE EXTENSION_LOADER.add_default_variables(MARISA_MODE=MARISA_MODE) if MARISA_MODE: Marisa = Client( config.MARISA_TOKEN, client_id=config.MARISA_ID, ) EXTENSION_LOADER.add_default_variables(Marisa=Marisa, main_client=Marisa) EXTENSION_LOADER.load_extension('bots.marisa', locked=True) EXTENSION_LOADER.add('bots.testers.test_commands') EXTENSION_LOADER.add('bots.testers.ratelimit') EXTENSION_LOADER.add('bots.testers.dispatch_tests') else: Koishi = Client( config.KOISHI_TOKEN, secret=config.KOISHI_SECRET, client_id=config.KOISHI_ID,
from hata import Client, start_clients, User, Embed, UserBase, ChannelBase from hata.ext.commands import ( setup_extension, Converter, ConverterFlag, checks, FlaggedAnnotation, ) from cute_commands import cute_commands OWO_RP = re.compile('owo|uwu|0w0', re.I) AYY_RP = re.compile('ay+', re.I) TOKEN = '' NekoBot = Client(TOKEN) setup_extension(NekoBot, 'n!') NekoBot.commands.extend(cute_commands) @NekoBot.commands async def pat(client, message): await client.message_create(message.channel, 'Puurs !') @NekoBot.commands(name='print', alises=['say']) async def print_(client, message, content): if content: await client.message_create(message.channel, content)
from hata import Client, IntentFlag TOKEN = '' # Intents are bit flags thus bitwise operations can be used to dictate which intents are used. # By default all gateway intents are used. Sakuya = Client(TOKEN, intents=IntentFlag(0).update_by_keys(guilds=True, guild_messages=True)) @Sakuya.events async def ready(client): print(f'{client:f} is connected!') # This event will be dispatched only for guilds but not for private channels. @Sakuya.events async def message_create(client, message): print(f'Received message: {message.content!r}') # This event will never be dispatched. @Sakuya.events async def user_presence_update(client, user, old_attributes): print('Presence Update') Sakuya.start()
from hata import Client # Replace this with your bot token, see topics/getting_started.md to see how you can get one TOKEN = '' # Create your client instance by using your bot token Sakuya = Client(TOKEN) # Register event handler for message create event. When a message is received the decorated function will be called. # # Events are dispatched asynchronously so multiple events can be handled in parallel. @Sakuya.events async def message_create(client, message): if message.content == '!ping': # Sending message can fail due to network error or by lack of permissions. # # If exception is not explicitly caught it will be logged to stderr and ignored. await client.message_create(message.channel, 'pong') # Register handler for the `ready` event. Ready is called when the client shards are all booted up. @Sakuya.events async def ready(client): # Hata has various format codes for Discord entities # # In this case `f` stands for `.full_name` property. print(f'{client:f} is connected!') Sakuya.start()
import os import json import json from hata import Client, start_clients, events, Embed, enter_executor from hata.events import Pagination, ReactionAddWaitfor, ReactionDeleteWaitfor from hata.extension_loader import ExtensionLoader, ExtensionError from pdaddons.python.hata.interpreter import Interpreter token = os.environ.get('TOKEN') pdbot = Client(token) prefix = os.environ.get('PREFIX') on_command = pdbot.events(events.CommandProcesser(prefix)).shortcut del(prefix) pdbot.events(ReactionAddWaitfor) pdbot.events(ReactionDeleteWaitfor) EXTENSION_LOADER = ExtensionLoader(pdbot) def add_extensions(): async def entry(client, lib): commands=getattr(lib,'commands',None) if commands is not None: pdbot.events.message_create.shortcut.extend(commands) entry=getattr(lib,'entry',None) if entry is not None: if is_coro(entry):