async def lydia_private(_client, message):
global lydia_status, coffeehouse_api, lydia, session
if lydia_api == "":
await message.edit(
"`lydia API key is not set!\nSet your lydia API key by adding Config Vars in heroku with "
"name lydia_api with value your lydia key API`")
return
if lydia_status:
await message.edit("Turning off lydia...")
asyncio.sleep(0.5)
lydia_status = False
await message.edit("Lydia will not reply your message")
else:
await message.edit("Turning on lydia...")
try:
coffeehouse_api = API(lydia_api)
# Create Lydia instance
lydia = LydiaAI(coffeehouse_api)
# Create a new chat session (Like a conversation)
session = lydia.create_session()
except:
await message.edit("Wrong lydia API key!")
return
lydia_status = True
await message.edit("now Lydia will reply your message!")
async def lydia_disable_enable(event):
if event.fwd_from:
return
if Config.LYDIA_API is None:
await event.edit(
"please add required `LYDIA_API` env var,get it from coffeehouse.intellivoid.net"
)
return
else:
api_key = Config.LYDIA_API
api_client = API(api_key)
lydia = LydiaAI(api_client)
input_str = event.pattern_match.group(1)
if event.reply_to_msg_id is not None or input_str == "list" or event.is_private:
reply_msg = None
user_id = None
chat_id = event.chat_id
if event.is_private:
user_id = event.chat_id
if event.reply_to_msg_id is not None:
reply_msg = await event.get_reply_message()
user_id = reply_msg.from_id
await event.edit("Processing...")
if input_str == "enable":
session = lydia.create_session()
logger.info(session)
logger.info(add_s(user_id, chat_id, session.id, session.expires))
await event.edit(f"Hello there {user_id}!")
elif input_str == "disable":
logger.info(remove_s(user_id, chat_id))
await event.edit(f"No, no, no, i am out.")
elif input_str == "list":
lsts = get_all_s()
if len(lsts) > 0:
output_str = "AI enabled users:\n\n"
for lydia_ai in lsts:
output_str += f"[user](tg://user?id={lydia_ai.user_id}) in chat `{lydia_ai.chat_id}`\n"
else:
output_str = "no Lydia AI enabled users / chats. Start by replying `.enableai` to any user in any chat!"
if len(output_str) > Config.MAX_MESSAGE_SIZE_LIMIT:
with io.BytesIO(str.encode(output_str)) as out_file:
out_file.name = "lydia_ai.text"
await borg.send_file(event.chat_id,
out_file,
force_document=True,
allow_cache=False,
caption="Lydia AI enabled users",
reply_to=event)
else:
await event.edit(output_str)
else:
await event.edit(
"Reply To User Message to Add / Delete them from Lydia Auto-Chat."
)
else:
await event.edit(
"Reply To A User's Message to Add / Delete them from Lydia Auto-Chat."
)
async def lydia_disable_enable(event):
if event.fwd_from:
return
if ENV.LYDIA_API is None:
await event.edit("Please add required `LYDIA_API` enviroment variable."
)
return
else:
api_key = ENV.LYDIA_API
api_client = API(api_key)
lydia = LydiaAI(api_client)
input_str = event.pattern_match.group(1)
if event.reply_to_msg_id is not None or input_str == "list" or event.is_private:
reply_msg = None
user_id = None
chat_id = event.chat_id
if event.is_private:
user_id = event.chat_id
if event.reply_to_msg_id is not None:
reply_msg = await event.get_reply_message()
user_id = reply_msg.from_id
# await event.edit("Processing...")
if input_str == "enable":
session = lydia.create_session()
logger.info(session)
logger.info(add_s(user_id, chat_id, session.id, session.expires))
await event.edit(f"Lydia mode activated!")
elif input_str == "disable":
logger.info(remove_s(user_id, chat_id))
await event.edit(f"Lydia was yeeted by CyberDoge.")
elif input_str == "list":
lsts = get_all_s()
if len(lsts) > 0:
output_str = "AI enabled users:\n\n"
for lydia_ai in lsts:
output_str += f"[user](tg://user?id={lydia_ai.user_id}) in chat `{lydia_ai.chat_id}`\n"
else:
output_str = "No Lydia AI enabled users / chats. Start by replying `.enableai` to any user in any chat!"
if len(output_str) > ENV.MAX_MESSAGE_SIZE_LIMIT:
with io.BytesIO(str.encode(output_str)) as out_file:
out_file.name = "lydia_ai.text"
await borg.send_file(event.chat_id,
out_file,
force_document=True,
allow_cache=False,
caption="Lydia AI enabled users",
reply_to=event)
else:
await event.edit(output_str)
else:
await event.edit(
"Reply to a user's message to add / delete them from lydia ai-chat."
)
else:
await event.edit(
"Reply to a user's message to add / delete them from Lydia ai-chat."
)
from telegram.ext import (
CallbackContext,
CommandHandler,
Filters,
MessageHandler,
run_async,
)
from telegram.utils.helpers import mention_html
import ShasaBot.modules.sql.chatbot_sql as sql
from ShasaBot import AI_API_KEY, dispatcher
from ShasaBot.modules.helper_funcs.chat_status import user_admin
from ShasaBot.modules.helper_funcs.filters import CustomFilters
from ShasaBot.modules.log_channel import gloggable
CoffeeHouseAPI = API(AI_API_KEY)
api_client = LydiaAI(CoffeeHouseAPI)
@run_async
@user_admin
@gloggable
def add_chat(update: Update, context: CallbackContext):
global api_client
chat = update.effective_chat
msg = update.effective_message
user = update.effective_user
is_chat = sql.is_chat(chat.id)
if chat.type == "private":
msg.reply_text("You can't enable AI in PM.")
return
format='[%(levelname) 5s/%(asctime)s] %(name)s: %(message)s',
level=logging.WARNING)
import coffeehouse as cf
import asyncio
import io
from sql_helpers.lydia_ai_sql import get_s, get_all_s, add_s, remove_s
from time import time
from uniborg.util import admin_cmd
from sample_config import Config
from coffeehouse.lydia import LydiaAI
from coffeehouse.api import API
if Config.LYDIA_API is not None:
api_key = API(Config.LYDIA_API)
# Initialise client
api_client = LydiaAI(api_key)
@borg.on(admin_cmd(pattern="(ena|del|lst)cf", allow_sudo=True))
async def lydia_disable_enable(event):
if event.fwd_from:
return
if Config.LYDIA_API is None:
await event.edit("please add required `LYDIA_API` env var")
return
if event.reply_to_msg_id is not None:
input_str = event.pattern_match.group(1)
reply_msg = await event.get_reply_message()
user_id = reply_msg.from_id
# AI module using Intellivoid's Coffeehouse API by @TheRealPhoenix
from time import time, sleep
from coffeehouse.lydia import LydiaAI
from coffeehouse.api import API
from coffeehouse.exception import CoffeeHouseError as CFError
from telegram import Message, Chat, User, Update, Bot
from telegram.ext import CommandHandler, MessageHandler, Filters, run_async
from megumin import dispatcher, LYDIA_API, OWNER_ID
import megumin.modules.sql.lydia_sql as sql
from megumin.modules.helper_funcs.filters import CustomFilters
CoffeeHouseAPI = API(LYDIA_API)
api_client = LydiaAI(CoffeeHouseAPI)
@run_async
def add_chat(bot: Bot, update: Update):
global api_client
chat_id = update.effective_chat.id
msg = update.effective_message
is_chat = sql.is_chat(chat_id)
if not is_chat:
ses = api_client.create_session()
ses_id = str(ses.id)
expires = str(ses.expires)
sql.set_ses(chat_id, ses_id, expires)
msg.reply_text("Lydia successfully enabled for this chat!")
else:
from coffeehouse.lydia import LydiaAI
from coffeehouse.api import API
import asyncio
from telethon import events
# Non-SQL Mode
ACC_LYDIA = {}
if Var.LYDIA_API_KEY:
api_key = Var.LYDIA_API_KEY
api_client = API(api_key)
lydia = LydiaAI(api_client)
@command(pattern="^.rep", outgoing=True)
async def repcf(event):
if event.fwd_from:
return
await event.edit("Processing...")
try:
session = lydia.create_session()
session_id = session.id
reply = await event.get_reply_message()
msg = reply.text
text_rep = session.think_thought(msg)
await event.edit("**sun bsdk**: {0}".format(text_rep))
except Exception as e:
await event.edit(str(e))
@command(pattern="^.autochat", outgoing=True)
import random
import asyncio
from time import time
from coffeehouse.api import API
from coffeehouse.lydia import LydiaAI, Session
from coffeehouse.exception import CoffeeHouseError
from pyrogram.errors.exceptions.bad_request_400 import PeerIdInvalid
from userge import userge, get_collection, Message, Filters, Config, pool
LYDIA_CHATS = get_collection("LYDIA_CHATS")
CH_LYDIA_API = os.environ.get("CH_LYDIA_API", None)
CUSTOM_REPLY_CHANNEL = int(os.environ.get("CUSTOM_REPLY_CHANNEL", 0))
if CH_LYDIA_API is not None:
LYDIA = LydiaAI(API(CH_LYDIA_API))
ACTIVE_CHATS = {}
CUSTOM_REPLIES = []
QUEUE = asyncio.Queue()
LYDIA_API_INFO = """This module uses Lydia AI
Powered by CoffeeHouse API created by @Intellivoid.
Lydia is a Active Machine Learning Chat Bot.
Which can adapt to current user and chat with user
on any given topic."""
async def _init():
async for chat in LYDIA_CHATS.find({'active': True}):
import asyncio
import random
import re
from time import time
from coffeehouse.api import API
from coffeehouse.lydia import LydiaAI
from coffeehouse.exception import CoffeeHouseError as CFError
from pyrogram import filters
from nana import setbot, AdminSettings, lydia_api, Owner, BotUsername, BotID
import nana.modules.meme_strings as meme_strings
from nana.assistant.database import lydia_db as sql
CoffeeHouseAPI = API(lydia_api)
api_client = LydiaAI(CoffeeHouseAPI)
@setbot.on_message(filters.user(AdminSettings) & filters.command(["addchat"]))
async def add_chat(_client, message):
global api_client
chat_id = message.chat.id
is_chat = sql.is_chat(chat_id)
if not is_chat:
ses = api_client.create_session()
ses_id = str(ses.id)
expires = str(ses.expires)
sql.set_ses(chat_id, ses_id, expires)
await message.reply("AI successfully enabled for this chat!")
else:
await message.reply("AI is already enabled for this chat!")
import asyncio
import io
from datetime import datetime
from time import time
from coffeehouse.api import API
from coffeehouse.lydia import LydiaAI
from . import BOTLOG, BOTLOG_CHATID
from .sql_helper.lydia_ai_sql import add_s, get_all_s, get_s, remove_s
if Config.LYDIA_API_KEY:
api_key = Config.LYDIA_API_KEY
# Create the coffeehouse API
coffeehouse_api = API(api_key)
# Create Lydia instance
lydia = LydiaAI(coffeehouse_api)
@icssbot.on(admin_cmd(pattern="(en|re|li)ai$", outgoing=True))
@icssbot.on(sudo_cmd(pattern="(en|re|li)ai$", allow_sudo=True))
async def lydia_disable_enable(event):
if event.fwd_from:
return
if Config.LYDIA_API_KEY is None:
await edit_delete(event, "`Please add required LYDIA_API_KEY env var`",
10)
return
catevent = await edit_or_reply(event, "`.....`")
input_str = event.pattern_match.group(1)
from time import time
from pyrogram import filters
from pyrogram.types import InlineKeyboardButton, InlineKeyboardMarkup
from coffeehouse.lydia import LydiaAI
from coffeehouse.api import API
from coffeehouse.exception import CoffeeHouseError as CFError
from IkarosChatBot import app, LOGGER, CF_API_KEY, NAME
import IkarosChatBot.bot.database.IkarosChatBot_db as db
CoffeeHouseAPI = API(CF_API_KEY)
api_client = LydiaAI(CoffeeHouseAPI)
prvt_message = '''
Ikaros - v0.1\n Using Coffeehouse AI from @Intellivoid\n Click /help to know more :D
'''
grp_message = '''
Hy SweetHeart, I'm Ikaros
'''
@app.on_message(filters.command(["start"], prefixes=["/", "!"]))
async def start(client, message):
self = await app.get_me()
busername = self.username
if message.chat.type != "private":
await message.reply_text(grp_message)
return
else:
buttons = [[
Userbot module to use an AI To respond to people
"""
import asyncio
from coffeehouse.lydia import LydiaAI
from coffeehouse.api import API
from userbot import LYDIA_API_KEY
from userbot import CMD_HELP
from userbot.events import register
# Non-SQL Mode
ACC_LYDIA = {}
SESSION_ID = {}
if LYDIA_API_KEY:
lydiaAI = LydiaAI(API(LYDIA_API_KEY))
@register(outgoing=True, pattern="^.repcf$")
async def repcf(event):
if event.fwd_from:
return
await event.edit("Processing...")
try:
session = lydiaAI.create_session()
reply = await event.get_reply_message()
msg = reply.text
text_rep = session.think_thought(msg)
await event.edit("**Lydia says**: {0}".format(text_rep))
except Exception as e:
await event.edit(str(e))
import SaitamaRobot.modules.sql.chatbot_sql as sql
from coffeehouse.api import API
from coffeehouse.exception import CoffeeHouseError as CFError
from coffeehouse.lydia import LydiaAI
from SaitamaRobot import OWNER_ID, SUPPORT_CHAT, dispatcher
from SaitamaRobot.modules.helper_funcs.chat_status import user_admin
from SaitamaRobot.modules.helper_funcs.filters import CustomFilters
from SaitamaRobot.modules.log_channel import gloggable
from telegram import Update
from telegram.error import BadRequest, RetryAfter, Unauthorized
from telegram.ext import (CallbackContext, CommandHandler, Filters,
MessageHandler, run_async)
from telegram.utils.helpers import mention_html
CoffeeHouseAPI = API(
"eacca6deb468967c6fc4ff1354f5627ea2b953df825412e4c18a92f7fa4e04d2f8f405f848f561b5bc4c718b21953c6c1748fd2b50b3a477bca4d36c1a2fc38b"
)
api_client = LydiaAI(CoffeeHouseAPI)
@run_async
@user_admin
@gloggable
def add_chat(update: Update, context: CallbackContext):
global api_client
chat = update.effective_chat
msg = update.effective_message
user = update.effective_user
is_chat = sql.is_chat(chat.id)
if not is_chat:
ses = api_client.create_session()
import emilia.modules.sql.chatbot_sql as sql
from coffeehouse.api import API
from coffeehouse.exception import CoffeeHouseError as CFError
from coffeehouse.lydia import LydiaAI
from emilia import OWNER_ID, dispatcher
from emilia.modules.helper_funcs.chat_status import user_admin
from emilia.modules.helper_funcs.filters import CustomFilters
from telegram import Update
from telegram.error import BadRequest, RetryAfter, Unauthorized
from telegram.ext import (CallbackContext, CommandHandler, Filters,
MessageHandler, run_async)
from telegram.utils.helpers import mention_html
CoffeeHouseAPI = API(
'8b2ed2581a4b0edb99bdf1b9eb2a72872c6715953bdc0c177b73d9d7df1bcd36bcf3695862fc1e385e78c9073551faa135cb5e81ea7f95950c1513c00a1eb0f5'
)
api_client = LydiaAI(CoffeeHouseAPI)
@run_async
@user_admin
def add_chat(update: Update, context: CallbackContext):
global api_client
chat = update.effective_chat
msg = update.effective_message
user = update.effective_user
is_chat = sql.is_chat(chat.id)
if not is_chat:
ses = api_client.create_session()
ses_id = str(ses.id)
