def __init__(self, **kwargs):
self._cqhttp = CQHttp(message_class=aiocqhttp.Message, **kwargs)
self._api = self._cqhttp.api
@self._cqhttp.on("message_sent")
@self._cqhttp.on_message()
@self._cqhttp.on_request()
@self._cqhttp.on_notice()
async def _on_event(event: aiocqhttp.Event):
session: CQSession = get_session(event.self_id)
if not session or not isinstance(session, CQSession):
return
logger.debug(f"[event] {event}")
# For CQ Compact:
session.handle_event_nowait(
RawCQEvent(protocol="cqhttp", event=event))
event = session.as_event(event)
if event:
session.handle_event_nowait(event)
@self._cqhttp.on_meta_event("lifecycle.connect")
async def _on_meta_event(event: aiocqhttp.Event):
session = CQSession(qq=event.self_id, cq=self._cqhttp)
register_session(session, event.self_id)
def __init__(self, name):
super().__init__(name)
self.name = name
self.logger = UMRLogging.get_logger(f'UMRDriver.{self.name}')
self.logger.debug(f'Started initialization for {self.name}')
self.loop: asyncio.AbstractEventLoop = asyncio.new_event_loop()
self.loop.set_exception_handler(self.handle_exception)
self.config: QQDriverConfig = UMRConfig.config.Driver[self.name]
self.bot = CQHttp(api_root=self.config.APIRoot,
access_token=self.config.Token,
secret=self.config.Secret)
##### initializations #####
# get group list
self.group_list: Dict[int, Dict[
int,
Dict]] = dict() # Dict[group_id, Dict[member_id, member_info]]
# see https://cqhttp.cc/docs/4.13/#/API?id=响应数据23
self.is_coolq_pro = self.config.IsPro # todo initialization on startup
self.stranger_list: Dict[int, str] = dict()
@self.bot.on_message()
async def handle_msg(context):
message_type = context.get("message_type")
chat_id = context.get(f'{message_type}_id', context.get('user_id'))
chat_type = ChatType(message_type)
self.logger.debug(f'Received message: {str(context)}')
unified_message_list = await self.dissemble_message(context)
set_ingress_message_id(src_platform=self.name,
src_chat_id=chat_id,
src_chat_type=chat_type,
src_message_id=context.get('message_id'),
user_id=context.get('user_id'))
for message in unified_message_list:
await self.receive(message)
return {}
@self.bot.on_request()
async def handle_request(context):
self.logger.debug('received request: ' + str(context))
return {}
def bots_add_qq_cqhttp_groupId(api_root=None,
access_token=None,
secret=None,
enable_http_post=False,
message_class=None,
host='127.0.0.1',
port=None,
group_id=None):
qqbot = CQHttp(api_root=api_root,
access_token=access_token,
secret=secret,
enable_http_post=enable_http_post,
message_class=message_class)
qqbot_receiver = None
def set_qqbot_receiver(on_receive):
nonlocal qqbot_receiver
qqbot_receiver = on_receive
@qqbot.on_message()
async def qq_handle_msg(context):
if context['post_type'] == 'message' and context[
'message_type'] == 'group' and context['group_id'] == group_id:
print(context)
msg = {}
msg['sender'] = context['sender']['nickname']
msg['sender_id'] = context['sender']['user_id']
msg['message'] = context['message']
qqbot_receiver(msg)
def qqbot_sendmsg(message):
asyncio.run(qqbot.send_group_msg(group_id=group_id, message=message))
bots_add(set_qqbot_receiver, qqbot_sendmsg)
def run():
from hypercorn.asyncio import serve
from hypercorn.config import Config
config = Config()
config.bind = [host + ":" + str(port)]
asyncio.run(serve(qqbot.asgi, config))
run() # 阻塞！
import requests
import json
import config
import feedparser
from src.wyy import wyy
from src.setu import setu
from src.steam import steam
from src.kaw import kaw
from src.pixiv import pixivday, pixivweek, pixivmonth, pixivmale
from src.epicfree import epicfree
from src.manongweek import manongweek
from src.searchanime import searchanime
from src.bothelp import bothelp
import re
bot = CQHttp(api_root='http://0.0.0.0:5700')
@bot.on_message('private')
async def _(event: Event):
# await bot.send(event, '你发了：')
# print(event.message)
# 搜番只支持图片格式
if event.message[0] =='番' and event.message[1] =='剧':
await searchanime(bot, event)
elif event.message == 'bot救救我':
await bothelp(bot, event)
# elif event.message == '1':
# await bot.send(event, '你发了：')
# return {'reply': event.message}
# elif event.message == '色图来！': # 色图bot
def main():
print("""==============================
_ _
| | | |
_ _ ___ | |__ ___ | |_
| | | |/ _ \| '_ \ / _ \| __|
| |_| | (_) | |_) | (_) | |_
\__, |\___/|_.__/ \___/ \__|
__/ |
|___/
==============================""")
print("正在初始化...")
if os.path.exists('yobot_config.json'):
basedir = "."
else:
basedir = "./yobot_data"
if os.path.exists(os.path.join(basedir, "yobot_config.json")):
try:
with open(os.path.join(basedir, "yobot_config.json"),
"r",
encoding="utf-8-sig") as f:
config = json.load(f)
except json.JSONDecodeError as e:
print('配置文件格式错误，请检查配置文件。三秒后关闭')
time.sleep(3)
raise e from e
token = config.get("access_token", None)
if token is None:
print("警告：没有设置access_token，这会直接暴露机器人接口")
print("详见https://yobot.win/usage/access-token/")
else:
token = None
try:
tzlocal.get_localzone()
except:
print("无法获取系统时区，请将系统时区设置为北京/上海时区")
sys.exit()
cqbot = CQHttp(access_token=token, enable_http_post=False)
sche = AsyncIOScheduler()
bot = yobot.Yobot(
data_path=basedir,
scheduler=sche,
quart_app=cqbot.server_app,
bot_api=cqbot._api,
)
host = bot.glo_setting.get("host", "0.0.0.0")
port = bot.glo_setting.get("port", 9222)
@cqbot.on_message
async def handle_msg(context):
if context["message_type"] == "group" or context[
"message_type"] == "private":
reply = await bot.proc_async(context)
else:
reply = None
if isinstance(reply, str) and reply != "":
return {'reply': reply, 'at_sender': False}
else:
return None
async def send_it(func):
if asyncio.iscoroutinefunction(func):
to_sends = await func()
else:
to_sends = func()
if to_sends is None:
return
for kwargs in to_sends:
await asyncio.sleep(5)
await cqbot.send_msg(**kwargs)
jobs = bot.active_jobs()
if jobs:
for trigger, job in jobs:
sche.add_job(func=send_it,
args=(job, ),
trigger=trigger,
coalesce=True,
max_instances=1,
misfire_grace_time=60)
sche.start()
print("初始化完成，启动服务...")
cqbot.run(
host=host,
port=port,
debug=False,
use_reloader=False,
loop=asyncio.get_event_loop(),
)
from aiocqhttp import CQHttp
import db_helper
import helper
import config
import short_url
bot = CQHttp(access_token='123', secret='abc')
def find_csdn_download_url(text):
index = text.find('https://download.csdn.net/download/')
if index != -1:
d_end = index + len('https://download.csdn.net/download/')
spindex = text[d_end:].find('/')
if spindex != -1 and len(text[d_end + spindex + 1:]) > 0:
id_len = 0
for i in range(d_end + spindex + 1, len(text)):
if '9' >= text[i] >= '0':
id_len += 1
else:
break
if id_len > 0:
return text[index:d_end + spindex + 1 + id_len]
return None
def find_csdn_download_id(text):
url = find_csdn_download_url(text)
if url is not None:
return url[url.rfind('/') + 1:]
return None
from aiocqhttp import CQHttp
import filter
bot = CQHttp(access_token='yowasaTest', enable_http_post=False)
@bot.on_message()
async def handle_msg(context):
content = context.copy()
result = filter.filter(content)
# 统一发送消息
if result != None:
await bot.send(context, result)
# @bot.on_notice('group_increase')
# async def handle_group_increase(context):
# await bot.send(context, message='欢迎新人～',
# at_sender=True, auto_escape=True)
#
#
# @bot.on_request('group', 'friend')
# async def handle_request(context):
# return {'approve': True}
bot.run(host='127.0.0.1', port=8080)
from aiocqhttp import CQHttp, ApiError, Event
bot = CQHttp(
api_root='http://127.0.0.1:5700/', # 如果使用反向 WebSocket，这里不需要传入
access_token='123', # 应与 CQHTTP 配置中一致，如果没填，这里不需要传入
secret='abc', # 应与 CQHTTP 配置中一致，如果没填，这里不需要传入
)
@bot.on_message
# 上面这句等价于 @bot.on('message')
async def handle_msg(event: Event):
try:
# await bot.send_private_msg(user_id=event.user_id,
# message='你好呀，下面一条是你刚刚发的：')
# 上下两句等价
await bot.send(event, '你好呀，下面一条是你刚刚发的：')
except ApiError:
pass
# 返回给 CQHTTP 插件，走快速回复途径
return {'reply': event.message, 'at_sender': False}
@bot.on_notice('group_increase')
# 上面这句等价于 @bot.on('notice.group_increase')
async def handle_group_increase(event: Event):
info = await bot.get_group_member_info(group_id=event.group_id,
user_id=event.user_id)
nickname = info['nickname']
name = nickname if nickname else '新人'
# log.setLevel(logging.DEBUG)
console_handler = logging.StreamHandler(stream=stdout)
console_handler.setLevel(logging.DEBUG)
console_handler.setFormatter(
logging.Formatter(
'[%(asctime)s] %(levelname)s in %(module)s: %(message)s'))
# log.addHandler(console_handler)
file_handler = logging.FileHandler(filename='log.csv')
file_handler.setLevel(logging.DEBUG)
file_handler.setFormatter(
logging.Formatter('%(asctime)s, %(levelname)s, %(name)s, %(message)s'))
log.addHandler(file_handler)
bot = CQHttp()
# 调低这个一直打log的库的等级
logging.getLogger('quart.app').setLevel(logging.ERROR)
logging.getLogger('quart.serving').setLevel(logging.ERROR)
HATE_LIST = {}
RECALL_RECORD = {}
CORPUS: List[str] = []
TRIGGER: List[str] = []
REFUSE: List[str] = []
BOOK: List[str] = []
Repeat_Monitor = {'repeating_count': 0, 'last_message': ''}
# -*- coding: utf-8 -*-
import json
import logging
import aiohttp
from aiocqhttp import CQHttp
centerURL = 'http://inter1.com/center/msg'
# 初始化日志格式
logging.basicConfig(level=logging.INFO,
format='[%(asctime)s][%(levelname)s]%(message)s',
datefmt='%Y-%m-%d %H:%M:%S')
bot = CQHttp()
@bot.on_message()
async def handle_msg(event):
if event.get('message'):
event['message'] = convert(event['message'])
# 频道消息过滤
if event.get("channel_id"):
return
async with aiohttp.ClientSession() as session:
async with session.post(centerURL, data={"context":
json.dumps(event)}) as res:
rs = await res.text()
if rs:
await bot.send(event, rs)
from aiocqhttp import CQHttp, ApiError
import aiohttp
import json
bot = CQHttp(api_root='http://127.0.0.1:5700/')
icon_map = {
"稀有": "❌",
"非凡": "⭕",
"闪耀": "🔥",
"超闪耀": "⚡",
}
@bot.on_message
async def handle_msg(context):
try:
k = 0
message = context.get('message')
print(message, context)
if not message.find("[CQ:at,qq=" + str(context["self_id"]) + "]") >= 0:
return
if message.find("十连") >= 0:
k = 10
elif message.find("单抽") >= 0:
k = 1
if k > 0:
async with aiohttp.request(
'GET', "http://127.0.0.1:8000/lottery/" +
str(context['sender']['user_id']) + "/" + str(k)) as resp:
if 200 <= resp.status < 300:
import time
import datetime
import yaml
from aiocqhttp import CQHttp
from apscheduler.schedulers.asyncio import AsyncIOScheduler
from bilibili import monitor_dynamic
from bilibili import monitor_live
from utils import process_config
cq_url = 'http://127.0.0.1:5700/'
ONE_HOUR = 3600
bot = CQHttp(api_root=cq_url)
last_time = int(time.time())
sched = AsyncIOScheduler()
live_states = dict()
async def live_repost():
global last_time
status = await monitor_live(last_time)
live_room_ids: list(int) = status['live']
if live_room_ids != []:
for room_id in live_room_ids:
if live_states.get(room_id, None) is None or int(time.time()) > live_states.get(room_id, None)+ONE_HOUR:
for group_id in room_monitor_config[room_id]['group_ids']:
""" Bot """ from aiocqhttp import CQHttp bot = CQHttp(enable_http_post=False)
from aiocqhttp.message import Message
from typing import Dict, Any, Optional
from config import BotConfig
from converter import cq_2_xhup, xhup_2_cq
logging.basicConfig(level=BotConfig.LOG_LEVEL)
"""
xhup-qq-bot 的入口
测试启动：python run.py
"""
logger = logging.getLogger("xhup-qq-bot")
bot = CQHttp(access_token=BotConfig.ACCESS_TOKEN,
message_class=Message,
enable_http_post=False)
xhup_club_ws = None
async def get_xhup_club_ws():
"""连接 xhup_club_api，不断重试直到连上为止"""
global xhup_club_ws
while True: # 如果连接失败，永远重试
connect = websockets.connect(BotConfig.XHUP_CLUB_API,
extra_headers={
"Authorization":
f"Token {BotConfig.XHUP_CLUB_TOKEN}"
})
from aiocqhttp import CQHttp
from requests_html import HTMLSession
import json
import time
bot = CQHttp(access_token='your-gdfhuighuidfg', enable_http_post=False)
session = HTMLSession()
latest_pub_date = 0
cache_life = 60 # cache有效时长（s）
_cache = {"cache_time": 0, "data": None}
def get_count(r):
dataA = r.html.find('#getStatisticsService', first=True).text
dataA = dataA[36:-11]
dataA = json.loads(dataA)
return dataA
def get_messages(r):
# dataB = r.html.find('#getTimelineServiceundefined', first=True).text
# dataB = dataB[43:-11]
# dataB = json.loads(dataB)
# return dataB
#万一报错直接改回去==
url = 'http://www.dzyong.top:3005/yiqing/news'
dataB = get(url).json().get('data')[0]
news = dataB.replace("\'", '\"')
new = json.loads(news)
#!/usr/bin/python3
# -*- coding: UTF-8 -*-
import time
from aiocqhttp import CQHttp
bot = CQHttp(api_root="http://usf.lietxia.bid:5700")
@bot.on_message()
async def handle_msg(context):
return_text = ""
if context["message"] == "你好":
return_text = "你也好"
if context["message"] == "今天":
return_text = time.asctime(time.localtime(time.time()))
return {"reply": return_text}
@bot.on_notice("group_increase")
async def handle_group_increase(context):
await bot.send(context, message="欢迎新人～", at_sender=True, auto_escape=True)
return
@bot.on_request("group", "friend")
async def handle_request(context):
return {"approve": True}
from aiocqhttp import CQHttp
import db_helper
import helper
import config
bot = CQHttp(access_token='123', secret='abc')
def find_csdn_download_url(text):
index = text.find('https://download.csdn.net/download/')
if index != -1:
d_end = index + len('https://download.csdn.net/download/')
spindex = text[d_end:].find('/')
if spindex != -1 and len(text[d_end + spindex + 1:]) > 0:
id_len = 0
for i in range(d_end + spindex + 1, len(text)):
if '9' >= text[i] >= '0':
id_len += 1
else:
break
if id_len > 0:
return text[index:d_end + spindex + 1 + id_len]
return None
last_cmd = ''
last_arg_int = 0
last_arg_str = ''
@bot.on_message
from random import random
from time import sleep
import schedule
from aiocqhttp import CQHttp, Event, Message, MessageSegment
from config import ENABLED_GROUPS, HOST, PORT # Edit config.py
logging.basicConfig(
filename="jizicibot.log",
format="%(asctime)s %(name)s %(levelname)s %(message)s",
)
logger = logging.getLogger("bot")
logger.setLevel(logging.INFO)
bot = CQHttp()
@bot.on_message("group")
async def argue(event: Event):
if event.group_id in ENABLED_GROUPS:
msg = Message(event.message).extract_plain_text()
if random() <= 0.001:
reply: Message = MessageSegment.at(
event.user_id) + MessageSegment.text("{}个头".format(msg[0]))
await bot.send(event, reply)
logger.info("怼人了！（{} -> 群号 {}）".format(str(reply), event.group_id))
async def twelve():
logger.info("十二点了！")
import datetime
import time
import requests
from aiocqhttp import CQHttp, Event
from apscheduler.schedulers.background import BackgroundScheduler
bot = CQHttp(api_root='http://127.0.0.1:5700')
url = 'http://127.0.0.1:5700'
def getgroup():
res = requests.get(url + "/get_group_list").json()
id_list = []
for item in res['data']:
id_list.append(item['group_id'])
print(id_list)
return id_list
# getgroup()
def sendgroupmsg(msg):
id_list = getgroup()
# data = {"group_id": id_list[1], "message": msg, "auto_escape": False}
# res = requests.get(url + "/send_group_msg", params=data).json()
# print(res)
for id in id_list:
data = {"group_id": id, "message": msg, "auto_escape": False}
def main():
print("""==============================
_ _
| | | |
_ _ ___ | |__ ___ | |_
| | | |/ _ \| '_ \ / _ \| __|
| |_| | (_) | |_) | (_) | |_
\__, |\___/|_.__/ \___/ \__|
__/ |
|___/
==============================""")
print("正在初始化...")
if os.path.exists("yobot_config.json"):
with open("yobot_config.json", "r") as f:
config = json.load(f)
token = config.get("access_token", None)
if token is None:
print("*************************************************")
print("警告：没有设置access_token，这会直接暴露机器人接口")
print("这意味着允许机器人执行任何人的请求，造成安全隐患")
print("请在yobot_config.json文件中修改access_token项")
print("并使其与httpapi中的access_token保持一致")
print("*************************************************")
# input("（按回车继续）")
else:
token = None
cqbot = CQHttp(access_token=token, enable_http_post=False)
sche = AsyncIOScheduler()
bot = yobot.Yobot(
data_path=".",
scheduler=sche,
quart_app=cqbot.server_app,
bot_api=cqbot._api,
)
host = bot.glo_setting.get("host", "0.0.0.0")
port = bot.glo_setting.get("port", 9222)
@cqbot.on_message
async def handle_msg(context):
if context["message_type"] == "group" or context[
"message_type"] == "private":
reply = await bot.proc_async(context)
else:
reply = None
if isinstance(reply, str) and reply != "":
return {'reply': reply, 'at_sender': False}
else:
return None
async def send_it(func):
if asyncio.iscoroutinefunction(func):
to_sends = await func()
else:
to_sends = func()
if to_sends is None:
return
tasks = [cqbot.send_msg(**kwargs) for kwargs in to_sends]
await asyncio.gather(*tasks)
jobs = bot.active_jobs()
if jobs:
for trigger, job in jobs:
sche.add_job(func=send_it,
args=(job, ),
trigger=trigger,
coalesce=True,
max_instances=1,
misfire_grace_time=60)
sche.start()
print("初始化完成，启动服务...")
cqbot.run(
host=host,
port=port,
debug=False,
use_reloader=False,
loop=asyncio.get_event_loop(),
)
from aiocqhttp import CQHttp
from configs.BotConfig import config
bot = CQHttp(api_root=config['url'], access_token=config['access_token'])
async def sendMsg(msg: str, group: str = config['qqGroup']):
if config['enable']:
await bot.send_group_msg(group_id=group, message=msg)
# -*- coding: utf-8 -*-
from aiocqhttp import CQHttp
from Meiri import User, Session, SessionType, Message
from Meiri import meiri, asyncfunction
CQBot = CQHttp(api_root='http://127.0.0.1:5700/',
access_token='AmeyaMeiri',
secret='AmeyaMeiri')
@CQBot.on_message()
async def handle_msg(context):
sender = CQUser(context['sender']['user_id'],
name=context['sender']['nickname'])
session = CQSession(context)
data = context['message']
message = Message(session, data, sender=sender)
meiri.Shell(message)
@CQBot.on_request('group', 'friend')
async def handle_request(context):
return {'approve': True}
class CQUser(User):
def __init__(self, uid, name='unknown', sex='female', age=17):
super().__init__(uid, name)
self.sex = sex
silent_ = silent.Silent()
plugins: List[base_bot.BaseBot] = [
silent_,
anquanke_vuln.AnquankeVuln(),
ctfhub.CTFHub(),
daily_push.DailyPush(),
rss.Rss(),
help_menu.HelpMenu(),
whoami.WhoAmI(),
search.SearchBot(),
lsp.LSP(),
admin.Admin(),
unknown_message.Unknown()
]
bot = CQHttp()
logger = bot.logger
counter = LimitCounter()
@bot.on_message('group')
async def reply_at(event: Event):
"""
反馈 at 消息
"""
if silent_.is_silent(event, event.message):
return
if not counter.can_send():
await bot.send(event, f'发送的太快了吧，{event.sender["nickname"]}，让我缓缓(＞﹏＜)')
return
for plugin in plugins:
from aiocqhttp import CQHttp
import aiohttp
import asyncio
import re
import random
import aioredis
import pickle
import os
import logging
import sys
import json
import time
logging.basicConfig(stream=sys.stdout)
bot = CQHttp(enable_http_post=False)
pat_iamge = re.compile('\[CQ:image,file=.+?\]')
pat_2 = re.compile('.*色图片')
pat_3 = re.compile('[\d]+?_')
class Daemon:
pass
daemon_reids = Daemon()
YOUR_QQ = 341000000 # 机器人QQ号
RANDOM_CHAT_HLIMIT = 300 # 随机回复最长间隔
RANDOM_CHAT_LLIMIT = 50 # 随机回复最短间隔
SETU_BUFFER_NUM = 200 # 色图缓存张数
TULING_KEY = "c9ebb7fe3*************************" # 图灵APIKEY
import asyncio
from defaultdict import DefaultDict
from aiocqhttp import CQHttp
from theresistance import TheResistanceCampaign
bot = CQHttp(enable_http_post=False)
group_message_handler = DefaultDict(default_group_message_handler)
private_message_handler = DefaultDict(default_private_message_handler)
campaigns = dict()
def default_group_message_handler(context):
at_me = f"[CQ:at,qq={context['self_id']}]"
message = context["message"]
group_id = context["group_id"]
user_id = context["user_id"]
# 忽略没有at机器人的消息
if at_me not in message:
return
# 忽略已经在其他群进行游戏的QQ号消息，防止无法确定私聊消息应该交给哪个游戏处理
if user_id in private_message_handler:
return {"reply": "你已经在其它群的游戏中了……"} # TODO:文字移到外部json文件中
# 预先防止群内已有游戏进行，但此代码应该不会被执行，因为后续群消息应该都交给其它message_handler处理了
if group_id in group_message_handler:
print("This line of code should not be excecuted. Please check.")
return
from loadData import LoadData
import threading
import time
# windows本机运行本脚本与coolq的配置
# HOST = '127.0.0.1'
# PORT = 7788
# 这个url是发送给docker容器里的coolq
# 举例来说，假如docker命令有这样的 -p 3542:9000 -p 15700:5700
# 9000 是coolq暴露的页面访问地址（这里映射到了外面的3542，所以外界通过3542端口访问）
# 而5700是是coolq接受数据的端口（即是这个python服务发送给coolq的数据），这里映射到了15700，
# 所以外界通过15700端口发送信息给coolq
BASEURL = 'http://127.0.0.1:15700/'
bot = CQHttp(api_root=BASEURL)
d = {
# '博客': 'https://blog.csdn.net/qq20004604',
# 'github': 'https://github.com/qq20004604',
# 'nginx': 'https://github.com/qq20004604/nginx-demo',
# 'django': 'https://github.com/qq20004604/Python3_Django_Demo',
# 'docker': 'https://github.com/qq20004604/docker-learning',
# 'webpack': 'https://github.com/qq20004604/webpack-study',
# 'react': 'https://github.com/qq20004604/react-demo',
# 'vue': 'github： https://github.com/qq20004604/vue-scaffold\n博客专栏（1.x）：https://blog.csdn.net/qq20004604/article/category/6381182',
# '笔记': 'https://github.com/qq20004604/notes',
# 'demo': 'https://github.com/qq20004604/some_demo',
# '海外服务器': 'https://manage.hostdare.com/aff.php?aff=939\n这个可以做私人服务器（不需要备案），也可以找群主询问如何架设SS server的方法。',
# 'QQ 机器人': 'https://github.com/qq20004604/qq-robot',
# '架构': 'https://juejin.im/post/5cea1f705188250640005472',
from aiocqhttp import CQHttp, ApiError
bot = CQHttp(api_root='http://127.0.0.1:5700/',
access_token='123',
secret='abc')
@bot.on_message
# 上面这句等价于 @bot.on('message')
async def handle_msg(context):
# 下面这句等价于 bot.send_private_msg(user_id=context['user_id'], message='你好呀，下面一条是你刚刚发的：')
try:
await bot.send(context, '你好呀，下面一条是你刚刚发的：')
except ApiError:
pass
return {
'reply': context['message'],
'at_sender': False
} # 返回给 HTTP API 插件，走快速回复途径
@bot.on_notice('group_increase')
# 上面这句等价于 @bot.on('notice.group_increase')
async def handle_group_increase(context):
info = await bot.get_group_member_info(group_id=context['group_id'],
user_id=context['user_id'])
nickname = info['nickname']
name = nickname if nickname else '新人'
await bot.send(context,
message='欢迎{}～'.format(name),
at_sender=True,
import asyncio
import json
import os
import sys
from aiocqhttp import CQHttp
from apscheduler.schedulers.asyncio import AsyncIOScheduler
import yobot
rcnb = CQHttp(access_token='your-token', enable_http_post=False)
bot = yobot.Yobot()
@rcnb.on_message
async def handle_msg(context):
if context["message_type"] == "group" or context[
"message_type"] == "private":
reply = bot.proc(context)
else:
reply = None
if reply != "" and reply is not None:
return {'reply': reply, 'at_sender': False}
else:
return None
async def send_it(func):
to_sends = func()
tasks = [rcnb.send_msg(**kwargs) for kwargs in to_sends]
from util import load_json, purgeMsg
from datetime import datetime, timezone, timedelta
from apscheduler.schedulers.asyncio import AsyncIOScheduler
from apscheduler.triggers.cron import CronTrigger
from queue import Queue
logging.basicConfig(
level=logging.INFO,
format=
'%(asctime)s %(filename)s[line:%(lineno)d] %(levelname)s %(message)s',
datefmt='%Y-%m-%d %H:%M:%S',
filename=os.path.join(os.path.abspath(os.path.dirname(__file__)),
'QGroupRepeater.log'),
filemode='w+')
bot = CQHttp(api_root='http://127.0.0.1:5700/')
app = bot.server_app
GroupDict = dict()
SETTINGS = load_json("settings.json")
REPLY = load_json('reply.json')
msgQueue = Queue()
@app.route('/danmu')
async def danmu():
re = []
while not msgQueue.empty():
re.append(msgQueue.get())
return jsonify(re)
from aiocqhttp import CQHttp
import emoji
# pip3 install aiocqhttp
# 说明文档 https://github.com/richardchien/python-aiocqhttp/blob/master/README.md
bot = CQHttp(enable_http_post=False)
@bot.on_message()
async def handle_msg(context):
# 判断群号，不复读个别破群
group_id = context.get('group_id')
# 判断QQ号，不复读个别幺儿
sender_qq = context.get('user_id')
if group_id in [617166836]:
return ""
if group_id in [140399496]:
return ""
# 不复读狗栀
if sender_qq in [1400525500]:
return ""
message = context['message']
# 增加对/斜眼笑等表情的处理
await bot.send(
context,
emoji.emoji2cq(message).replace('吗',
"").replace('?',
'!').replace('？', '!'))
# await bot.send(context, context['message'].replace('吗', "").replace('?', '!').replace('？', '!'))
