def init():
seconds_offset = time.localtime().tm_gmtoff
local_utc = _format_offset(seconds_offset)
if local_utc != 'UTC+8':
logger.warning('当前时区不是东8区，请修改到正确的时区后再运行本程序')
os._exit(0)
kwargs = {
'superusers': config.SUPERUSERS,
'nickname': config.NICKNAME,
'command_start': config.COMMAND_START,
'command_sep': config.COMMAND_SEP,
'debug': config.DEBUG
}
nonebot.init(**kwargs)
driver = nonebot.get_driver()
driver.register_adapter('cqhttp', CQHTTPBot)
config_ = driver.config
config_.savedata = 'data/service'
nonebot.load_builtin_plugins()
nonebot.load_plugin("nonebot_plugin_apscheduler")
nonebot.load_plugin('nonebot_plugin_rauthman')
if config.DEBUG:
nonebot.load_plugin('nonebot_plugin_docs')
nonebot.load_plugin('nonebot_plugin_test')
nonebot.load_plugins('cheru/plugin')
logger.add(error_log_file,
rotation='0:00',
format=default_format,
compression='zip',
enqueue=True,
backtrace=True,
diagnose=True,
level='ERROR')
async def _(bot: Bot, event: Event):
global mid
qid = event.get_user_id()
data = readJson()
try:
cd = event.time - data[qid][0]
except:
cd = cdTime + 1
print(cd)
key = str(event.get_message()).strip()
pic = await ghs_pic3(key)
try:
if cd > cdTime or event.get_user_id() in nonebot.get_driver(
).config.superusers:
await setu.send('给大佬递图', at_sender=True)
mid = await setu.send(message=Message(pic))
print(mid)
writeJson(qid, event.time, mid['message_id'], data)
else:
await setu.send(f'不要发的太快，冲多了对身体不好，你的CD还有{cdTime - cd}秒',
at_sender=True)
except Exception as e:
print(e)
await setu.send(message=Message('消息被风控，派蒙不背锅'), at_sender=True)
async def test_roll(
app: App,
mocker: MockerFixture,
):
"""测试点数"""
from nonebot import get_driver
from nonebot.adapters.onebot.v11 import Adapter, Bot, Message
from nonebug.mixin.call_api.fake import make_fake_adapter, make_fake_bot
from src.plugins.roll import roll_cmd
randint = mocker.patch("src.plugins.roll.roll.randint")
randint.return_value = 1
async with app.test_matcher(roll_cmd) as ctx:
adapter = make_fake_adapter(Adapter)(get_driver(), ctx)
bot = make_fake_bot(Bot)(adapter, "1")
event = fake_group_message_event(message=Message("/roll d100"))
ctx.receive_event(bot, event)
ctx.should_call_send(event, "d100=d100(1)=1", "result", at_sender=True)
ctx.should_finished()
randint.assert_called_once_with(1, 100)
async def auth(token: str):
if qq_tuple := token_manager.get_user(token):
qq, nickname = qq_tuple
bot = nonebot.get_bot()
assert isinstance(bot, Bot)
groups = await bot.call_api("get_group_list")
if str(qq) in nonebot.get_driver().config.superusers:
jwt_obj = {
"id":
str(qq),
"groups":
list(
map(
lambda info: {
"id": info["group_id"],
"name": info["group_name"],
},
groups,
)),
}
ret_obj = {
"type": "admin",
"name": nickname,
"id": str(qq),
"token": pack_jwt(jwt_obj),
}
return {"status": 200, **ret_obj}
if admin_groups := await get_admin_groups(int(qq)):
jwt_obj = {"id": str(qq), "groups": admin_groups}
ret_obj = {
"type": "user",
"name": nickname,
"id": str(qq),
"token": pack_jwt(jwt_obj),
}
return {"status": 200, **ret_obj}
async def test_music(
app: App,
mocker: MockerFixture,
):
"""测试音乐"""
from nonebot import get_driver
from nonebot.adapters.onebot.v11 import Adapter, Bot, Message, MessageSegment
from nonebug.mixin.call_api.fake import make_fake_adapter, make_fake_bot
from src.plugins.music import music_cmd
get = mocker.patch("httpx.AsyncClient.get", side_effect=mocked_get)
async with app.test_matcher(music_cmd) as ctx:
adapter = make_fake_adapter(Adapter)(get_driver(), ctx)
bot = make_fake_bot(Bot)(adapter, "1")
event = fake_group_message_event(message=Message("/music test"))
ctx.receive_event(bot, event)
ctx.should_call_send(event, MessageSegment.music("163", 1825190456),
"result")
ctx.should_finished()
get.assert_called_once_with("http://netease:3000/search?keywords=test")
async def test_tencent(
app: App,
mocker: MockerFixture,
):
"""测试腾讯闲聊机器人"""
from nonebot import get_driver
from nonebot.adapters.onebot.v11 import Adapter, Bot, Message
from nonebug.mixin.call_api.fake import make_fake_adapter, make_fake_bot
from src.plugins.robot import robot_message
call_tencent_api = mocker.patch("src.plugins.robot.call_tencent_api")
call_tencent_api.return_value = "test"
async with app.test_matcher(robot_message) as ctx:
adapter = make_fake_adapter(Adapter)(get_driver(), ctx)
bot = make_fake_bot(Bot)(adapter, "1")
event = fake_group_message_event(message=Message("你好"), to_me=True)
ctx.receive_event(bot, event)
ctx.should_call_send(event, "test", "result")
ctx.should_finished()
call_tencent_api.assert_called_once_with("你好")
from aiohttp import request
from loguru import logger
from nonebot import get_driver
from nonebot.adapters import Event, Message, MessageTemplate
from nonebot.adapters.onebot.v11 import MessageEvent as OneBot_V11_MessageEvent
from nonebot.exception import ActionFailed
from nonebot.params import CommandArg
from nonebot.permission import Permission
from nonebot.plugin import on_command
from nonebot.typing import T_State
from ujson import loads as loadJsonS
from ._permission import onFocus
config = get_driver().config
translate = on_command("翻译", aliases={"机翻"})
@translate.permission_updater
async def _(event: Event) -> Permission:
return await onFocus(event)
async def getReqSign(params: dict) -> str:
common = {
"Action": "TextTranslate",
"Region": f"{getattr(config, 'tencentcloud_common_region', 'ap-shanghai')}",
"Timestamp": int(time()),
"Nonce": randint(1, maxsize),
async def test_delete_sub(app: App):
"""测试删除订阅"""
from nonebot import get_driver
from nonebot.adapters.onebot.v11 import Adapter, Bot, Message
from nonebug.mixin.call_api.fake import make_fake_adapter, make_fake_bot
from src.web.nonebot_bison import del_sub_cmd
from src.web.nonebot_bison.config import DATA
config = get_driver().config
config.superusers = {"10"}
with DATA.open("bison.json", "w", encoding="utf8") as f:
json.dump(
{
"user_target": {
"1": {
"user":
10000,
"user_type":
"group",
"subs": [{
"target":
"https://devblogs.microsoft.com/python/feed/",
"target_type": "rss",
"target_name": "Python",
"cats": [],
"tags": [],
}],
}
}
},
f,
)
async with app.test_matcher(del_sub_cmd) as ctx:
adapter = make_fake_adapter(Adapter)(get_driver(), ctx)
bot = make_fake_bot(Bot)(adapter, "1")
event = fake_group_message_event(message=Message("/sub.delete"))
next_event = fake_group_message_event(message=Message("1"))
ctx.receive_event(bot, event)
ctx.should_call_send(
event,
Message(
"订阅的帐号为：\n1 rss Python https://devblogs.microsoft.com/python/feed/\n请输入要删除的订阅的序号"
),
"result",
)
ctx.receive_event(bot, next_event)
ctx.should_call_send(next_event, "删除成功", "result")
ctx.should_finished()
with DATA.open("bison.json", "r", encoding="utf8") as f:
data = json.load(f)
assert data["user_target"] == {
"1": {
"user": 10000,
"user_type": "group",
"subs": [],
}
}
import warnings
import nonebot
from pydantic import BaseSettings
class PlugConfig(BaseSettings):
bison_config_path: str = ""
bison_use_pic: bool = False
bison_use_local: bool = False
bison_browser: str = ""
bison_init_filter: bool = True
bison_use_queue: bool = True
class Config:
extra = "ignore"
global_config = nonebot.get_driver().config
plugin_config = PlugConfig(**global_config.dict())
import re
import cn2an
import httpx
import traceback
from io import BytesIO
from pathlib import Path
from typing import Optional, Union
from pydub import AudioSegment
from nonebot import get_driver
from nonebot.log import logger
from .config import Config
mb_config = Config.parse_obj(get_driver().config.dict())
dir_path = Path(__file__).parent / "resources"
with (dir_path / "recoder.wav").open("rb") as f:
recoder = f.read()
def split_text(text: str):
max_len = 50
words = iter(re.split(r"[？！，。、?!,\.\n]+", text))
lines = []
current = next(words)
for word in words:
if len(current) + len(word) >= max_len:
lines.append(current)
current = word
else:
current += "\n" + word
lines.append(current)
async def init():
config = nonebot.get_driver().config
config.session = aiohttp.ClientSession()
async def hpoi(max_num: int = -1):
def dfs(x) -> str:
if isinstance(x, str):
x = x.strip()
return x if x != "\n" else ""
res = ""
for i in x.contents:
res += dfs(i)
return res
thing = fp.parse(r"http://172.18.0.1:1200/hpoi/info/all")
ress = [
(
["暂时没有有用的新资讯哦！"],
(
thing["entries"][0]["title"]
if len(thing["entries"]) > 0
else "Grab Rss Error!"
),
"",
"",
)
]
t_max_num = max_num
max_num = -1
cnt = 0
for item in thing["entries"]:
if max_num != -1 and cnt >= max_num:
break
sess = nonebot.get_driver().config.session
async with sess.get(item["link"]) as resp:
if resp.status != 200:
return "Html页面获取失败！错误码：" + str(resp.status)
ShitHtml = await resp.text()
sp = BeautifulSoup(ShitHtml, "lxml")
ShitTime = sp.find_all(class_="left-item-content")
ShitAttr = sp.find(class_="table table-condensed info-box")
ShitAttr = ShitAttr.find_all("tr")
ShitPic = sp.find("a", class_="thumbnail fix-thumbnail-margin-10")["href"]
ShitPic = await getImage(sess, ShitPic)
tm = None
text = ""
for i in ShitAttr:
x = dfs(i)
if x != "" and x[0] != "外":
text += x + "\n"
text = [ShitPic, text[:-1]]
for i in ShitTime:
content = i.contents[0]
content = content.strip()
x = transtime(content, "%a %b %d %H:%M:%S %Z %Y 创建")
if isinstance(x, str):
x = transtime(content[:16], "%Y-%m-%d %H:%M")
if not isinstance(x, str):
tm = x if tm == None or tm < x else tm
ress.append(
(
text,
tm,
item["link"] if "link" in item and item["link"] != "" else "",
None,
)
)
cnt += 1
if len(ress) > 1:
ress = ress[1:]
ress.sort(key=lambda x: x[1], reverse=True)
return ress[:t_max_num]
import base64
import os
import random
from io import BytesIO
from typing import Any, Dict, List
import requests
import ujson as json
from nonebot import Driver, get_driver, logger
from nonebot.adapters.cqhttp import MessageSegment
from PIL import Image
from src.util import pic2b64
from src import R
driver: Driver = get_driver()
global_config = driver.config
RES_DIR = os.path.join(global_config.res_dir, 'img', 'gacha')
CONFIG_PATH: str
CONFIG: dict
current_game: str = ''
def draw(times: int, game_name: str) -> Dict[str, List[str]]:
"""抽卡"""
game: Dict[str, Any] = CONFIG[game_name]
cards: List[dict] = game['cards']
current_pool: str = game['current_pool']
pool: Dict[str, dict] = game['pools'][current_pool]
result = {k: [] for k in pool}
# https://github.com/Womsxd/YuanShen_User_Info
import json
import time
import string
import random
import hashlib
import sys
import requests
from httpx import AsyncClient
import nonebot
mhyVersion = "2.7.0"
cookie_list = nonebot.get_driver().config.myscookie
def cache_Cookie():
return random.choice(cookie_list)
def md5(text):
md5 = hashlib.md5()
md5.update(text.encode())
return md5.hexdigest()
def DSGet():
n = "fd3ykrh7o1j54g581upo1tvpam0dsgtf"
i = str(int(time.time()))
r = ''.join(random.sample(string.ascii_lowercase + string.digits, 6))
c = md5("salt=" + n + "&t=" + i + "&r=" + r)
return ','.join([i, r, c])
# 直播间标题放入live_title全局变量中
live_title[sub_id] = str(live_info['title'])
# 直播间up名称放入live_up_name全局变量中
live_up_name[sub_id] = str(up_name)
except Exception as e:
logger.error(
f'init_live_info: 获取直播间信息错误, room_id: {sub_id}, error: {repr(e)}'
)
continue
logger.opt(colors=True).info('init_live_info: <g>B站直播间监控列表初始化完成.</g>')
# 初始化任务加入启动序列
get_driver().on_startup(init_live_info)
# 启用检查直播间状态的定时任务
scheduler = require("nonebot_plugin_apscheduler").scheduler
# 创建用于更新数据库里面直播间UP名称的定时任务
@scheduler.scheduled_job(
'cron',
# year=None,
# month=None,
day='*/1',
# week=None,
# day_of_week=None,
# hour='*/8',
# minute='*/1',
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
import nonebot
from nonebot.adapters.cqhttp import Bot
gids = {} # 此处放入指定群聊
nonebot.init(apscheduler_autostart=True)
nonebot.init(apscheduler_config={
"apscheduler.timezone": "Asia/Shanghai"
})
app = nonebot.get_asgi()
driver = nonebot.get_driver()
driver.register_adapter("cqhttp", Bot)
nonebot.load_plugins("src/plugins")
config = nonebot.get_driver().config
config.GroupList = gids
if __name__ == "__main__":
nonebot.run(app="bot:app")
async def handle_first_receive(bot: Bot, event: Event, state: dict):
try:
if event.group_id:
group_id = event.group_id
except:
return
r = random.randint(0, 1000)
# print(float(r))
# print(float(config.randomprobability)*10)
if float(r) >= float(
nonebot.get_driver().config.dict()['randomprobability']) * 10:
return
session = str(event.user_id)
try:
if group_id in nonebot.get_driver().config.dict()['bangroup']:
return
except:
pass
try:
API_Key = nonebot.get_driver().config.dict()['baidu_api_key']
Secret_Key = nonebot.get_driver().config.dict()['baidu_secret_key']
bot_id = nonebot.get_driver().config.dict()['baidu_bot_id']
if API_Key == None or Secret_Key == None or bot_id == None:
logger.error('百度闲聊配置出错！将使用腾讯闲聊！')
app_id = nonebot.get_driver().config.dict()['tx_app_id']
appkey = nonebot.get_driver().config.dict()['tx_appkey']
if app_id == None or appkey == None:
logger.error('腾讯、百度 闲聊配置出错！请正确配置1')
return
# 腾讯
tx = txbot.TXBot(app_id=app_id, appkey=appkey, session=session)
state['TXBot'] = tx
# 百度
baidu = baiduBot.BaiduBot(API_Key=API_Key,
Secret_Key=Secret_Key,
bot_id=bot_id,
session=session)
state['BaiduBot'] = baidu
except BaseException as e:
logger.error('腾讯、百度 闲聊配置出错！请正确配置3' + str(e))
args = str(event.message).strip() # 首次发送命令时跟随的参数，例：/天气 上海，则args为上海
if args:
state["Random_bot"] = args # 如果用户发送了参数则直接赋值
msg = state["Random_bot"]
# 百度
try:
baidu = state['BaiduBot']
r_msg = await baidu.sendMsg(msg)
except:
r_msg = {}
r_msg['code'] = '-1'
if str(r_msg['code']) != '0':
# 如果出错转为调用腾讯
logger.error(r_msg)
try:
tx = state['TXBot']
r_msg = await tx.sendMsg(msg)
except:
app_id = nonebot.get_driver().config.dict()['tx_app_id']
appkey = nonebot.get_driver().config.dict()['tx_appkey']
session = str(event.user_id)
if app_id == None or appkey == None:
logger.error('腾讯、百度 闲聊配置出错！请正确配置1')
# await Random_bot.send('腾讯、百度 闲聊配置出错！请正确配置1')
return
# 腾讯
tx = txbot.TXBot(app_id=app_id, appkey=appkey, session=session)
r_msg = await tx.sendMsg(msg)
await Random_bot.send(r_msg['answer'], )
else:
await Random_bot.send(r_msg['answer'])
import random
import re
import nonebot
from nonebot import on_command
from nonebot.adapters.cqhttp import Bot, Event
from nonebot.log import logger
from nonebot.rule import to_me
from .ChatBotApi import baiduBot
from .ChatBotApi import txbot
if nonebot.get_driver().config.dict()['opendrandom']:
Random_bot = on_command('', rule=None, permission=None, priority=10)
@Random_bot.handle()
async def handle_first_receive(bot: Bot, event: Event, state: dict):
try:
if event.group_id:
group_id = event.group_id
except:
return
r = random.randint(0, 1000)
# print(float(r))
# print(float(config.randomprobability)*10)
if float(r) >= float(
nonebot.get_driver().config.dict()['randomprobability']) * 10:
return
session = str(event.user_id)
try:
if group_id in nonebot.get_driver().config.dict()['bangroup']:
async def rssBili(uid, max_num: int = -1):
thing = fp.parse(r"http://172.18.0.1:1200/bilibili/user/dynamic/" + str(uid))
ress = [
(
["暂时没有有用的新资讯哦！"],
(
thing["entries"][0]["title"]
if len(thing["entries"]) > 0
else "Grab Rss Error!"
),
"",
)
]
cnt = 0
for item in thing["entries"]:
if max_num != -1 and cnt >= max_num:
break
if (
("封禁公告" in item.summary)
or ("小讲堂" in item.summary)
or ("中奖" in item.summary)
or ("转发" in item.summary)
):
continue
fdres = re.match(r".*?<br />", item.summary, re.S)
if fdres == None:
text = item.summary
else:
text = fdres.string[int(fdres.span()[0]) : fdres.span()[1] - len("<br />")]
text = re.sub("<img alt.*>", "", text)
while len(text) > 1 and text[-1] == "\n":
text = text[:-1]
pics = re.findall(
r"https://(?:(?!https://).)*?\.(?:jpg|jpeg|png|gif|bmp|tiff|ai|cdr|eps)\"",
item.summary,
re.S,
)
text = [text]
sess = nonebot.get_driver().config.session
for i in pics:
i = i[:-1]
pic = await getImage(sess, i)
if pic != None:
text.append(pic)
ress.append(
(
text,
item["published"],
item["link"] if "link" in item and item["link"] != "" else "",
item["title"],
)
)
cnt += 1
if len(ress) > 1:
ress = ress[1:]
return ress
from nonebot.matcher import Matcher
from nonebot import get_bots
from nonebot.log import logger
from christinaqqbot.utils.reply import get_random_reply
from christinaqqbot.utils.time import get_beijing_time
from .model import setu
logger.add('log.log', retention='10 days')
setu_tags = [
'萝莉', '黑丝', '白丝', '魅魔', '吸血鬼', '白毛', 'arknights', '原神', '碧蓝航线', '百合', '红瞳',
'舰队Collection', 'JK', '巨乳'
]
setu_api = nonebot.get_driver().config.setu_api
def get_2_setu(tag='random') -> setu:
if (tag == 'random'):
tag = get_random_reply(setu_tags)
try:
api_url = setu_api + '/pixiv/search/{tag}/popular/0'.format(tag=tag)
r = requests.get(url=api_url)
r = feedparser.parse(r.text)
except Exception:
raise Exception("setu api访问错误！\r\n你的涩图炸了，你可以尝试再来一张。")
if (len(r['entries']) > 0):
result = r['entries'][random.randint(0, len(r['entries']) - 1)]
image_url = re.findall(r'["](.*?)["]', result['summary'])[0]
from nonebot.adapters.cqhttp import Message, MessageSegment, GroupMessageEvent, PrivateMessageEvent
from src.libraries.maimaidx_guess import GuessObject
from src.libraries.tool import hash
from src.libraries.maimaidx_music import *
from src.libraries.image import *
from src.libraries.maimai_best_40 import generate
from src.libraries.maimai_best_50 import generate50
import requests
import json
import random
import time
import re
from urllib import parse
driver = get_driver()
@driver.on_startup
def _():
logger.info("Load help text successfully")
help_text: dict = get_driver().config.help_text
help_text['mai'] = ('查看舞萌相关功能', """桜千雪です、よろしく。
可用命令如下：
今日舞萌 查看今天的舞萌运势
XXXmaimaiXXX什么 随机一首歌
随个[dx/标准][绿黄红紫白]<难度> 随机一首指定条件的乐曲
查歌<乐曲标题的一部分> 查询符合条件的乐曲
[绿黄红紫白]id<歌曲编号> 查询乐曲信息或谱面信息
<歌曲别名>是什么歌 查询乐曲别名对应的乐曲
定数查歌 <定数> 查询定数对应的乐曲
def daily_setu():
logger.success('daily setu进程开启！')
time.sleep(5)
daily_setu_time = nonebot.get_driver().config.daily_setu_time
while True:
try:
now_time = get_beijing_time()
send_time = datetime.datetime.strptime(
str(now_time.date()) + daily_setu_time, '%Y-%m-%d%H:%M')
prepare_time = send_time - datetime.timedelta(minutes=10)
logger.info('daily setu | 北京时间|{beijing_time}'.format(
beijing_time=str(now_time)))
# 达到时间，开始准备涩图
if (prepare_time < now_time < send_time):
try:
logger.info('达到时间，开始准备涩图')
bots = get_bots()
bot = None
for id in bots.keys():
bot = bots[id]
setu_list = get_daily_setu()
if (len(setu_list) == 0):
# 出现任何异常则跳过准备时间的十分钟
time.sleep(660)
raise Exception('今日排行版没有符合条件的涩图')
# 访问涩图排行版正确，但是没有符合条件的涩图
logger.info('成功获取每日涩图列表！')
for setu in setu_list:
setu.pic_file = save_setu(setu.url)
logger.info('成功缓存每日涩图！')
# 获得开启日常涩图功能的群号
daily_setu_group = nonebot.get_driver().config.daily_setu
while True:
try:
now_time = get_beijing_time()
logger.info('每日涩图等待发送...')
# 达到发送时间，发送
if (now_time > send_time):
for group in daily_setu_group.keys():
asyncio.run(
send_daily_setu(
daily_setu_group[group], bot,
setu_list))
logger.info('每日涩图发送完成！')
break
time.sleep(30)
except Exception as e:
pass
except Exception as e:
for group in daily_setu_group.keys():
asyncio.run(
bot.send_group_msg(
group_id=daily_setu_group[group],
message=str(e.args[0])))
logger.error(e.args[0])
finally:
for setu in setu_list:
try:
os.remove(setu.pic_file)
except Exception:
pass
logger.info('删除每日涩图成功！')
# delete pic
except Exception as e:
logger.error(e.args[0])
time.sleep(60)
async def test_reverse_driver(app: App):
import nonebot
from nonebot.exception import WebSocketClosed
from nonebot.drivers import (
URL,
Request,
Response,
WebSocket,
ReverseDriver,
HTTPServerSetup,
WebSocketServerSetup,
)
driver = cast(ReverseDriver, nonebot.get_driver())
async def _handle_http(request: Request) -> Response:
assert request.content in (b"test", "test")
return Response(200, content="test")
async def _handle_ws(ws: WebSocket) -> None:
await ws.accept()
data = await ws.receive()
assert data == "ping"
await ws.send("pong")
data = await ws.receive()
assert data == b"ping"
await ws.send(b"pong")
data = await ws.receive_text()
assert data == "ping"
await ws.send("pong")
data = await ws.receive_bytes()
assert data == b"ping"
await ws.send(b"pong")
with pytest.raises(WebSocketClosed):
await ws.receive()
http_setup = HTTPServerSetup(URL("/http_test"), "POST", "http_test",
_handle_http)
driver.setup_http_server(http_setup)
ws_setup = WebSocketServerSetup(URL("/ws_test"), "ws_test", _handle_ws)
driver.setup_websocket_server(ws_setup)
async with app.test_server() as ctx:
client = ctx.get_client()
response = await client.post("/http_test", data="test")
assert response.status_code == 200
assert response.text == "test"
async with client.websocket_connect("/ws_test") as ws:
await ws.send_text("ping")
assert await ws.receive_text() == "pong"
await ws.send_bytes(b"ping")
assert await ws.receive_bytes() == b"pong"
await ws.send_text("ping")
assert await ws.receive_text() == "pong"
await ws.send_bytes(b"ping")
assert await ws.receive_bytes() == b"pong"
await ws.close()
from nonebot import on_command, get_driver
from nonebot.adapters.cqhttp.bot import Bot
import nonebot
import asyncio
'''
广播test
'''
ban_group = nonebot.get_driver().config
async def broadcast(bot: Bot, msg, this_group = None):
list = await bot.get_group_list(self_id=bot.self_id)
for item in list:
group = item['group_id']
if group == this_group:
continue
await asyncio.sleep(0.2)
await bot.send_group_msg(group_id=group,message=msg)
from .config import ncm_config
from tinydb import TinyDB, Query
dbPath = Path("db")
musicPath = Path("music")
if not musicPath.is_dir():
Path("music").mkdir()
logger.success("音乐库创建成功")
if not dbPath.is_dir():
Path("db").mkdir()
logger.success("数据库目录创建成功")
music = TinyDB("./db/musics.json")
playlist = TinyDB("./db/playlist.json")
setting = TinyDB("./db/setting.json")
Q = Query()
cmd = list(nonebot.get_driver().config.command_start)[0]
# 白名单导入
for ids in ncm_config.whitelist:
info = setting.search(Q["group_id"] == ids)
if info:
info[0]["song"] = True
info[0]["list"] = True
setting.update(info[0], Q["group_id"] == ids)
else:
setting.insert({"group_id": ids, "song": True, "list": True})
class Ncm:
def __init__(self, bot, event):
self.api = apis
self.api.login.LoginViaCellphone(phone=ncm_config.ncm_phone,
from httpx import AsyncClient
import base64
import nonebot
from re import findall
apikey = nonebot.get_driver().config.apikey
if nonebot.get_driver().config.setuproxy == 'True':
proxy = 'i.pixiv.cat'
else:
proxy = 'disable'
async def ghs_pic3(keyword='', r18: int = 0) -> (str, str):
async with AsyncClient() as client:
req_url = "https://api.lolicon.app/setu/"
params = {
"apikey": apikey,
"r18": r18,
"size1200": 'true',
'keyword': keyword,
'proxy': proxy
}
res = await client.get(req_url, params=params)
try:
setu_title = res.json()['data'][0]['title']
setu_url = res.json()['data'][0]['url']
base64 = await down_pic(setu_url)
setu_pid = res.json()['data'][0]['pid']
setu_author = res.json()['data'][0]['author']
pic = "[CQ:image,file=base64://" + base64 + "]"
local_img_url = "title:" + setu_title + "[CQ:image,file=base64://" + base64 + "]" + "pid:" + str(
# import nonebot
import json
from nonebot import get_driver
from nonebot.plugin import on_regex
from nonebot.adapters import Bot, Event
from nonebot.typing import T_State
from .config import Config
global_config = get_driver().config
config = Config(**global_config.dict())
json_path = config.json_path
# 读取json文件内容,返回字典格式
with open(json_path, "r", encoding="utf8") as fp:
json_data = json.load(fp)
async def search(bot: Bot, event: Event, state: T_State):
global json_data
reply = ""
res = []
if state["_matched_groups"][1]:
keyword = state["_matched_groups"][1]
# logger.info(f"help search {keyword}")
# await bot.send(ev,keyword)
# print(keyword)
# return
if keyword and type(json_data) == list:
for plugin_type in json_data:
for plugin in plugin_type["plugins_list"]:
self.version.update({'version': __version__})
@classmethod
async def update_config(cls):
"""升级为 TinyDB"""
with Config() as config:
if 'status' in config.config.tables():
config.backup()
config.config.drop_tables()
for c_type, config_type in {'group': 'groups', 'private': 'users'}.items():
config.type = c_type
for type_id, type_config in config.json[config_type].items():
config.type_id = type_id
uids = type_config['uid']
for uid, sets in uids.items():
config.bot_id = config.json['uid'][uid][config_type][config.type_id]
await config.add_uid(uid)
for func, status in sets.items():
await config.set(func, uid, status)
if 'admin' in type_config and not type_config['admin']:
await config.set_permission(False)
if config.new_version():
config.backup()
config.update_version()
nonebot.get_driver().on_startup(Config.update_config)
from nonebot.adapters.cqhttp import Bot as CQHTTPBot
# Custom your logger
#
# from nonebot.log import logger, default_format
# logger.add("error.log",
# rotation="00:00",
# diagnose=False,
# level="ERROR",
# format=default_format)
# 初始化
# You can pass some keyword args config to init function
nonebot.init()
app = nonebot.get_asgi()
driver = nonebot.get_driver()
# 使用协议
driver.register_adapter("cqhttp", CQHTTPBot)
# 加载插件
nonebot.load_plugin("nonebot_plugin_biliav")
nonebot.load_builtin_plugins()
nonebot.load_from_toml("pyproject.toml")
# Modify some config / config depends on loaded configs
#
# config = driver.config
# do something...
async def handle_plugin_cooldown(matcher: Matcher, bot: Bot, event: Event,
state: T_State):
group_id = event.dict().get('group_id')
user_id = event.dict().get('user_id')
global_config = get_driver().config
superusers = global_config.superusers
# 忽略超级用户
if user_id in [int(x) for x in superusers]:
return
# 只处理message事件
if matcher.type != 'message':
return
# 处理插件冷却
# 冷却处理优先级: 全局>插件>群组>用户
# 冷却限制优先级: 用户>群组>插件>全局
plugin_name = matcher.module
plugin = get_plugin(plugin_name)
plugin_cool_down_list = plugin.export.get('cool_down')
# 只处理声明了__plugin_cool_down__的插件
if not plugin_cool_down_list:
return
# 检查用户或群组是否有skip_cd权限, 跳过冷却检查
skip_cd_auth_node = f'{plugin_name}.{PluginCoolDown.skip_auth_node}'
user_auth_res = DBAuth(auth_id=user_id,
auth_type='user',
auth_node=skip_cd_auth_node)
if user_auth_res.allow_tag().result == 1 and user_auth_res.deny_tag(
).result == 0:
return
group_auth_res = DBAuth(auth_id=group_id,
auth_type='group',
auth_node=skip_cd_auth_node)
if group_auth_res.allow_tag().result == 1 and group_auth_res.deny_tag(
).result == 0:
return
# 检查冷却情况
global_check = DBCoolDownEvent.check_global_cool_down_event()
plugin_check = DBCoolDownEvent.check_plugin_cool_down_event(
plugin=plugin_name)
group_check = DBCoolDownEvent.check_group_cool_down_event(
plugin=plugin_name, group_id=group_id)
user_check = DBCoolDownEvent.check_user_cool_down_event(plugin=plugin_name,
user_id=user_id)
# 处理全局冷却
# 先检查是否已有全局冷却
if plugin_check.result == 1 or group_check.result == 1 or user_check.result == 1:
pass
elif global_check.result == 1:
await bot.send(
event=event,
message=Message(
f'{MessageSegment.at(user_id=user_id)}命令冷却中!\n{global_check.info}'
))
raise IgnoredException('全局命令冷却中')
elif global_check.result == 0:
pass
else:
logger.error(
f'全局冷却事件异常! group: {group_id}, user: {user_id}, error: {global_check.info}'
)
# 然后再处理命令中存在的全局冷却
for time in [
x.cool_down_time for x in plugin_cool_down_list
if x.type == 'global'
]:
# 若有插件、群组或用户冷却则交由其处理
if plugin_check.result == 1 or group_check.result == 1 or user_check.result == 1:
break
res = check_and_set_global_cool_down(minutes=time)
if res.result == 1:
await bot.send(
event=event,
message=Message(
f'{MessageSegment.at(user_id=user_id)}命令冷却中!\n{res.info}'))
raise IgnoredException('全局命令冷却中')
elif res.result == 0:
pass
else:
logger.error(
f'全局冷却事件异常! group: {group_id}, user: {user_id}, error: {res.info}'
)
# 处理插件冷却
for time in [
x.cool_down_time for x in plugin_cool_down_list
if x.type == 'plugin'
]:
# 若有群组或用户冷却则交由其处理
if group_check.result == 1 or user_check.result == 1:
break
res = check_and_set_plugin_cool_down(minutes=time, plugin=plugin_name)
if res.result == 1:
await bot.send(
event=event,
message=Message(
f'{MessageSegment.at(user_id=user_id)}命令冷却中!\n{res.info}'))
raise IgnoredException('插件命令冷却中')
elif res.result == 0:
pass
else:
logger.error(
f'插件冷却事件异常! group: {group_id}, user: {user_id}, plugin: {plugin_name}, error: {res.info}'
)
# 处理群组冷却
for time in [
x.cool_down_time for x in plugin_cool_down_list
if x.type == 'group'
]:
if not group_id:
break
# 若有用户冷却则交由其处理
if user_check.result == 1:
break
res = check_and_set_group_cool_down(minutes=time,
plugin=plugin_name,
group_id=group_id)
if res.result == 1:
await bot.send(
event=event,
message=Message(
f'{MessageSegment.at(user_id=user_id)}命令冷却中!\n{res.info}'))
raise IgnoredException('群组命令冷却中')
elif res.result == 0:
pass
else:
logger.error(
f'群组冷却事件异常! group: {group_id}, user: {user_id}, plugin: {plugin_name}, error: {res.info}'
)
# 处理用户冷却
for time in [
x.cool_down_time for x in plugin_cool_down_list if x.type == 'user'
]:
if not user_id:
break
res = check_and_set_user_cool_down(minutes=time,
plugin=plugin_name,
user_id=user_id)
if res.result == 1:
await bot.send(
event=event,
message=Message(
f'{MessageSegment.at(user_id=user_id)}命令冷却中!\n{res.info}'))
raise IgnoredException('用户命令冷却中')
elif res.result == 0:
pass
else:
logger.error(
f'用户冷却事件异常! group: {group_id}, user: {user_id}, plugin: {plugin_name}, error: {res.info}'
)
