id
int64 0
190k
| prompt
stringlengths 21
13.4M
| docstring
stringlengths 1
12k
⌀ |
|---|---|---|
188,026 | import os
import os.path
import math
import torch
import torch.utils.data
import numpy as np
import librosa
from librosa.filters import mel as librosa_mel_fn
import torch.nn.functional as F
The provided code snippet includes necessary dependencies for implementing the `pitch_shifting` function. Write a Python function `def pitch_shifting(data, sampling_rate=48000, factor=5)` to solve the following problem:
shift the audio pitch.
Here is the function:
def pitch_shifting(data, sampling_rate=48000, factor=5):
''' shift the audio pitch.
'''
# Permissible factor values = -5 <= x <= 5
pitch_factor = np.random.rand(1) * 2 * factor - factor
return librosa.effects.pitch_shift(data, sampling_rate, pitch_factor) | shift the audio pitch. |
188,027 | import os
import os.path
import math
import torch
import torch.utils.data
import numpy as np
import librosa
from librosa.filters import mel as librosa_mel_fn
import torch.nn.functional as F
The provided code snippet includes necessary dependencies for implementing the `speed_change` function. Write a Python function `def speed_change(data, landmark=None)` to solve the following problem:
change the speed of input audio. Note that we return the speed_rate to change the speed of landmarks or videos. Args: data: [n,] audio clip landmark: [m, pts, 2] aligned landmarks with audio if existed.
Here is the function:
def speed_change(data, landmark=None):
''' change the speed of input audio. Note that we return the speed_rate to
change the speed of landmarks or videos.
Args:
data: [n,] audio clip
landmark: [m, pts, 2] aligned landmarks with audio if existed.
'''
# Permissible factor values = 0.7 <= x <= 1.3 (higher is faster)
# resulted audio length: np.round(n/rate)
speed_rate = np.random.uniform(0.7, 1.3)
# only augment audio
if landmark == None:
return librosa.effects.time_stretch(data, speed_rate), speed_rate
else:
# n_after = np.round(data.shape[0]/speed_rate)
pass | change the speed of input audio. Note that we return the speed_rate to change the speed of landmarks or videos. Args: data: [n,] audio clip landmark: [m, pts, 2] aligned landmarks with audio if existed. |
188,028 | import os
import os.path
import math
import torch
import torch.utils.data
import numpy as np
import librosa
from librosa.filters import mel as librosa_mel_fn
import torch.nn.functional as F
def world_augment(wav, sr, op):
f0, sp, ap = pw.wav2world(wav.astype(np.float64), sr)
op = op if op is not None else np.random.randint(0,4)
if op == 0:
base_f0 = np.random.randint(100,300)
# base_f0 = np.random.randint(100, 200)
robot_like_f0 = np.ones_like(f0) * base_f0 # 100是个适当的数字
robot_like = pw.synthesize(robot_like_f0, sp, ap, sr)
out_wav = robot_like
elif op == 1:
ratio = 1 + np.random.rand()
female_like_sp = np.zeros_like(sp)
for f in range(female_like_sp.shape[1]):
female_like_sp[:, f] = sp[:, int(f/ratio)]
ratio_f = 0.65 + 1.4 * np.random.rand()
out_wav = pw.synthesize(f0*ratio_f, female_like_sp, ap, sr)
elif op == 2:
# change the current pitch here
ratio = 0.65 + 1.4 * np.random.rand()
out_wav = pw.synthesize(f0*ratio, sp, ap, sr)
elif op == 3:
# the random masking using the time axis
mask_len = np.random.randint(0,256 * 4)
mask_pos = np.random.randint(0, wav.shape[0] - mask_len + 1)
out_wav = np.copy(wav)
out_wav[mask_pos:mask_pos+mask_len] = 0
else:
out_wav = np.copy(wav)
return out_wav.astype(np.float32) | null |
188,029 | import os
import os.path
import math
import torch
import torch.utils.data
import numpy as np
import librosa
from librosa.filters import mel as librosa_mel_fn
import torch.nn.functional as F
def sox_augment(wav, sr, tempo_ratio=1.0, op=None):
aug_choice = op if op is not None else np.random.randint(low=1, high=8)
# tempo_ratio = 1.0
hop_length = 256
tfm = sox.Transformer()
if aug_choice == 1:
# 1 pitch aug
param = np.random.uniform(-5.0, 5.0)
tfm.pitch(param)
elif aug_choice == 2:
# 2 tempo aug, when tempo_ratio is around 1.0, no tempo aug
# tempo_ratio = np.random.uniform(0.5, 2.0)
# if tempo_ratio >= 0.9 and tempo_ratio <= 1.1:
# tempo_ratio = 1.0
# if tempo_ratio != 1.0:
# tfm.tempo(tempo_ratio, 's', quick=False)
pass
elif aug_choice == 3:
# 3 gain aug
param = np.random.uniform(-20, 5)
tfm.norm()
tfm.gain(param)
elif aug_choice == 4:
# 4 echo aug
# delays = np.random.uniform(5, 60)
# decays = np.random.uniform(0.2, 0.6)
# tfm.echo(delays=[delays], decays=[decays])
pass
elif aug_choice == 5:
# 5 reverb aug
param = np.random.uniform(0, 100, size=(4,))
tfm.reverb(param[0], param[1], param[2], param[3])
elif aug_choice == 6:
# 6 bandreject aug
param1 = np.random.randint(200, 7500)
param2 = np.random.uniform(1.0, 4.0)
tfm.bandreject(param1, param2)
elif aug_choice == 7:
# 8 equalizer aug
param1 = np.random.randint(200, 7500)
param2 = np.random.uniform(1.0, 4.0)
param3 = np.random.uniform(-20, 5)
tfm.equalizer(param1, param2, param3)
else:
raise RuntimeError('Aug choice error!')
wave_length = wav.shape[0]
if aug_choice == 1:# When using pitch augmentation, pad silence to keep audio length
wav = np.concatenate((wav, np.array([0.0]*(hop_length * 2))), axis=0)
aug_wave_data = tfm.build_array(input_array=wav, sample_rate_in=sr)
if aug_choice == 1:# Keep audio length unchanged when using pitch augmentation
aug_wave_data = aug_wave_data[:wave_length]
return aug_wave_data | null |
188,030 | import os
import os.path
import math
import torch
import torch.utils.data
import numpy as np
import librosa
from librosa.filters import mel as librosa_mel_fn
import torch.nn.functional as F
def sox_augment_v2(wav, sr, op=None):
aug_choice = op if op is not None else np.random.randint(low=1, high=5)
hop_length = 256
tfm = sox.Transformer()
if aug_choice == 1:
# 1 pitch aug
param = np.random.uniform(-5.0, 5.0)
tfm.pitch(param)
elif aug_choice == 2:
# 5 reverb aug
param = np.random.uniform(0, 100, size=(4,))
tfm.reverb(param[0], param[1], param[2], param[3])
elif aug_choice == 3:
# 6 bandreject aug
param1 = np.random.randint(200, 7500)
param2 = np.random.uniform(1.0, 4.0)
tfm.bandreject(param1, param2)
elif aug_choice == 4:
# 8 equalizer aug
param1 = np.random.randint(200, 7500)
param2 = np.random.uniform(1.0, 4.0)
param3 = np.random.uniform(-20, 5)
tfm.equalizer(param1, param2, param3)
else:
raise RuntimeError('Aug choice error!')
wave_length = wav.shape[0]
if aug_choice == 1:# When using pitch augmentation, pad silence to keep audio length
wav = np.concatenate((wav, np.array([0.0]*(hop_length * 2))), axis=0)
aug_wave_data = tfm.build_array(input_array=wav, sample_rate_in=sr)
if aug_choice == 1:# Keep audio length unchanged when using pitch augmentation
aug_wave_data = aug_wave_data[:wave_length]
return aug_wave_data | null |
188,031 | import os
import os.path
import math
import torch
import torch.utils.data
import numpy as np
import librosa
from librosa.filters import mel as librosa_mel_fn
import torch.nn.functional as F
def audio_output_augment(wav, sr, op=None):
aug_choice = op if op is not None else np.random.randint(low=1, high=4)
tfm = sox.Transformer()
if aug_choice == 1:
# 5 reverb aug
param = np.random.uniform(0, 100, size=(4,))
tfm.reverb(param[0], param[1], param[2], param[3])
elif aug_choice == 2:
# 6 bandreject aug
param1 = np.random.randint(200, 7500)
param2 = np.random.uniform(1.0, 4.0)
tfm.bandreject(param1, param2)
elif aug_choice == 3:
# 8 equalizer aug
param1 = np.random.randint(200, 7500)
param2 = np.random.uniform(1.0, 4.0)
param3 = np.random.uniform(-20, 5)
tfm.equalizer(param1, param2, param3)
else:
raise RuntimeError('Aug choice error!')
aug_wave_data = tfm.build_array(input_array=wav, sample_rate_in=sr)
return aug_wave_data | null |
188,032 | import os
import os.path
import math
import torch
import torch.utils.data
import numpy as np
import librosa
from librosa.filters import mel as librosa_mel_fn
import torch.nn.functional as F
def audio_time_augment(wav, sr, time_scale):
tfm = sox.Transformer()
tfm.tempo(time_scale, 's', quick=False)
aug_wave_data = tfm.build_array(input_array=wav, sample_rate_in=sr)
return aug_wave_data | null |
188,033 | import os
import os.path
import math
import torch
import torch.utils.data
import numpy as np
import librosa
from librosa.filters import mel as librosa_mel_fn
import torch.nn.functional as F
def prepare_noises(scp_file, root=None, sampline_rate=None, ignore_class=None):
noises = []
print('Loading augmentation noises...')
with open(scp_file,'r') as fp:
for line in fp.readlines():
line = line.rstrip('\n')
if ignore_class is not None and ignore_class in line:
continue
noise, sr = librosa.load(os.path.join(root, line), sr=sampline_rate)
noises.append(noise)
print('Augmentation noises loaded!')
return noises, sr | null |
188,034 | import os
import os.path
import math
import torch
import torch.utils.data
import numpy as np
import librosa
from librosa.filters import mel as librosa_mel_fn
import torch.nn.functional as F
def add_gauss_noise(wav, noise_std=0.03, max_wav_value=1.0):
if isinstance(wav, np.ndarray):
wav = torch.tensor(wav.copy())
real_std = np.random.random() * noise_std
wav_new = wav.float() / max_wav_value + torch.randn(wav.size()) * real_std
wav_new = wav_new * max_wav_value
wav_new = wav_new.clamp_(-max_wav_value, max_wav_value)
return wav_new.float().numpy()
def add_background_noise(wav, noises, min_snr=2, max_snr=15):
def mix_noise(wav, noise, scale):
x = wav + scale * noise
x = x.clip(-1, 1)
return x
def voice_energy(wav):
wav_float = np.copy(wav)
return np.sum(wav_float ** 2) / (wav_float.shape[0] + 1e-5)
def voice_energy_ratio(wav, noise, target_snr):
wav_eng = voice_energy(wav)
noise_eng = voice_energy(noise)
target_noise_eng = wav_eng / (10 ** (target_snr / 10.0))
ratio = target_noise_eng / (noise_eng + 1e-5)
return ratio
total_id = len(noises)
# 0 is no need to generate the noise
idx = np.random.choice(range(0, total_id))
noise_wav = noises[idx]
if noise_wav.shape[0] > wav.shape[0]:
sel_range_id = np.random.choice(range(0, noise_wav.shape[0] - wav.shape[0]))
n = noise_wav[sel_range_id:sel_range_id + wav.shape[0]]
else:
n = np.zeros(wav.shape[0])
sel_range_id = np.random.choice(range(0, wav.shape[0] - noise_wav.shape[0] + 1))
n[sel_range_id:sel_range_id + noise_wav.shape[0]] = noise_wav
#
target_snr = np.random.random() * (max_snr - min_snr) + min_snr
scale = voice_energy_ratio(wav, n, target_snr)
wav_new = mix_noise(wav, n, scale)
return wav_new
def noise_augment(wav, wav_noises, gaussian_prob=0.5):
if np.random.random() > gaussian_prob:# add gauss noise
noise_std = np.random.uniform(low=0.001, high=0.02)
aug_wave_data = add_gauss_noise(wav, noise_std=noise_std)
else:# add background noise
aug_wave_data = add_background_noise(wav, wav_noises, min_snr=2, max_snr=15)
return aug_wave_data | null |
188,035 | import torch
import torch.nn as nn
from torch.autograd import Variable
import math
import torch.nn.functional as F
from torchvision import models
The provided code snippet includes necessary dependencies for implementing the `Sample_GMM` function. Write a Python function `def Sample_GMM(gmm_params, ncenter, ndim, weight_smooth = 0.0, sigma_scale = 0.0)` to solve the following problem:
Sample values from a given a GMM distribution. Args: gmm_params: [b, target_length, (2 * ndim + 1) * ncenter], including the distribution weights, average and sigma ncenter: numbers of gaussian distribution ndim: dimension of each gaussian distribution weight_smooth: float, smooth the gaussian distribution weights sigma_scale: float, adjust the gaussian scale, larger for sharper prediction, 0 for zero sigma which always return average values Returns: current_sample: []
Here is the function:
def Sample_GMM(gmm_params, ncenter, ndim, weight_smooth = 0.0, sigma_scale = 0.0):
''' Sample values from a given a GMM distribution.
Args:
gmm_params: [b, target_length, (2 * ndim + 1) * ncenter], including the
distribution weights, average and sigma
ncenter: numbers of gaussian distribution
ndim: dimension of each gaussian distribution
weight_smooth: float, smooth the gaussian distribution weights
sigma_scale: float, adjust the gaussian scale, larger for sharper prediction,
0 for zero sigma which always return average values
Returns:
current_sample: []
'''
# reshape as [b*T, (2 * ndim + 1) * ncenter]
b, T, _ = gmm_params.shape
gmm_params_cpu = gmm_params.cpu().view(-1, (2 * ndim + 1) * ncenter)
# compute each distrubution probability
prob = nn.functional.softmax(gmm_params_cpu[:, : ncenter] * (1 + weight_smooth), dim=1)
# select the gaussian distribution according to their weights
selected_idx = torch.multinomial(prob, num_samples=1, replacement=True)
mu = gmm_params_cpu[:, ncenter : ncenter + ncenter * ndim]
# please note that we use -logsigma as output, hence here we need to take the negative
sigma = torch.exp(-gmm_params_cpu[:, ncenter + ncenter * ndim:]) * sigma_scale
# print('sigma average:', sigma.mean())
selected_sigma = torch.empty(b*T, ndim).float()
selected_mu = torch.empty(b*T, ndim).float()
current_sample = torch.randn(b*T, ndim).float()
# current_sample = test_sample
for i in range(b*T):
idx = selected_idx[i, 0]
selected_sigma[i, :] = sigma[i, idx * ndim:(idx + 1) * ndim]
selected_mu[i, :] = mu[i, idx * ndim:(idx + 1) * ndim]
# sample with sel sigma and sel mean
current_sample = current_sample * selected_sigma + selected_mu
# cur_sample = sel_mu
# return current_sample.unsqueeze(1).cuda()
if torch.cuda.is_available():
return current_sample.reshape(b, T, -1).cuda()
else:
return current_sample.reshape(b, T, -1) | Sample values from a given a GMM distribution. Args: gmm_params: [b, target_length, (2 * ndim + 1) * ncenter], including the distribution weights, average and sigma ncenter: numbers of gaussian distribution ndim: dimension of each gaussian distribution weight_smooth: float, smooth the gaussian distribution weights sigma_scale: float, adjust the gaussian scale, larger for sharper prediction, 0 for zero sigma which always return average values Returns: current_sample: [] |
188,036 | import torch
import torch.nn as nn
from torch.autograd import Variable
import math
import torch.nn.functional as F
from torchvision import models
def gram_matrix(input):
a, b, c, d = input.size() # a=batch size(=1)
# b=number of feature maps
# (c,d)=dimensions of a f. map (N=c*d)
features = input.view(a * b, c * d) # resise F_XL into \hat F_XL
G = torch.mm(features, features.t()) # compute the gram product
# we 'normalize' the values of the gram matrix
# by dividing by the number of element in each feature maps.
return G.div(a * b * c * d) | null |
188,037 | import os
import numpy as np
import torch
import torch.nn as nn
import torch.nn.functional as F
from torch.optim import lr_scheduler
from torch.nn import init
import functools
from torch.nn.parallel import DistributedDataParallel as DDP
from torch.nn.utils.rnn import pad_packed_sequence, pack_padded_sequence
def conv2d(batch_norm, in_planes, out_planes, kernel_size=3, stride=1):
if batch_norm:
return nn.Sequential(
nn.Conv2d(in_planes, out_planes, kernel_size=kernel_size, stride=stride, padding=(kernel_size-1)//2, bias=True),
nn.BatchNorm2d(out_planes),
nn.LeakyReLU(0.2, inplace=True)
)
else:
return nn.Sequential(
nn.Conv2d(in_planes, out_planes, kernel_size=kernel_size, stride=stride, padding=(kernel_size-1)//2, bias=True),
nn.LeakyReLU(0.2, inplace=True)
) | null |
188,038 | import os
import numpy as np
import torch
import torch.nn as nn
import torch.nn.functional as F
from torch.optim import lr_scheduler
from torch.nn import init
import functools
from torch.nn.parallel import DistributedDataParallel as DDP
from torch.nn.utils.rnn import pad_packed_sequence, pack_padded_sequence
def init_weights(net, init_type='normal', init_gain=0.02):
"""Initialize network weights.
Parameters:
net (network) -- network to be initialized
init_type (str) -- the name of an initialization method: normal | xavier | kaiming | orthogonal
init_gain (float) -- scaling factor for normal, xavier and orthogonal.
We use 'normal' in the original pix2pix and CycleGAN paper. But xavier and kaiming might
work better for some applications. Feel free to try yourself.
"""
def init_func(m): # define the initialization function
classname = m.__class__.__name__
if hasattr(m, 'weight') and (classname.find('Conv') != -1 or classname.find('Linear') != -1):
if init_type == 'normal':
init.normal_(m.weight.data, 0.0, init_gain)
elif init_type == 'xavier':
init.xavier_normal_(m.weight.data, gain=init_gain)
elif init_type == 'kaiming':
init.kaiming_normal_(m.weight.data, a=0, mode='fan_in')
elif init_type == 'orthogonal':
init.orthogonal_(m.weight.data, gain=init_gain)
else:
raise NotImplementedError('initialization method [%s] is not implemented' % init_type)
if hasattr(m, 'bias') and m.bias is not None:
init.constant_(m.bias.data, 0.0)
elif classname.find('BatchNorm2d') != -1: # BatchNorm Layer's weight is not a matrix; only normal distribution applies.
init.normal_(m.weight.data, 1.0, init_gain)
init.constant_(m.bias.data, 0.0)
print('initialize network with %s' % init_type)
net.apply(init_func) # apply the initialization function <init_func>
The provided code snippet includes necessary dependencies for implementing the `init_net` function. Write a Python function `def init_net(net, init_type='normal', init_gain=0.02, gpu_ids=[], useDDP=False)` to solve the following problem:
Initialize a network: 1. register CPU/GPU device (with multi-GPU support); 2. initialize the network weights Parameters: net (network) -- the network to be initialized init_type (str) -- the name of an initialization method: normal | xavier | kaiming | orthogonal gain (float) -- scaling factor for normal, xavier and orthogonal. gpu_ids (int list) -- which GPUs the network runs on: e.g., 0,1,2 Return an initialized network.
Here is the function:
def init_net(net, init_type='normal', init_gain=0.02, gpu_ids=[], useDDP=False):
"""Initialize a network: 1. register CPU/GPU device (with multi-GPU support); 2. initialize the network weights
Parameters:
net (network) -- the network to be initialized
init_type (str) -- the name of an initialization method: normal | xavier | kaiming | orthogonal
gain (float) -- scaling factor for normal, xavier and orthogonal.
gpu_ids (int list) -- which GPUs the network runs on: e.g., 0,1,2
Return an initialized network.
"""
if len(gpu_ids) > 0:
assert(torch.cuda.is_available())
net.to(gpu_ids[0])
if useDDP:
net = net().to(gpu_ids)
net = DDP(net, device_ids=gpu_ids) # DDP
print(f'use DDP to apply models on {gpu_ids}')
else:
net = torch.nn.DataParallel(net, gpu_ids) # multi-GPUs
init_weights(net, init_type, init_gain=init_gain)
return net | Initialize a network: 1. register CPU/GPU device (with multi-GPU support); 2. initialize the network weights Parameters: net (network) -- the network to be initialized init_type (str) -- the name of an initialization method: normal | xavier | kaiming | orthogonal gain (float) -- scaling factor for normal, xavier and orthogonal. gpu_ids (int list) -- which GPUs the network runs on: e.g., 0,1,2 Return an initialized network. |
188,039 | import os
import numpy as np
import torch
import torch.nn as nn
import torch.nn.functional as F
from torch.optim import lr_scheduler
from torch.nn import init
import functools
from torch.nn.parallel import DistributedDataParallel as DDP
from torch.nn.utils.rnn import pad_packed_sequence, pack_padded_sequence
The provided code snippet includes necessary dependencies for implementing the `get_scheduler` function. Write a Python function `def get_scheduler(optimizer, opt)` to solve the following problem:
Return a learning rate scheduler Parameters: optimizer -- the optimizer of the network opt (option class) -- stores all the experiment flags; needs to be a subclass of BaseOptions． opt.lr_policy is the name of learning rate policy: linear | step | plateau | cosine For 'linear', we keep the same learning rate for the first <opt.n_epochs> epochs and linearly decay the rate to zero over the next <opt.n_epochs_decay> epochs. For other schedulers (step, plateau, and cosine), we use the default PyTorch schedulers. See https://pytorch.org/docs/stable/optim.html for more details.
Here is the function:
def get_scheduler(optimizer, opt):
"""Return a learning rate scheduler
Parameters:
optimizer -- the optimizer of the network
opt (option class) -- stores all the experiment flags; needs to be a subclass of BaseOptions．
opt.lr_policy is the name of learning rate policy: linear | step | plateau | cosine
For 'linear', we keep the same learning rate for the first <opt.n_epochs> epochs
and linearly decay the rate to zero over the next <opt.n_epochs_decay> epochs.
For other schedulers (step, plateau, and cosine), we use the default PyTorch schedulers.
See https://pytorch.org/docs/stable/optim.html for more details.
"""
if opt.lr_policy == 'linear':
def lambda_rule(epoch):
lr_l = 1.0 - max(0, epoch - opt.n_epochs) / float(opt.n_epochs_decay + 1)
return lr_l
scheduler = lr_scheduler.LambdaLR(optimizer, lr_lambda=lambda_rule, last_epoch=opt.epoch_count-2)
elif opt.lr_policy == 'step':
scheduler = lr_scheduler.StepLR(optimizer, step_size=opt.lr_decay_iters, gamma=opt.gamma, last_epoch=opt.epoch_count-2)
for _ in range(opt.epoch_count-2):
scheduler.step()
elif opt.lr_policy == 'plateau':
scheduler = lr_scheduler.ReduceLROnPlateau(optimizer, mode='min', factor=0.2, threshold=0.01, patience=5)
elif opt.lr_policy == 'cosine':
scheduler = lr_scheduler.CosineAnnealingLR(optimizer, T_max=opt.n_epochs, eta_min=0)
else:
return NotImplementedError('learning rate policy [%s] is not implemented', opt.lr_policy)
return scheduler | Return a learning rate scheduler Parameters: optimizer -- the optimizer of the network opt (option class) -- stores all the experiment flags; needs to be a subclass of BaseOptions． opt.lr_policy is the name of learning rate policy: linear | step | plateau | cosine For 'linear', we keep the same learning rate for the first <opt.n_epochs> epochs and linearly decay the rate to zero over the next <opt.n_epochs_decay> epochs. For other schedulers (step, plateau, and cosine), we use the default PyTorch schedulers. See https://pytorch.org/docs/stable/optim.html for more details. |
188,040 | import os
import numpy as np
import torch
import torch.nn as nn
import torch.nn.functional as F
from torch.optim import lr_scheduler
from torch.nn import init
import functools
from torch.nn.parallel import DistributedDataParallel as DDP
from torch.nn.utils.rnn import pad_packed_sequence, pack_padded_sequence
def weights_init(m):
classname = m.__class__.__name__
if classname.find('Conv') != -1 and hasattr(m, 'weight'):
m.weight.data.normal_(0.0, 0.02)
elif classname.find('BatchNorm2d') != -1:
m.weight.data.normal_(1.0, 0.02)
m.bias.data.fill_(0) | null |
188,041 | import os
import numpy as np
import torch
import torch.nn as nn
import torch.nn.functional as F
from torch.optim import lr_scheduler
from torch.nn import init
import functools
from torch.nn.parallel import DistributedDataParallel as DDP
from torch.nn.utils.rnn import pad_packed_sequence, pack_padded_sequence
def print_network(net):
if isinstance(net, list):
net = net[0]
num_params = 0
for param in net.parameters():
num_params += param.numel()
print(net)
print('Total number of parameters: %d' % num_params) | null |
188,042 | from __future__ import print_function
import torch
import numpy as np
from PIL import Image
import inspect, re
import numpy as np
import os
import collections
from PIL import Image
import cv2
from collections import OrderedDict
from . import flow_viz
def tensor2im(image_tensor, imtype=np.uint8, normalize=True):
if isinstance(image_tensor, list):
image_numpy = []
for i in range(len(image_tensor)):
image_numpy.append(tensor2im(image_tensor[i], imtype, normalize))
return image_numpy
if isinstance(image_tensor, torch.autograd.Variable):
image_tensor = image_tensor.data
if len(image_tensor.size()) == 5:
image_tensor = image_tensor[0, -1]
if len(image_tensor.size()) == 4:
image_tensor = image_tensor[0]
image_tensor = image_tensor[:3]
image_numpy = image_tensor.cpu().float().numpy()
if normalize:
image_numpy = (np.transpose(image_numpy, (1, 2, 0)) + 1) / 2.0 * 255.0
else:
image_numpy = np.transpose(image_numpy, (1, 2, 0)) * 255.0
#image_numpy = (np.transpose(image_numpy, (1, 2, 0)) * std + mean) * 255.0
image_numpy = np.clip(image_numpy, 0, 255)
if image_numpy.shape[2] == 1:
image_numpy = image_numpy[:,:,0]
return image_numpy.astype(imtype) | null |
188,043 | from __future__ import print_function
import torch
import numpy as np
from PIL import Image
import inspect, re
import numpy as np
import os
import collections
from PIL import Image
import cv2
from collections import OrderedDict
from . import flow_viz
def tensor2flow(flo, imtype=np.uint8):
flo = flo[0].permute(1,2,0).cpu().detach().numpy()
flo = flow_viz.flow_to_image(flo)
return flo | null |
188,044 | from __future__ import print_function
import torch
import numpy as np
from PIL import Image
import inspect, re
import numpy as np
import os
import collections
from PIL import Image
import cv2
from collections import OrderedDict
from . import flow_viz
def add_dummy_to_tensor(tensors, add_size=0):
if add_size == 0 or tensors is None: return tensors
if isinstance(tensors, list):
return [add_dummy_to_tensor(tensor, add_size) for tensor in tensors]
if isinstance(tensors, torch.Tensor):
dummy = torch.zeros_like(tensors)[:add_size]
tensors = torch.cat([dummy, tensors])
return tensors | null |
188,045 | from __future__ import print_function
import torch
import numpy as np
from PIL import Image
import inspect, re
import numpy as np
import os
import collections
from PIL import Image
import cv2
from collections import OrderedDict
from . import flow_viz
def remove_dummy_from_tensor(tensors, remove_size=0):
if remove_size == 0 or tensors is None: return tensors
if isinstance(tensors, list):
return [remove_dummy_from_tensor(tensor, remove_size) for tensor in tensors]
if isinstance(tensors, torch.Tensor):
tensors = tensors[remove_size:]
return tensors | null |
188,046 | from __future__ import print_function
import torch
import numpy as np
from PIL import Image
import inspect, re
import numpy as np
import os
import collections
from PIL import Image
import cv2
from collections import OrderedDict
from . import flow_viz
def save_image(image_numpy, image_path):
image_pil = Image.fromarray(image_numpy)
image_pil.save(image_path) | null |
188,047 | from __future__ import print_function
import torch
import numpy as np
from PIL import Image
import inspect, re
import numpy as np
import os
import collections
from PIL import Image
import cv2
from collections import OrderedDict
from . import flow_viz
def print_numpy(x, val=True, shp=False):
x = x.astype(np.float64)
if shp:
print('shape,', x.shape)
if val:
x = x.flatten()
print('mean = %3.3f, min = %3.3f, max = %3.3f, median = %3.3f, std=%3.3f' % (
np.mean(x), np.min(x), np.max(x), np.median(x), np.std(x))) | null |
188,048 | from __future__ import print_function
import torch
import numpy as np
from PIL import Image
import inspect, re
import numpy as np
import os
import collections
from PIL import Image
import cv2
from collections import OrderedDict
from . import flow_viz
def mkdir(path):
def mkdirs(paths):
if isinstance(paths, list) and not isinstance(paths, str):
for path in paths:
mkdir(path)
else:
mkdir(paths) | null |
188,049 |
def sort_readme():
with open("README.md", "r", encoding="utf-8") as f:
all = f.readlines()
table_start = "|Category|Company|Description|GitHub Stars|Alternative to|\n"
table_end = "<!-- END STARTUP LIST -->\n"
idx = all.index(table_start)
idx_end = all.index(table_end)
find_name = lambda x: x[x.index("[") + 1 : x.index("]")].strip()
find_cat = lambda x: x[: x.index("|")].strip()
pairs = [(find_cat(x), find_name(x)) for x in all[idx + 2 : idx_end - 1]]
sorted_pairs = sorted(pairs)
right_elements = [all[idx + 2 : -1][pairs.index(i)] for i in sorted_pairs]
all[idx + 2 : idx_end - 1] = right_elements
with open("README.md", "w", encoding="utf-8") as f:
f.writelines(all) | null |
188,050 | import yaml
import os
from add_company import add_new_company
def parse_all_yamls():
arr = []
for filename in os.listdir("submissions"):
if filename.endswith(".yaml"):
with open(f"submissions/{filename}", "r") as file:
obj = yaml.load(file, yaml.Loader)
arr.append(obj)
return arr
def add_new_company(
category, company_name, description, link, gh_link, alts_names, alts_links
):
with open("README.md", "r", encoding="utf-8") as f:
all = f.readlines()
table_start = "|Category|Company|Description|GitHub Stars|Alternative to|\n"
table_end = "<!-- END STARTUP LIST -->\n"
idx = all.index(table_start)
idx_end = all.index(table_end)
find_name = lambda x: x[x.index("[") + 1 : x.index("]")].strip()
find_cat = lambda x: x[: x.index("|")].strip()
categories = [(find_cat(x), find_name(x)) for x in all[idx + 2 : idx_end - 1]]
search_tup = (category.strip(), company_name.strip())
insert_idx = -1
for i, tup in enumerate(reversed(categories)):
if search_tup == tup:
return "This entry already exists"
elif search_tup > tup:
print(search_tup, tup)
insert_idx = len(categories) - i
break
all.insert(
insert_idx + idx + 2,
create_new_line(
category, company_name, description, link, gh_link, alts_names, alts_links
),
)
# file_name = "_".join(company_name.split(" "))
# with open(f"submissions/{file_name}.yaml", "w") as file:
# yaml.dump(
# dict(
# category=category,
# company_name=company_name,
# description=description,
# link=link,
# gh_link=gh_link,
# alts_names=alts_names,
# alts_links=alts_links,
# ),
# file,
# default_flow_style=False,
# )
with open("README.md", "w", encoding="utf-8") as f:
f.writelines(all)
return "ok, added!"
def build_list():
arr = parse_all_yamls()
for obj in arr:
add_new_company(**obj) | null |
188,051 | import yaml
def read_readme():
with open("README.md", "r", encoding="utf-8") as f:
all = f.readlines()
table_start = "|Category|Company|Description|GitHub Stars|Alternative to|\n"
table_end = "<!-- END STARTUP LIST -->\n"
idx = all.index(table_start)
idx_end = all.index(table_end)
return all[idx + 2 : idx_end - 1] | null |
188,052 | import yaml
def parse_line(line: str):
arr = line.split("|")
category = arr[0]
name = arr[1].split("]")[0][1:]
website = arr[1].split("]")[1][1:-1]
description = arr[2]
github = arr[3].split(">")[0].split("href=")[1]
alts = list(map(lambda x: x.strip().split("]")[0][1:], arr[4].split(",")))
alts_links = list(map(lambda x: x.strip().split("](")[1][:-1], arr[4].split(",")))
return dict(
category=category,
company_name=name,
link=website,
description=description,
gh_link=github,
alts_names=alts,
alts_links=alts_links,
) | null |
188,053 |
def count_companies_in_readme():
with open('README.md', 'r', encoding='utf-8') as f:
all = f.readlines()
table_start = '|Category|Company|Description|GitHub Stars|Alternative to|\n'
idx = all.index(table_start)
return len(all[idx + 2: -1]) | null |
188,054 | import yaml
import os
appl = lambda x: SPECIAL_MAPPING[x] if x in SPECIAL_MAPPING else x
def get_all_companies():
arr = []
for filename in os.listdir("submissions"):
if filename.endswith(".yaml"):
with open(f"submissions/{filename}", "r", encoding="utf-8") as file:
obj = yaml.load(file, yaml.Loader)
obj["category"] = appl(obj["category"])
obj["company_name"] = appl(obj["company_name"])
arr.append(obj)
return arr | null |
188,055 | import yaml
import os
def get_all_categories(arr):
categories = set()
for obj in arr:
categories.add(obj["category"])
return categories | null |
188,056 | import yaml
import os
def create_website_directories(categories):
for category in categories:
if not os.path.exists(f"website/docs/{category}"):
os.mkdir(f"website/docs/{category}") | null |
188,057 | import yaml
import os
def remove_github_com(s: str):
return s.replace("https://github.com/", "")
def remove_https(s: str):
s = s.replace("https://", "")
s = s.replace("http://", "")
return s.strip("/")
markdown_template = """
# {company_name}
<a href="{link}"><img src="https://icons.duckduckgo.com/ip3/{clean_link}.ico" alt="Avatar" width="30" height="30" /></a>
[](https://GitHub.com/{clean_gh_link}/stargazers/) [](https://GitHub.com/{clean_gh_link}/network/) [](https://GitHub.com/N{clean_gh_link}/issues/)
[](https://github.com/{clean_gh_link}/blob/master/LICENSE) [](https://GitHub.com/{clean_gh_link}/graphs/contributors/)
**Category**: {category}
**Github**: [{clean_gh_link}]({gh_link})
**Website**: [{clean_link}]({link})
**Description**:
{description}
**Alternative to**: {alts}
"""
def generate_alternative_md(alts_names, alts_links):
alt_md = ""
for alt_link, alt_name in zip(alts_links, alts_names):
alt_md += f"[{alt_name}]({alt_link}), "
return alt_md.strip(", ")
def create_markdown_for_companies(companies):
for company in companies:
file_name = "-".join(company["company_name"].split(" "))
with open(
f"website/docs/{company['category']}/{file_name}.md", "w", encoding="utf-8"
) as file:
file.write(
markdown_template.format(
company_name=company["company_name"],
category=company["category"],
gh_link=company["gh_link"],
clean_gh_link=remove_github_com(company["gh_link"]),
link=company["link"],
clean_link=remove_https(company["link"]),
description=company["description"],
alts=generate_alternative_md(
company["alts_names"], company["alts_links"]
),
)
) | null |
188,058 | def add_new_company(
category, company_name, description, link, gh_link, alts_names, alts_links
):
with open("README.md", "r", encoding="utf-8") as f:
all = f.readlines()
table_start = "|Category|Company|Description|GitHub Stars|Alternative to|\n"
table_end = "<!-- END STARTUP LIST -->\n"
idx = all.index(table_start)
idx_end = all.index(table_end)
find_name = lambda x: x[x.index("[") + 1 : x.index("]")].strip()
find_cat = lambda x: x[: x.index("|")].strip()
categories = [(find_cat(x), find_name(x)) for x in all[idx + 2 : idx_end - 1]]
search_tup = (category.strip(), company_name.strip())
insert_idx = -1
for i, tup in enumerate(reversed(categories)):
if search_tup == tup:
return "This entry already exists"
elif search_tup > tup:
print(search_tup, tup)
insert_idx = len(categories) - i
break
all.insert(
insert_idx + idx + 2,
create_new_line(
category, company_name, description, link, gh_link, alts_names, alts_links
),
)
# file_name = "_".join(company_name.split(" "))
# with open(f"submissions/{file_name}.yaml", "w") as file:
# yaml.dump(
# dict(
# category=category,
# company_name=company_name,
# description=description,
# link=link,
# gh_link=gh_link,
# alts_names=alts_names,
# alts_links=alts_links,
# ),
# file,
# default_flow_style=False,
# )
with open("README.md", "w", encoding="utf-8") as f:
f.writelines(all)
return "ok, added!"
def add_company_from_command_line():
count = 0
args = dict()
while True:
if count == 0:
args["company_name"] = input("Enter the company name.\n(e.g Metabase)\n: ")
print("-" * 100)
count += 1
elif count == 1:
args["category"] = input(
"Enter category of the company. May be an existing or a new one.\n(e.g Business Intelligence)\n: "
)
print("-" * 100)
count += 1
elif count == 2:
args["description"] = input(
"Description of the company.\nKeep it short and simple (use one line)\n: "
)
print("-" * 100)
count += 1
elif count == 3:
args["link"] = input(
"""Url to the company's website.\n(e.g https://www.metabase.com/)\n: """
)
print("-" * 100)
count += 1
elif count == 4:
args["gh_link"] = input(
""""Url of the product's github repo.\n(e.g https://github.com/metabase/metabase)\n: """
)
print("-" * 100)
count += 1
elif count == 5:
args["alts_names"] = input(
"""Names of the company's well-known SaaS competitors.\n(e.g for Metabase: PowerBI, DataStudio, Tableau)\n: """
).split(",")
print("-" * 100)
count += 1
elif count == 6:
args["alts_links"] = input(
"Links to the corresponding SaaS competitors.\n(e.g for Metabase: https://powerbi.microsoft.com/, https://datastudio.google.com/, https://www.tableau.com/)\n: "
).split(",")
print("-" * 100)
count += 1
else:
result = add_new_company(**args)
print(result)
break | null |
188,059 | import argparse
import copy
import glob
import os
import random
import time
import numpy as np
import torch
import wandb
from mmengine import Config
from torch.nn.parallel import DistributedDataParallel as DDP
from torch.utils.data import DataLoader, DistributedSampler
from tqdm import tqdm
from transformers import (
get_constant_schedule_with_warmup,
get_cosine_schedule_with_warmup,
get_linear_schedule_with_warmup,
)
from mmgpt import create_model_and_transforms
from mmgpt.models.builder import create_toy_model_and_transforms
from mmgpt.datasets import InfiniteSampler, build_dataset
from mmgpt.train.distributed import init_distributed_device, world_info_from_env
from mmgpt.train.train_utils import AverageMeter, get_autocast, get_cast_dtype, get_checkpoint
def random_seed(seed=42, rank=0):
torch.manual_seed(seed + rank)
np.random.seed(seed + rank)
random.seed(seed + rank) | null |
188,060 | import argparse
import copy
import glob
import os
import random
import time
import numpy as np
import torch
import wandb
from mmengine import Config
from torch.nn.parallel import DistributedDataParallel as DDP
from torch.utils.data import DataLoader, DistributedSampler
from tqdm import tqdm
from transformers import (
get_constant_schedule_with_warmup,
get_cosine_schedule_with_warmup,
get_linear_schedule_with_warmup,
)
from mmgpt import create_model_and_transforms
from mmgpt.models.builder import create_toy_model_and_transforms
from mmgpt.datasets import InfiniteSampler, build_dataset
from mmgpt.train.distributed import init_distributed_device, world_info_from_env
from mmgpt.train.train_utils import AverageMeter, get_autocast, get_cast_dtype, get_checkpoint
def get_cast_dtype(precision: str):
def get_autocast(precision):
class AverageMeter(object):
def __init__(self):
def reset(self):
def update(self, val, n=1):
def train_one_epoch(
args,
model,
epoch,
train_dataloader,
language_dataloader,
tokenizer,
optimizer,
lr_scheduler,
device_id,
wandb,
):
num_batches_per_epoch = len(train_dataloader)
total_training_steps = num_batches_per_epoch * args.num_epochs
autocast = get_autocast(args.precision)
cast_dtype = get_cast_dtype(args.precision)
model.train()
# setup logging
step_time_m = AverageMeter() # time for one optimizer step (> 1 batch if using gradient accum)
data_time_m = (
AverageMeter()
) # avg time to load one batch of both C4 AND laion (= 1 batch regardless of gradient accum)
end = time.time()
# loop through dataloader
for num_steps, batch in tqdm(
enumerate(train_dataloader),
disable=args.rank != 0,
total=total_training_steps,
initial=(epoch * num_batches_per_epoch),
):
data_time_m.update(time.time() - end)
global_step = num_steps + epoch * num_batches_per_epoch
#### VISION FORWARD PASS ####
images = batch["image"].to(device_id, dtype=cast_dtype, non_blocking=True).unsqueeze(1).unsqueeze(1)
input_ids = batch["input_ids"].to(device_id, dtype=cast_dtype, non_blocking=True)
attention_mask = batch["attention_mask"].to(device_id, dtype=cast_dtype, non_blocking=True)
labels = batch["labels"].to(device_id, dtype=cast_dtype, non_blocking=True)
with autocast():
loss_batch = model(
vision_x=images,
lang_x=input_ids,
attention_mask=attention_mask,
labels=labels,
)[0]
loss = loss_batch / args.gradient_accumulation_steps
loss_vision = loss # for logging
#### BACKWARD PASS ####
loss.backward()
#### LANGUAGE FORWARD PASS ####
if language_dataloader is not None:
batch_lang = next(language_dataloader)
lang_input_ids = batch_lang["input_ids"].to(device_id, dtype=cast_dtype, non_blocking=True)
lang_attention_mask = batch_lang["attention_mask"].to(device_id, dtype=cast_dtype, non_blocking=True)
lang_labels = batch_lang["labels"].to(device_id, dtype=cast_dtype, non_blocking=True)
with autocast():
lang_loss_batch = model(
vision_x=None,
lang_x=lang_input_ids,
attention_mask=lang_attention_mask,
labels=lang_labels,
)[0]
lang_loss = lang_loss_batch / args.gradient_accumulation_steps
#### BACKWARD PASS ####
lang_loss.backward()
torch.nn.utils.clip_grad_norm_(model.parameters(), 1.0)
# step optimizer and log
if (((num_steps + 1) % args.gradient_accumulation_steps) == 0) or (num_steps == num_batches_per_epoch - 1):
optimizer.step()
lr_scheduler.step()
optimizer.zero_grad()
# step time and reset end outside of rank 0
step_time_m.update(time.time() - end)
end = time.time()
if args.rank == 0 and args.report_to_wandb:
# compute within rank 0
samples_per_second = (
args.gradient_accumulation_steps * args.batch_size * args.world_size / step_time_m.val
)
samples_per_second_per_gpu = args.gradient_accumulation_steps * args.batch_size / step_time_m.val
wandb.log(
{
"data_time": data_time_m.avg,
"step_time": step_time_m.avg,
"samples_per_second": samples_per_second,
"samples_per_second_per_gpu": samples_per_second_per_gpu,
"lr": optimizer.param_groups[0]["lr"],
},
commit=False,
)
step_time_m.reset()
data_time_m.reset()
loss_log = {
"loss": loss.item(),
"loss_vision": loss_vision.item(),
"global_step": global_step,
}
if language_dataloader is not None:
loss_log["loss_lang"] = lang_loss.item()
wandb.log(loss_log, commit=True)
# Log loss to console
if ((num_steps + 1) % args.logging_steps == 0) and args.rank == 0:
print(
f"Step {num_steps+1}/{num_batches_per_epoch} of epoch {epoch+1}/{args.num_epochs} complete. Loss: {loss.item():.3f}"
) | null |
188,063 | import os
import torch
try:
import horovod.torch as hvd
except ImportError:
hvd = None
def is_using_distributed():
if "WORLD_SIZE" in os.environ:
return int(os.environ["WORLD_SIZE"]) > 1
if "SLURM_NTASKS" in os.environ:
return int(os.environ["SLURM_NTASKS"]) > 1
return False
def world_info_from_env():
local_rank = 0
for v in (
"LOCAL_RANK",
"MPI_LOCALRANKID",
"SLURM_LOCALID",
"OMPI_COMM_WORLD_LOCAL_RANK",
):
if v in os.environ:
local_rank = int(os.environ[v])
break
global_rank = 0
for v in ("RANK", "PMI_RANK", "SLURM_PROCID", "OMPI_COMM_WORLD_RANK"):
if v in os.environ:
global_rank = int(os.environ[v])
break
world_size = 1
for v in ("WORLD_SIZE", "PMI_SIZE", "SLURM_NTASKS", "OMPI_COMM_WORLD_SIZE"):
if v in os.environ:
world_size = int(os.environ[v])
break
return local_rank, global_rank, world_size
def init_distributed_device(args):
# Distributed training = training on more than one GPU.
# Works in both single and multi-node scenarios.
args.distributed = False
args.world_size = 1
args.rank = 0 # global rank
args.local_rank = 0
if args.horovod:
assert hvd is not None, "Horovod is not installed"
hvd.init()
args.local_rank = int(hvd.local_rank())
args.rank = hvd.rank()
args.world_size = hvd.size()
args.distributed = True
os.environ["LOCAL_RANK"] = str(args.local_rank)
os.environ["RANK"] = str(args.rank)
os.environ["WORLD_SIZE"] = str(args.world_size)
elif is_using_distributed():
if "SLURM_PROCID" in os.environ:
# DDP via SLURM
args.local_rank, args.rank, args.world_size = world_info_from_env()
# SLURM var -> torch.distributed vars in case needed
os.environ["LOCAL_RANK"] = str(args.local_rank)
os.environ["RANK"] = str(args.rank)
os.environ["WORLD_SIZE"] = str(args.world_size)
torch.distributed.init_process_group(
backend=args.dist_backend,
init_method=args.dist_url,
world_size=args.world_size,
rank=args.rank,
)
else:
# DDP via torchrun, torch.distributed.launch
args.local_rank, _, _ = world_info_from_env()
torch.distributed.init_process_group(backend=args.dist_backend, init_method=args.dist_url)
args.world_size = torch.distributed.get_world_size()
args.rank = torch.distributed.get_rank()
args.distributed = True
else:
# needed to run on single gpu
torch.distributed.init_process_group(
backend=args.dist_backend,
init_method=args.dist_url,
world_size=1,
rank=0,
)
if torch.cuda.is_available():
if args.distributed and not args.no_set_device_rank:
device = "cuda:%d" % args.local_rank
else:
device = "cuda:0"
torch.cuda.set_device(device)
else:
device = "cpu"
args.device = device
device = torch.device(device)
return device | null |
188,064 | import os
import torch
def is_rank0():
if not torch.distributed.is_initialized():
return True
return torch.distributed.get_rank() == 0 | null |
188,065 | import time
from contextlib import suppress
import torch
from tqdm import tqdm
def get_cast_dtype(precision: str):
def get_autocast(precision):
class AverageMeter(object):
def __init__(self):
def reset(self):
def update(self, val, n=1):
def train_one_epoch(
args,
model,
epoch,
laion_loader,
mmc4_loader,
tokenizer,
optimizer,
lr_scheduler,
device_id,
wandb,
):
num_batches_per_epoch_laion = laion_loader.num_batches
num_batches_per_epoch_mmc4 = mmc4_loader.num_batches
assert (
num_batches_per_epoch_laion == num_batches_per_epoch_mmc4
), "Number of batches in laion and mmc4 datasets must be the same"
num_batches_per_epoch = num_batches_per_epoch_mmc4
total_training_steps = num_batches_per_epoch * args.num_epochs
autocast = get_autocast(args.precision)
cast_dtype = get_cast_dtype(args.precision)
media_token_id = tokenizer("<image>", add_special_tokens=False)["input_ids"][-1]
endofchunk_token_id = tokenizer("<|endofchunk|>", add_special_tokens=False)["input_ids"][-1]
model.train()
# setup logging
step_time_m = AverageMeter() # time for one optimizer step (> 1 batch if using gradient accum)
data_time_m = (
AverageMeter()
) # avg time to load one batch of both C4 AND laion (= 1 batch regardless of gradient accum)
end = time.time()
# loop through dataloader
for num_steps, (batch_laion, batch_mmc4) in tqdm(
enumerate(zip(laion_loader, mmc4_loader)),
disable=args.rank != 0,
total=total_training_steps,
initial=(epoch * num_batches_per_epoch),
):
data_time_m.update(time.time() - end)
global_step = num_steps + epoch * num_batches_per_epoch
#### LAION FORWARD PASS ####
images = batch_laion[0].to(device_id, dtype=cast_dtype, non_blocking=True).unsqueeze(1).unsqueeze(1)
input_ids = batch_laion[1][0].to(device_id, dtype=cast_dtype, non_blocking=True)
attention_mask = batch_laion[1][1].to(device_id, dtype=cast_dtype, non_blocking=True)
labels = input_ids.clone()
labels[labels == tokenizer.pad_token_id] = -100
labels[:, 0] = -100
labels[labels == media_token_id] = -100
labels.to(device_id)
with autocast():
loss_laion = model(
vision_x=images,
lang_x=input_ids,
attention_mask=attention_mask,
labels=labels,
)[0]
divided_loss_laion = loss_laion / args.gradient_accumulation_steps
#### C4 FORWARD PASS ####
images = batch_mmc4[0].to(device_id, dtype=cast_dtype, non_blocking=True).unsqueeze(2)
input_ids = torch.stack([x[0] for x in batch_mmc4[1]]).squeeze(1)
attention_mask = torch.stack([x[1] for x in batch_mmc4[1]]).squeeze(1)
# NOTE: irena: expected shape of clip_text_input_ids / attention_mask is (N, I, max_seq_len)
labels = input_ids.clone()
labels[labels == tokenizer.pad_token_id] = -100
labels[:, 0] = -100
for i in range(labels.shape[0]):
# remove loss for any token before the first <image> token
label_idx = 0
while label_idx < labels.shape[1] and labels[i][label_idx] != media_token_id:
labels[i][label_idx] = -100
label_idx += 1
# get index of all endofchunk tokens in the sequence
endofchunk_idxs = torch.where(labels[i] == endofchunk_token_id)[0]
for endofchunk_idx in endofchunk_idxs:
token_idx = endofchunk_idx + 1
while token_idx < labels.shape[1] and labels[i][token_idx] != media_token_id:
labels[i][token_idx] = -100
token_idx += 1
labels[labels == media_token_id] = -100
labels.to(device_id)
with autocast():
loss_mmc4 = model(
vision_x=images,
lang_x=input_ids,
attention_mask=attention_mask,
labels=labels,
)[0]
# if loss is nan, skip this batch
if torch.isnan(loss_mmc4):
print("loss is nan, skipping this batch")
print("input_ids: ", tokenizer.batch_decode(input_ids))
print("labels: ", labels)
print("images: ", images)
optimizer.zero_grad()
continue
divided_loss_mmc4 = loss_mmc4 / args.gradient_accumulation_steps
#### BACKWARD PASS ####
loss = divided_loss_laion * args.loss_multiplier_laion + divided_loss_mmc4 * args.loss_multiplier_mmc4
loss.backward()
#### MASK GRADIENTS FOR EMBEDDINGS ####
# Note (anas): Do not apply weight decay to embeddings as it will break this function.
def mask_embedding(m):
if isinstance(m, torch.nn.Embedding) and m.weight.requires_grad:
zero_mask = torch.zeros_like(m.weight.grad)
zero_mask[media_token_id] = torch.ones_like(zero_mask[media_token_id])
zero_mask[endofchunk_token_id] = torch.ones_like(zero_mask[endofchunk_token_id])
m.weight.grad = m.weight.grad * zero_mask
model.apply(mask_embedding)
torch.nn.utils.clip_grad_norm_(model.parameters(), 1.0)
# step optimizer and log
if (((num_steps + 1) % args.gradient_accumulation_steps) == 0) or (num_steps == num_batches_per_epoch - 1):
optimizer.step()
lr_scheduler.step()
optimizer.zero_grad()
# step time and reset end outside of rank 0
step_time_m.update(time.time() - end)
end = time.time()
if args.rank == 0 and args.report_to_wandb:
# compute within rank 0
laion_samples_per_second = (
args.gradient_accumulation_steps * args.batch_size_laion * args.world_size / step_time_m.val
)
laion_samples_per_second_per_gpu = (
args.gradient_accumulation_steps * args.batch_size_laion / step_time_m.val
)
c4_samples_per_second = (
args.gradient_accumulation_steps * args.batch_size_mmc4 * args.world_size / step_time_m.val
)
c4_samples_per_second_per_gpu = (
args.gradient_accumulation_steps * args.batch_size_mmc4 / step_time_m.val
)
wandb.log(
{
"data_time": data_time_m.avg,
"step_time": step_time_m.avg,
"laion_samples_per_second": laion_samples_per_second,
"laion_samples_per_second_per_gpu": laion_samples_per_second_per_gpu,
"c4_samples_per_second": c4_samples_per_second,
"c4_samples_per_second_per_gpu": c4_samples_per_second_per_gpu,
"lr": optimizer.param_groups[0]["lr"],
},
commit=False,
)
step_time_m.reset()
data_time_m.reset()
wandb.log(
{
"loss_laion": divided_loss_laion.item(),
"global_step": global_step,
},
commit=False,
)
wandb.log(
{"loss_mmc4": divided_loss_mmc4.item(), "global_step": global_step},
commit=True,
)
# Log loss to console
if ((num_steps + 1) % args.logging_steps == 0) and args.rank == 0:
print(
f"Step {num_steps+1}/{num_batches_per_epoch} of epoch {epoch+1}/{args.num_epochs} complete. Loss LAION: {loss_laion.item():.3f} // Loss MMC4: {loss_mmc4.item():.3f}"
) | null |
188,066 | import time
from contextlib import suppress
import torch
from tqdm import tqdm
def get_checkpoint(model: torch.nn.Module):
state_dict = model.state_dict()
parameters = {k: v for k, v in model.named_parameters()}
# remove duplicate parameters
duplicate_keys = set(state_dict.keys()) - set(parameters.keys())
for k in duplicate_keys:
del state_dict[k]
# remove non-grad parameters
for name, p in parameters.items():
if not p.requires_grad:
del state_dict[name]
return state_dict | null |
188,067 | import copy
import json
import os
import random
from collections import defaultdict
import torch
import torch.nn.functional as F
from PIL import Image
from .vqa_dataset import VQADataset
class NLVRv1Dataset(VQADataset):
"""Visual Reasoning Dataset."""
def __init__(self, tokenizer, vis_processor, vis_root, ann_paths, **kwargs):
super().__init__(tokenizer, vis_processor, vis_root, ann_paths=[], **kwargs)
self.annotation = self.load_annotations(ann_paths)
if self.sample_image:
print("randomly sample one annotation for each image")
self.annotation = self.parse_annotation(self.annotation)
self._add_instance_ids()
def load_annotations(ann_paths):
annotation = []
for ann_path in ann_paths:
if "train.json" in ann_path:
split = "train"
elif "dev.json" in ann_path:
split = "dev"
elif "test.json" in ann_path:
split = "test"
else:
raise ValueError(f"Unknown split for {ann_path}")
with open(ann_path, "r") as f:
for line in f.readlines():
line = line.strip()
if len(line) != 0:
ann = json.loads(line)
ann["split"] = split
annotation.append(ann)
return annotation
def parse_annotation(self, annotation):
image_list = defaultdict(list)
for ann in annotation:
img_key = f"{ann['split']}-{ann['identifier']}"
image_list[img_key].append(ann)
annotation = []
for ann_list in image_list.values():
annotation.append(random.choice(ann_list))
return annotation
def process_text(self, ann):
question = ann["sentence"] + " " + random.choice(QUESTIONS)
true_answer = ann["label"]
if random.random() < self.option_prob:
instruction = self.prompter(question, ["true", "false"])
else:
instruction = self.prompter(question)
return dict(instruction=instruction, answer=true_answer)
def process_image(self, ann):
# each question have 6 images, we can random select one of them.
# TODO: check whether using all 6 images?
random_id = random.randint(0, 5)
image_name = f"{ann['split']}-{ann['identifier']}-{random_id}.png"
image_path = os.path.join(self.vis_root, ann["split"], "images", ann["directory"], image_name)
image = Image.open(image_path).convert("RGB")
image = self.vis_processor(image)
return image
def build_nlvrv1_dataset(
tokenizer,
vis_processor,
vis_root="data/nlvr",
ann_paths=["data/nlvr//train/train.json"],
sample_image=False,
):
return NLVRv1Dataset(
tokenizer=tokenizer,
vis_processor=vis_processor,
vis_root=vis_root,
ann_paths=ann_paths,
sample_image=sample_image,
) | null |
188,068 | import copy
import json
import os
import random
from collections import defaultdict
import torch
import torch.nn.functional as F
from PIL import Image
from .vqa_dataset import VQADataset
class NLVRv2Dataset(VQADataset):
def __init__(self, tokenizer, vis_processor, vis_root, ann_paths, **kwargs):
def parse_annotation(self, annotation):
def process_text(self, ann):
def process_image(self, ann):
def _flip(samples):
def __getitem__(self, index):
def build_nlvrv2_dataset(
tokenizer,
vis_processor,
vis_root="data/nlvr2",
ann_paths=["data/nlvr2/annotations/nlvr_train.json"],
sample_image=False,
):
return NLVRv2Dataset(
tokenizer=tokenizer,
vis_processor=vis_processor,
vis_root=vis_root,
ann_paths=ann_paths,
sample_image=sample_image,
) | null |
188,069 | import json
import os
import random
from collections import defaultdict
from PIL import Image
from .vqa_dataset import VQADataset
class GQADataset(VQADataset):
"""Visual Reasoning Dataset."""
def __init__(self, tokenizer, vis_processor, vis_root, ann_paths, **kwargs):
super().__init__(tokenizer, vis_processor, vis_root, ann_paths=[], **kwargs)
self.annotation = self.load_annotations(ann_paths)
if self.sample_image:
print("randomly sample one annotation for each image")
self.annotation = self.parse_annotation(self.annotation)
self._add_instance_ids()
self.answer_prob = 1.0
def load_annotations(ann_paths):
annotation = []
for ann_path in ann_paths:
ann = json.load(open(ann_path, "r"))
for k, v in ann.items():
v["question_id"] = k
annotation.append(v)
return annotation
def parse_annotation(self, annotation):
image_list = defaultdict(list)
for ann in annotation:
image_list[ann["imageId"]].append(ann)
annotation = []
for ann_list in image_list.values():
annotation.append(random.choice(ann_list))
return annotation
def process_text(self, ann):
question = ann["question"]
answer = ann["answer"]
full_answer = ann["fullAnswer"]
# TODO: check which one is better
# Random select answer or full_answer
if random.random() < self.answer_prob:
select_answer = full_answer
else:
select_answer = answer
instruction = self.prompter(question)
return dict(instruction=instruction, answer=select_answer)
def process_image(self, ann):
image_path = os.path.join(self.vis_root, ann["imageId"] + ".jpg")
image = Image.open(image_path).convert("RGB")
image = self.vis_processor(image)
return image
def build_gqa_dataset(
tokenizer,
vis_processor,
vis_root="data/gqa/images",
ann_paths=[
"data/gqa/questions/train_all_questions/train_all_questions_0.json",
"data/gqa/questions/val_all_questions.json",
],
sample_image=False,
):
return GQADataset(
tokenizer=tokenizer,
vis_processor=vis_processor,
vis_root=vis_root,
ann_paths=ann_paths,
sample_image=sample_image,
) | null |
188,070 | import copy
import json
import numpy as np
from torch.utils.data import Dataset
from transformers import LlamaTokenizer
class DollyDataset(Dataset):
"""Each line of the annotation file is a json object with the following fields:
{
"instruction": "What is a dispersive prism?",
"context": "In optics, a dispersive prism is an optical prism that is used to disperse light, that is, to separate light into its spectral components (the colors of the rainbow). Different wavelengths (colors) of light will be deflected by the prism at different angles.[1] This is a result of the prism material's index of refraction varying with wavelength (dispersion). Generally, longer wavelengths (red) undergo a smaller deviation than shorter wavelengths (blue). The dispersion of white light into colors by a prism led Sir Isaac Newton to conclude that white light consisted of a mixture of different colors.",
"response": "A dispersive prism is an optical prism that disperses the light's different wavelengths at different angles. When white light is shined through a dispersive prism it will separate into the different colors of the rainbow.",
"category": "summarization"
}
"""
def __init__(self, tokenizer, ann_path: str, add_eos=True, ignore_instruction=True, **kwargs):
"""
ann_path (string): directory to store the annotation file
"""
assert tokenizer.add_eos_token is False, "tokenizer should not add eos token by default"
self.tokenizer: LlamaTokenizer = tokenizer
self.annotation = []
self.prompter = LMPrompter()
self.add_eos = add_eos
self.ignore_instruction = ignore_instruction
self.load_annotation(ann_path)
def load_annotation(self, ann_path):
self.annotation = []
for line in open(ann_path, "r").readlines():
self.annotation.append(json.loads(line))
def __len__(self):
return len(self.annotation)
def process_text(self, ann):
instruction = ann["instruction"]
context = ann["context"]
response = ann["response"]
instruction = self.prompter(instruction=instruction, input=context)
return dict(instruction=instruction, answer=response)
def tokenize(self, text):
res = self.tokenizer(
text["instruction"] + text["answer"],
return_tensors=None,
padding="do_not_pad",
truncation=True,
max_length=512,
)
# manually add eos token
if res["input_ids"][-1] != self.tokenizer.eos_token_id and len(res["input_ids"]) < 512 and self.add_eos:
res["input_ids"].append(self.tokenizer.eos_token_id)
res["attention_mask"].append(1)
labels = copy.deepcopy(res["input_ids"])
# ignore instruction_token
if self.ignore_instruction:
instruction_token = self.tokenizer(
text["instruction"], return_tensors=None, padding="do_not_pad", truncation=True, max_length=512
)
labels = [-100] * len(instruction_token["input_ids"]) + labels[len(instruction_token["input_ids"]) :]
res.update(labels=labels)
return res
def __getitem__(self, index):
ann = self.annotation[index]
text = self.process_text(ann)
res = self.tokenize(text)
res.update(text)
return res
def collater(self, samples):
question_list, answer_list, input_id_list, attention_mask_list, labels_list = [], [], [], [], []
for sample in samples:
question_list.append(sample["instruction"])
answer_list.append(sample["answer"])
input_id_list.append(sample["input_ids"])
attention_mask_list.append(sample["attention_mask"])
labels_list.append(sample["labels"])
# We have to pad the labels before calling `tokenizer.pad` as this method won't pad them and needs them of the
# same length to return tensors.
max_label_length = max(len(l) for l in labels_list)
padding_side = self.tokenizer.padding_side
padded_labels = []
for l in labels_list:
remainder = [-100] * (max_label_length - len(l))
if isinstance(l, list):
l = l + remainder if padding_side == "right" else remainder + l
elif padding_side == "right":
l = np.concatenate([l, remainder]).astype(np.int64)
else:
l = np.concatenate([remainder, l]).astype(np.int64)
padded_labels.append(l)
padded_samples = self.tokenizer.pad(
{"input_ids": input_id_list, "attention_mask": attention_mask_list, "labels": padded_labels},
return_tensors="pt",
padding="longest",
)
labels = padded_samples["labels"]
labels[labels == self.tokenizer.pad_token_id] = -100
labels[:, 0] = -100
return {
"input_ids": padded_samples["input_ids"],
"attention_mask": padded_samples["attention_mask"],
"labels": labels,
"instruction": question_list,
"answer": answer_list,
}
def build_dolly_dataset(
tokenizer,
ann_path="data/dolly/databricks-dolly-15k.jsonl",
**kwargs,
):
return DollyDataset(
tokenizer=tokenizer,
ann_path=ann_path,
**kwargs,
) | null |
188,071 | import random
from .vqa_dataset import VQADataset
class AOKVQADataset(VQADataset):
def __init__(self, tokenizer, vis_processor, vis_root, ann_paths, **kwargs):
super().__init__(tokenizer, vis_processor, vis_root, ann_paths, **kwargs)
def process_text(self, ann):
question = ann["question"]
question = question + " " + random.choice(REASON_QUESTIONS)
choices = ann["choices"]
true_answer = choices[ann["correct_choice_idx"]]
answer = "The answer is " + true_answer + ". Because " + " ".join(ann["rationales"])
is_option = random.random() < self.option_prob and len(choices) > 1
if is_option:
instruction = self.prompter(question, choices)
else:
instruction = self.prompter(question)
instruction = self.prompter(question)
return dict(instruction=instruction, answer=answer)
def build_aokvqa_dataset(
tokenizer,
vis_processor,
vis_root="data/coco/images",
ann_paths=["data/aokvqa/annotations/aokvqa_v1p0_train.json"],
sample_image=False,
):
return AOKVQADataset(
tokenizer=tokenizer,
vis_processor=vis_processor,
vis_root=vis_root,
ann_paths=ann_paths,
sample_image=sample_image,
) | null |
188,072 | import json
import os
import random
from PIL import Image
from .vqa_dataset import VQADataset, VQAPrompter
class CcSbuAlignDataset(VQADataset):
def __init__(self, tokenizer, vis_processor, vis_root, ann_paths, add_eos=True, ignore_instruction=True):
self.tokenizer = tokenizer
self.vis_root = vis_root
self.annotation = []
for ann_path in ann_paths:
self.annotation.extend(json.load(open(ann_path, "r"))["annotations"])
self.vis_processor = vis_processor
self.prompter = VQAPrompter()
self.add_eos = add_eos
self.ignore_instruction = ignore_instruction
def process_text(self, ann):
# random select a question
question = random.choice(QUESTIONS)
answer = ann["caption"]
instruction = self.prompter(question)
return dict(instruction=instruction, answer=answer)
def process_image(self, ann):
image_path = os.path.join(self.vis_root, ann["image_id"] + ".jpg")
image = Image.open(image_path).convert("RGB")
image = self.vis_processor(image)
return image
def build_ccsbualign_dataset(
tokenizer,
vis_processor,
vis_root="data/cc_sbu_align/image/",
ann_paths=["data/cc_sbu_align/filter_cap.json"],
**kwargs,
):
return CcSbuAlignDataset(
tokenizer=tokenizer,
vis_processor=vis_processor,
vis_root=vis_root,
ann_paths=ann_paths,
) | null |
188,073 | import numpy as np
import torch
from .alpaca_gpt4_dataset import AlpacaGPT4Dataset
from .aokvqa_dataset import AOKVQADataset
from .cc_sbu_align_dataset import CcSbuAlignDataset
from .clevr_dataset import CLEVRDataset
from .coco_caption_dataset import COCOCaptionDataset
from .dial_dataset import DialDataset
from .dolly_dataset import DollyDataset
from .gqa_dataset import GQADataset
from .llava_dataset import LlavaDataset
from .nlvr_dataset import NLVRv1Dataset, NLVRv2Dataset
from .ocr_vqa_dataset import OCRVQADataset
from .snli_ve_datasets import SNLIVEDataset
from .text_ocr_dataset import TextOCRDataset
from .vqa_dataset import ConcatDataset, VQADataset
from .baize_dataset import BaiZeDataset
class AlpacaGPT4Dataset(DollyDataset):
"""
```json
[
{
"instruction": "Identify the odd one out.",
"input": "Twitter, Instagram, Telegram",
"output": "The odd one out is Telegram. Twitter and Instagram are social media platforms mainly for sharing information, images and videos while Telegram is a cloud-based instant messaging and voice-over-IP service."
},
]
"""
def load_annotation(self, ann_path):
self.annotation = json.load(open(ann_path, "r"))
def process_text(self, ann):
instruction = ann["instruction"]
input = ann["input"]
output = ann["output"]
instruction = self.prompter(instruction=instruction, input=input)
return dict(instruction=instruction, answer=output)
class AOKVQADataset(VQADataset):
def __init__(self, tokenizer, vis_processor, vis_root, ann_paths, **kwargs):
super().__init__(tokenizer, vis_processor, vis_root, ann_paths, **kwargs)
def process_text(self, ann):
question = ann["question"]
question = question + " " + random.choice(REASON_QUESTIONS)
choices = ann["choices"]
true_answer = choices[ann["correct_choice_idx"]]
answer = "The answer is " + true_answer + ". Because " + " ".join(ann["rationales"])
is_option = random.random() < self.option_prob and len(choices) > 1
if is_option:
instruction = self.prompter(question, choices)
else:
instruction = self.prompter(question)
instruction = self.prompter(question)
return dict(instruction=instruction, answer=answer)
class CcSbuAlignDataset(VQADataset):
def __init__(self, tokenizer, vis_processor, vis_root, ann_paths, add_eos=True, ignore_instruction=True):
self.tokenizer = tokenizer
self.vis_root = vis_root
self.annotation = []
for ann_path in ann_paths:
self.annotation.extend(json.load(open(ann_path, "r"))["annotations"])
self.vis_processor = vis_processor
self.prompter = VQAPrompter()
self.add_eos = add_eos
self.ignore_instruction = ignore_instruction
def process_text(self, ann):
# random select a question
question = random.choice(QUESTIONS)
answer = ann["caption"]
instruction = self.prompter(question)
return dict(instruction=instruction, answer=answer)
def process_image(self, ann):
image_path = os.path.join(self.vis_root, ann["image_id"] + ".jpg")
image = Image.open(image_path).convert("RGB")
image = self.vis_processor(image)
return image
class CLEVRDataset(VQADataset):
"""Visual Reasoning Dataset. It also contains Dialog.
Note: The image is a little bit simple. with several objects and simple background.
"""
def __init__(self, tokenizer, vis_processor, vis_root, ann_paths, **kwargs):
super().__init__(tokenizer, vis_processor, vis_root, ann_paths=[], **kwargs)
self.annotation = self.load_annotations(ann_paths)
if self.sample_image:
print("randomly sample one annotation for each image")
self.annotation = self.parse_annotation(self.annotation)
self._add_instance_ids()
def load_annotations(ann_paths):
annotation = []
for ann_path in ann_paths:
ann = json.load(open(ann_path, "r"))
annotation.extend(ann["questions"])
return annotation
def parse_annotation(self, annotation):
image_list = defaultdict(list)
for ann in annotation:
image_list[ann["image_filename"]].append(ann)
annotation = []
for ann_list in image_list.values():
annotation.append(random.choice(ann_list))
return annotation
def process_text(self, ann):
question = ann["question"]
answer = ann["answer"]
instruction = self.prompter(question)
return dict(instruction=instruction, answer=answer)
def process_image(self, ann):
split = ann["split"]
image_path = os.path.join(self.vis_root, split, ann["image_filename"])
image = Image.open(image_path).convert("RGB")
image = self.vis_processor(image)
return image
class COCOCaptionDataset(VQADataset):
def __init__(
self, tokenizer, vis_processor=None, vis_root=None, ann_paths=[], add_eos=True, ignore_instruction=True
):
"""
vis_root (string): Root directory of images (e.g. coco/images/)
ann_root (string): directory to store the annotation file
"""
self.tokenizer: LlamaTokenizer = tokenizer
self.vis_root = vis_root
self.annotation = []
for ann_path in ann_paths:
self.annotation.extend(json.load(open(ann_path, "r")))
self.vis_processor = vis_processor
instructions = []
for question in QUESTIONS:
# instruction = f"Below is a question about an image. Write a response to answer the question.\n\n### Image:\n<image>\n\n### Question:\n{question}\n\n### Answer:\n".format(
# question
# )
instruction = "Below is an instruction that describes a task. Write a response that appropriately completes the request.\n\n### Image:\n{image}\n\n### Instruction:\n{question}\n\n### Response:\n".format(
image="<image>", question=question
)
instructions.append(instruction)
self.instructions = instructions
self.add_eos = add_eos
self.ignore_instruction = ignore_instruction
def process_image(self, ann):
image_path = os.path.join(self.vis_root, ann["image"])
image = Image.open(image_path).convert("RGB")
image = self.vis_processor(image)
return image
def process_text(self, ann):
all_captions = ann["caption"]
if not isinstance(all_captions, list):
all_captions = [all_captions]
caption = random.choice(all_captions)
instruction = random.choice(self.instructions)
return dict(instruction=instruction, answer=caption)
class DialDataset(VQADataset):
def __init__(self, *args, **kwargs):
super(DialDataset, self).__init__(*args, **kwargs)
self.prompter = DialPrompter()
def _add_instance_ids(self, key="id"):
for idx, ann in enumerate(self.annotation):
ann[key] = str(idx)
def process_text(self, anns):
# TODO remove this
begin_string = "Below is an instruction that describes a task. Write a response that appropriately completes the request.\n\n### Image:\n{image}".format(
image="<image>"
)
num_convs = len(anns["conversations"]) // 2
conv_list = []
for conv_id in range(num_convs):
question = anns["conversations"][conv_id]["value"]
# remove '<image>' tag and '\n'
question = question.replace("<image>", "").replace("\n", "")
answer = anns["conversations"][conv_id + 1]["value"]
instruction = self.prompter(question)
if conv_id == 0:
single_conv = dict(instruction=begin_string + instruction, answer=answer)
else:
single_conv = dict(instruction=instruction, answer=answer)
conv_list.append(single_conv)
return conv_list
def __getitem__(self, index):
ann = self.annotation[index]
image = self.process_image(ann)
text_list = self.process_text(ann)
res_list = []
for text in text_list:
single_res = self.tokenize(text)
single_res["instruction"] = text["instruction"]
single_res["answer"] = text["answer"]
res_list.append(single_res)
input_ids = []
attention_mask = []
labels = []
instruction = []
answer = []
for res in res_list:
input_ids.extend(res["input_ids"])
attention_mask.extend(res["attention_mask"])
labels.extend(res["labels"])
instruction.extend(res["instruction"])
answer.extend(res["answer"])
res = dict(
input_ids=input_ids, attention_mask=attention_mask, labels=labels, instruction=instruction, answer=answer
)
res.update(image=image)
return res
class DollyDataset(Dataset):
"""Each line of the annotation file is a json object with the following fields:
{
"instruction": "What is a dispersive prism?",
"context": "In optics, a dispersive prism is an optical prism that is used to disperse light, that is, to separate light into its spectral components (the colors of the rainbow). Different wavelengths (colors) of light will be deflected by the prism at different angles.[1] This is a result of the prism material's index of refraction varying with wavelength (dispersion). Generally, longer wavelengths (red) undergo a smaller deviation than shorter wavelengths (blue). The dispersion of white light into colors by a prism led Sir Isaac Newton to conclude that white light consisted of a mixture of different colors.",
"response": "A dispersive prism is an optical prism that disperses the light's different wavelengths at different angles. When white light is shined through a dispersive prism it will separate into the different colors of the rainbow.",
"category": "summarization"
}
"""
def __init__(self, tokenizer, ann_path: str, add_eos=True, ignore_instruction=True, **kwargs):
"""
ann_path (string): directory to store the annotation file
"""
assert tokenizer.add_eos_token is False, "tokenizer should not add eos token by default"
self.tokenizer: LlamaTokenizer = tokenizer
self.annotation = []
self.prompter = LMPrompter()
self.add_eos = add_eos
self.ignore_instruction = ignore_instruction
self.load_annotation(ann_path)
def load_annotation(self, ann_path):
self.annotation = []
for line in open(ann_path, "r").readlines():
self.annotation.append(json.loads(line))
def __len__(self):
return len(self.annotation)
def process_text(self, ann):
instruction = ann["instruction"]
context = ann["context"]
response = ann["response"]
instruction = self.prompter(instruction=instruction, input=context)
return dict(instruction=instruction, answer=response)
def tokenize(self, text):
res = self.tokenizer(
text["instruction"] + text["answer"],
return_tensors=None,
padding="do_not_pad",
truncation=True,
max_length=512,
)
# manually add eos token
if res["input_ids"][-1] != self.tokenizer.eos_token_id and len(res["input_ids"]) < 512 and self.add_eos:
res["input_ids"].append(self.tokenizer.eos_token_id)
res["attention_mask"].append(1)
labels = copy.deepcopy(res["input_ids"])
# ignore instruction_token
if self.ignore_instruction:
instruction_token = self.tokenizer(
text["instruction"], return_tensors=None, padding="do_not_pad", truncation=True, max_length=512
)
labels = [-100] * len(instruction_token["input_ids"]) + labels[len(instruction_token["input_ids"]) :]
res.update(labels=labels)
return res
def __getitem__(self, index):
ann = self.annotation[index]
text = self.process_text(ann)
res = self.tokenize(text)
res.update(text)
return res
def collater(self, samples):
question_list, answer_list, input_id_list, attention_mask_list, labels_list = [], [], [], [], []
for sample in samples:
question_list.append(sample["instruction"])
answer_list.append(sample["answer"])
input_id_list.append(sample["input_ids"])
attention_mask_list.append(sample["attention_mask"])
labels_list.append(sample["labels"])
# We have to pad the labels before calling `tokenizer.pad` as this method won't pad them and needs them of the
# same length to return tensors.
max_label_length = max(len(l) for l in labels_list)
padding_side = self.tokenizer.padding_side
padded_labels = []
for l in labels_list:
remainder = [-100] * (max_label_length - len(l))
if isinstance(l, list):
l = l + remainder if padding_side == "right" else remainder + l
elif padding_side == "right":
l = np.concatenate([l, remainder]).astype(np.int64)
else:
l = np.concatenate([remainder, l]).astype(np.int64)
padded_labels.append(l)
padded_samples = self.tokenizer.pad(
{"input_ids": input_id_list, "attention_mask": attention_mask_list, "labels": padded_labels},
return_tensors="pt",
padding="longest",
)
labels = padded_samples["labels"]
labels[labels == self.tokenizer.pad_token_id] = -100
labels[:, 0] = -100
return {
"input_ids": padded_samples["input_ids"],
"attention_mask": padded_samples["attention_mask"],
"labels": labels,
"instruction": question_list,
"answer": answer_list,
}
class GQADataset(VQADataset):
"""Visual Reasoning Dataset."""
def __init__(self, tokenizer, vis_processor, vis_root, ann_paths, **kwargs):
super().__init__(tokenizer, vis_processor, vis_root, ann_paths=[], **kwargs)
self.annotation = self.load_annotations(ann_paths)
if self.sample_image:
print("randomly sample one annotation for each image")
self.annotation = self.parse_annotation(self.annotation)
self._add_instance_ids()
self.answer_prob = 1.0
def load_annotations(ann_paths):
annotation = []
for ann_path in ann_paths:
ann = json.load(open(ann_path, "r"))
for k, v in ann.items():
v["question_id"] = k
annotation.append(v)
return annotation
def parse_annotation(self, annotation):
image_list = defaultdict(list)
for ann in annotation:
image_list[ann["imageId"]].append(ann)
annotation = []
for ann_list in image_list.values():
annotation.append(random.choice(ann_list))
return annotation
def process_text(self, ann):
question = ann["question"]
answer = ann["answer"]
full_answer = ann["fullAnswer"]
# TODO: check which one is better
# Random select answer or full_answer
if random.random() < self.answer_prob:
select_answer = full_answer
else:
select_answer = answer
instruction = self.prompter(question)
return dict(instruction=instruction, answer=select_answer)
def process_image(self, ann):
image_path = os.path.join(self.vis_root, ann["imageId"] + ".jpg")
image = Image.open(image_path).convert("RGB")
image = self.vis_processor(image)
return image
class LlavaDataset(VQADataset):
def __init__(self, tokenizer, vis_processor, vis_root, ann_paths, **kwargs):
super().__init__(tokenizer, vis_processor, vis_root, ann_paths, **kwargs)
def _add_instance_ids(self, key="id"):
for idx, ann in enumerate(self.annotation):
ann[key] = str(idx)
def process_text(self, ann):
question = ann["conversations"][0]["value"]
# remove '<image>' tag and '\n'
question = question.replace("<image>", "").replace("\n", "")
answer = ann["conversations"][1]["value"]
instruction = self.prompter(question)
return dict(instruction=instruction, answer=answer)
class NLVRv1Dataset(VQADataset):
"""Visual Reasoning Dataset."""
def __init__(self, tokenizer, vis_processor, vis_root, ann_paths, **kwargs):
super().__init__(tokenizer, vis_processor, vis_root, ann_paths=[], **kwargs)
self.annotation = self.load_annotations(ann_paths)
if self.sample_image:
print("randomly sample one annotation for each image")
self.annotation = self.parse_annotation(self.annotation)
self._add_instance_ids()
def load_annotations(ann_paths):
annotation = []
for ann_path in ann_paths:
if "train.json" in ann_path:
split = "train"
elif "dev.json" in ann_path:
split = "dev"
elif "test.json" in ann_path:
split = "test"
else:
raise ValueError(f"Unknown split for {ann_path}")
with open(ann_path, "r") as f:
for line in f.readlines():
line = line.strip()
if len(line) != 0:
ann = json.loads(line)
ann["split"] = split
annotation.append(ann)
return annotation
def parse_annotation(self, annotation):
image_list = defaultdict(list)
for ann in annotation:
img_key = f"{ann['split']}-{ann['identifier']}"
image_list[img_key].append(ann)
annotation = []
for ann_list in image_list.values():
annotation.append(random.choice(ann_list))
return annotation
def process_text(self, ann):
question = ann["sentence"] + " " + random.choice(QUESTIONS)
true_answer = ann["label"]
if random.random() < self.option_prob:
instruction = self.prompter(question, ["true", "false"])
else:
instruction = self.prompter(question)
return dict(instruction=instruction, answer=true_answer)
def process_image(self, ann):
# each question have 6 images, we can random select one of them.
# TODO: check whether using all 6 images?
random_id = random.randint(0, 5)
image_name = f"{ann['split']}-{ann['identifier']}-{random_id}.png"
image_path = os.path.join(self.vis_root, ann["split"], "images", ann["directory"], image_name)
image = Image.open(image_path).convert("RGB")
image = self.vis_processor(image)
return image
class NLVRv2Dataset(VQADataset):
"""Visual Reasoning Dataset."""
def __init__(self, tokenizer, vis_processor, vis_root, ann_paths, **kwargs):
super().__init__(tokenizer, vis_processor, vis_root, ann_paths, **kwargs)
self.flip_prob = 0.5
def parse_annotation(self, annotation):
image_list = defaultdict(list)
for ann in annotation:
image_list[ann["images"][0]].append(ann)
# image_name_list = list(image_list.keys())
annotation = []
for ann_list in image_list.values():
annotation.append(random.choice(ann_list))
return annotation
def process_text(self, ann):
question = ann["sentence"] + " " + random.choice(QUESTIONS)
true_answer = ann["label"]
if random.random() < self.option_prob:
instruction = self.prompter(question, ["true", "false"])
else:
instruction = self.prompter(question)
return dict(instruction=instruction, answer=true_answer)
def process_image(self, ann):
image_0_path = os.path.join(self.vis_root, ann["images"][0])
image_1_path = os.path.join(self.vis_root, ann["images"][1])
image_0 = Image.open(image_0_path).convert("RGB")
image_1 = Image.open(image_1_path).convert("RGB")
image_0 = self.vis_processor(image_0)
image_1 = self.vis_processor(image_1)
return image_0, image_1
def _flip(samples):
sentence = samples["sentence"]
image0, image1 = samples["image0"], samples["image1"]
if "left" not in sentence and "right" not in sentence:
if random.random() < 0.5:
image0, image1 = image1, image0
else:
if random.random() < 0.5:
sentence = sentence.replace("left", "[TEMP_TOKEN]")
sentence = sentence.replace("right", "left")
sentence = sentence.replace("[TEMP_TOKEN]", "right")
image0, image1 = image1, image0
samples["sentence"] = sentence
samples["image0"] = image0
samples["image1"] = image1
return samples
def __getitem__(self, index):
ann = copy.deepcopy(self.annotation[index])
image_0, image_1 = self.process_image(ann)
if random.random() < self.flip_prob:
samples = self._flip({"sentence": ann["sentence"], "image0": image_0, "image1": image_1})
image_0, image_1 = samples["image0"], samples["image1"]
ann["sentence"] = samples["sentence"]
# concat
# TODO: https://github.com/salesforce/LAVIS/blob/main/lavis/models/blip_models/blip_nlvr.py
# model logic need update if using nlvr2
image = torch.cat([image_0, image_1], dim=2)
image = F.interpolate(image[None, ...], size=(image_0.shape[1], image_0.shape[2]))[0]
text = self.process_text(ann)
res = self.tokenize(text)
res.update(image=image)
res.update(text)
return res
class OCRVQADataset(VQADataset):
def process_image(self, ann):
image_path = os.path.join(self.vis_root, ann["filename"])
image = Image.open(image_path).convert("RGB")
image = self.vis_processor(image)
return image
def process_text(self, ann):
index = random.choice(list(range(len(ann["questions"]))))
question = ann["questions"][index]
answer = ann["answers"][index]
instruction = self.prompter(question)
return dict(instruction=instruction, answer=answer)
class SNLIVEDataset(VQADataset):
"""Visual Reasoning Dataset."""
def __init__(self, tokenizer, vis_processor, vis_root, ann_paths, **kwargs):
super().__init__(tokenizer, vis_processor, vis_root, ann_paths=[], **kwargs)
self.annotation = self.load_annotations(ann_paths)
if self.sample_image:
print("randomly sample one annotation for each image")
self.annotation = self.parse_annotation(self.annotation)
self._add_instance_ids()
def load_annotations(ann_paths):
annotation = []
for ann_path in ann_paths:
with open(ann_path, "r") as f:
for line in f.readlines():
line = line.strip()
if len(line) != 0:
ann = json.loads(line)
annotation.append(ann)
return annotation
def parse_annotation(self, annotation):
image_list = defaultdict(list)
for ann in annotation:
image_list[ann["Flickr30K_ID"]].append(ann)
annotation = []
for ann_list in image_list.values():
annotation.append(random.choice(ann_list))
return annotation
def process_text(self, ann):
question = ann["sentence2"] + " " + random.choice(QUESTIONS)
answer = ann["gold_label"]
if random.random() < self.option_prob:
instruction = self.prompter(question, ["entailment", "neutral", "contradiction"])
else:
instruction = self.prompter(question)
return dict(instruction=instruction, answer=answer)
def process_image(self, ann):
image_path = os.path.join(self.vis_root, ann["Flickr30K_ID"] + ".jpg")
image = Image.open(image_path).convert("RGB")
image = self.vis_processor(image)
return image
class TextOCRDataset(VQADataset):
def __init__(
self, tokenizer, vis_processor=None, vis_root=None, ann_paths=[], add_eos=True, ignore_instruction=True
):
"""
vis_root (string): Root directory of images (e.g. coco/images/)
ann_root (string): directory to store the annotation file
"""
assert tokenizer.add_eos_token is False, "tokenizer should not add eos token by default"
self.tokenizer: LlamaTokenizer = tokenizer
self.vis_root = vis_root
self.annotation = []
for ann_path in ann_paths:
self.annotation.extend(json.load(open(ann_path, "r"))["data"])
self.vis_processor = vis_processor
self._add_instance_ids()
self.option_prob = 0.5
self.prompter = VQAPrompter()
self.add_eos = add_eos
self.ignore_instruction = ignore_instruction
def process_image(self, ann):
image_path = os.path.join(self.vis_root, ann["image_id"] + ".jpg")
image = Image.open(image_path).convert("RGB")
image = self.vis_processor(image)
return image
def process_text(self, ann):
question = ann["question"]
answer_weight = {}
for answer in ann["answers"]:
if answer in answer_weight.keys():
answer_weight[answer] += 1 / len(ann["answers"])
else:
answer_weight[answer] = 1 / len(ann["answers"])
answers = list(answer_weight.keys())
weights = list(answer_weight.values())
# create instruction
true_answer = answers[np.argmax(weights)]
is_option = random.random() < self.option_prob and len(answers) > 1
if is_option:
instruction = self.prompter(question, answers)
else:
instruction = self.prompter(question)
return dict(instruction=instruction, answer=true_answer)
class VQADataset(Dataset):
def __init__(
self,
tokenizer,
vis_processor=None,
vis_root=None,
ann_paths=[],
add_eos=True,
ignore_instruction=True,
sample_image=False,
):
"""
vis_root (string): Root directory of images (e.g. coco/images/)
ann_root (string): directory to store the annotation file
"""
assert tokenizer.add_eos_token is False, "tokenizer should not add eos token by default"
self.tokenizer: LlamaTokenizer = tokenizer
self.vis_root = vis_root
self.annotation = []
for ann_path in ann_paths:
self.annotation.extend(json.load(open(ann_path, "r")))
self.sample_image = sample_image
if self.sample_image:
print("randomly sample one annotation for each image")
self.annotation = self.parse_annotation(self.annotation)
self.vis_processor = vis_processor
self._add_instance_ids()
self.option_prob = 0.5
self.prompter = VQAPrompter()
self.add_eos = add_eos
self.ignore_instruction = ignore_instruction
def parse_annotation(self, annotation):
image_list = defaultdict(list)
for ann in annotation:
image_list[ann["image"]].append(ann)
# image_name_list = list(image_list.keys())
annotation = []
for ann_list in image_list.values():
annotation.append(random.choice(ann_list))
return annotation
def __len__(self):
return len(self.annotation)
def _add_instance_ids(self, key="instance_id"):
for idx, ann in enumerate(self.annotation):
ann[key] = str(idx)
def process_image(self, ann):
image_path = os.path.join(self.vis_root, ann["image"])
image = Image.open(image_path).convert("RGB")
image = self.vis_processor(image)
return image
def process_text(self, ann):
question = ann["question"]
answer_weight = {}
for answer in ann["answer"]:
if answer in answer_weight.keys():
answer_weight[answer] += 1 / len(ann["answer"])
else:
answer_weight[answer] = 1 / len(ann["answer"])
answers = list(answer_weight.keys())
weights = list(answer_weight.values())
# create instruction
true_answer = answers[np.argmax(weights)]
is_option = random.random() < self.option_prob and len(answers) > 1
if is_option:
instruction = self.prompter(question, answers)
else:
instruction = self.prompter(question)
return dict(instruction=instruction, answer=true_answer)
def tokenize(self, text):
res = self.tokenizer(
text["instruction"] + text["answer"],
return_tensors=None,
padding="do_not_pad",
truncation=True,
max_length=512,
)
# manually add eos token
if res["input_ids"][-1] != self.tokenizer.eos_token_id and len(res["input_ids"]) < 512 and self.add_eos:
res["input_ids"].append(self.tokenizer.eos_token_id)
res["attention_mask"].append(1)
labels = copy.deepcopy(res["input_ids"])
# ignore instruction_token
if self.ignore_instruction:
instruction_token = self.tokenizer(
text["instruction"], return_tensors=None, padding="do_not_pad", truncation=True, max_length=512
)
labels = [-100] * len(instruction_token["input_ids"]) + labels[len(instruction_token["input_ids"]) :]
res.update(labels=labels)
return res
def __getitem__(self, index):
ann = self.annotation[index]
image = self.process_image(ann)
text = self.process_text(ann)
res = self.tokenize(text)
res.update(image=image)
res.update(text)
return res
def collater(self, samples):
image_list, question_list, answer_list, input_id_list, attention_mask_list, labels_list = [], [], [], [], [], []
for sample in samples:
image_list.append(sample["image"])
question_list.append(sample["instruction"])
answer_list.append(sample["answer"])
input_id_list.append(sample["input_ids"])
attention_mask_list.append(sample["attention_mask"])
labels_list.append(sample["labels"])
# We have to pad the labels before calling `tokenizer.pad` as this method won't pad them and needs them of the
# same length to return tensors.
max_label_length = max(len(l) for l in labels_list)
padding_side = self.tokenizer.padding_side
padded_labels = []
for l in labels_list:
remainder = [-100] * (max_label_length - len(l))
if isinstance(l, list):
l = l + remainder if padding_side == "right" else remainder + l
elif padding_side == "right":
l = np.concatenate([l, remainder]).astype(np.int64)
else:
l = np.concatenate([remainder, l]).astype(np.int64)
padded_labels.append(l)
padded_samples = self.tokenizer.pad(
{"input_ids": input_id_list, "attention_mask": attention_mask_list, "labels": padded_labels},
return_tensors="pt",
padding="longest",
)
labels = padded_samples["labels"]
media_token_id = self.tokenizer("<image>", add_special_tokens=False)["input_ids"][-1]
labels[labels == self.tokenizer.pad_token_id] = -100
labels[:, 0] = -100
labels[labels == media_token_id] = -100
return {
"image": torch.stack(image_list, dim=0),
"input_ids": padded_samples["input_ids"],
"attention_mask": padded_samples["attention_mask"],
"labels": labels,
"instruction": question_list,
"answer": answer_list,
}
class ConcatDataset(ConcatDataset):
def __init__(self, datasets: Iterable[Dataset]) -> None:
super().__init__(datasets)
def collater(self, samples):
# TODO For now only supports datasets with same underlying collater implementations
all_keys = set()
for s in samples:
all_keys.update(s)
shared_keys = all_keys
for s in samples:
shared_keys = shared_keys & set(s.keys())
samples_shared_keys = []
for s in samples:
samples_shared_keys.append({k: s[k] for k in s.keys() if k in shared_keys})
return self.datasets[0].collater(samples_shared_keys)
class BaiZeDataset(DollyDataset):
"""
```json
[
{
"instruction": "Identify the odd one out.",
"input": "Twitter, Instagram, Telegram",
"output": "The odd one out is Telegram. Twitter and Instagram are social media platforms mainly for sharing information, images and videos while Telegram is a cloud-based instant messaging and voice-over-IP service."
},
]
"""
def __init__(self, *args, **kwargs):
super(BaiZeDataset, self).__init__(*args, **kwargs)
self.prompter = LangDialPrompter()
def load_annotation(self, ann_path):
self.annotation = json.load(open(ann_path, "r"))
def process_text(self, anns):
# TODO remove this
begin_string = "Below is an instruction that describes a task. Write a response that appropriately completes the request."
convs = anns['input'].split("[|Human|] ")
conv_list = []
for conv_id, one_conv in enumerate(convs[1:-1]):
question, answer = one_conv.split("[|AI|] ")
question = question.replace("\n", "")
answer = answer.replace("\n", "")
instruction = self.prompter(question)
if conv_id == 0:
single_conv = dict(instruction=begin_string + instruction, answer=answer)
else:
single_conv = dict(instruction=instruction, answer=answer)
conv_list.append(single_conv)
return conv_list
def __getitem__(self, index):
ann = self.annotation[index]
text_list = self.process_text(ann)
res_list = []
for text in text_list:
single_res = self.tokenize(text)
single_res["instruction"] = text["instruction"]
single_res["answer"] = text["answer"]
res_list.append(single_res)
input_ids = []
attention_mask = []
labels = []
instruction = []
answer = []
for res in res_list:
input_ids.extend(res["input_ids"])
attention_mask.extend(res["attention_mask"])
labels.extend(res["labels"])
instruction.append(res["instruction"])
answer.append(res["answer"])
res = dict(
input_ids=input_ids, attention_mask=attention_mask, labels=labels, instruction=instruction, answer=answer
)
return res
def build_dataset(dataset_config, **kwargs):
if isinstance(dataset_config, list):
datasets = [build_dataset(cfg, **kwargs) for cfg in dataset_config]
return ConcatDataset(datasets)
dataset_type = dataset_config.pop("type")
sample = dataset_config.pop("sample", -1)
if dataset_type == "llava":
dataset = LlavaDataset(
**dataset_config,
**kwargs,
)
elif dataset_type == "vqa":
dataset = VQADataset(
**dataset_config,
**kwargs,
)
elif dataset_type == "minigpt4":
dataset = CcSbuAlignDataset(
**dataset_config,
**kwargs,
)
elif dataset_type == "llava_dial":
dataset = DialDataset(
**dataset_config,
**kwargs,
)
elif dataset_type == "coco_dial":
dataset = DialDataset(
**dataset_config,
**kwargs,
)
elif dataset_type == "aokvqa":
dataset = AOKVQADataset(
**dataset_config,
**kwargs,
)
elif dataset_type == "okvqa":
dataset = VQADataset(
**dataset_config,
**kwargs,
)
elif dataset_type == "text_ocr":
dataset = TextOCRDataset(
**dataset_config,
**kwargs,
)
elif dataset_type == "ocr_vqa":
dataset = OCRVQADataset(
**dataset_config,
**kwargs,
)
elif dataset_type == "coco_caption":
dataset = COCOCaptionDataset(
**dataset_config,
**kwargs,
)
elif dataset_type == "gqa":
dataset = GQADataset(
**dataset_config,
**kwargs,
)
elif dataset_type == "clevr":
dataset = CLEVRDataset(
**dataset_config,
**kwargs,
)
elif dataset_type == "nlvrv1":
dataset = NLVRv1Dataset(
**dataset_config,
**kwargs,
)
elif dataset_type == "nlvrv2":
dataset = NLVRv2Dataset(
**dataset_config,
**kwargs,
)
elif dataset_type == "snlive":
dataset = SNLIVEDataset(
**dataset_config,
**kwargs,
)
elif dataset_type == "dolly":
dataset = DollyDataset(
**dataset_config,
**kwargs,
)
elif dataset_type == "alpaca_gpt4":
dataset = AlpacaGPT4Dataset(
**dataset_config,
**kwargs,
)
elif dataset_type == "baize":
dataset = BaiZeDataset(
**dataset_config,
**kwargs,
)
else:
raise NotImplementedError
if sample > 0:
random_indices = np.random.choice(len(dataset), min(sample, len(dataset)), replace=False)
subsample_dataset = torch.utils.data.Subset(dataset, random_indices)
subsample_dataset.collater = dataset.collater
return subsample_dataset
else:
return dataset | null |
188,074 | import json
import os
import random
from collections import defaultdict
from PIL import Image
from .vqa_dataset import VQADataset
class CLEVRDataset(VQADataset):
"""Visual Reasoning Dataset. It also contains Dialog.
Note: The image is a little bit simple. with several objects and simple background.
"""
def __init__(self, tokenizer, vis_processor, vis_root, ann_paths, **kwargs):
super().__init__(tokenizer, vis_processor, vis_root, ann_paths=[], **kwargs)
self.annotation = self.load_annotations(ann_paths)
if self.sample_image:
print("randomly sample one annotation for each image")
self.annotation = self.parse_annotation(self.annotation)
self._add_instance_ids()
def load_annotations(ann_paths):
annotation = []
for ann_path in ann_paths:
ann = json.load(open(ann_path, "r"))
annotation.extend(ann["questions"])
return annotation
def parse_annotation(self, annotation):
image_list = defaultdict(list)
for ann in annotation:
image_list[ann["image_filename"]].append(ann)
annotation = []
for ann_list in image_list.values():
annotation.append(random.choice(ann_list))
return annotation
def process_text(self, ann):
question = ann["question"]
answer = ann["answer"]
instruction = self.prompter(question)
return dict(instruction=instruction, answer=answer)
def process_image(self, ann):
split = ann["split"]
image_path = os.path.join(self.vis_root, split, ann["image_filename"])
image = Image.open(image_path).convert("RGB")
image = self.vis_processor(image)
return image
def build_clevr_dataset(
tokenizer,
vis_processor,
vis_root="data/clevr/CLEVR_v1.0/images",
ann_paths=[
"data/clevr/CLEVR_v1.0/questions/CLEVR_train_questions.json",
"data/clevr/CLEVR_v1.0/questions/CLEVR_val_questions.json",
],
sample_image=False,
):
return CLEVRDataset(
tokenizer=tokenizer,
vis_processor=vis_processor,
vis_root=vis_root,
ann_paths=ann_paths,
sample_image=sample_image,
) | null |
188,078 | import open_clip
import torch
import torch.nn as nn
from bigmodelvis import Visualization
from peft import LoraConfig, get_peft_model
from transformers import LlamaForCausalLM, LlamaTokenizer
from .flamingo import Flamingo
from .flamingo_lm import FlamingoLMMixin
from .utils import extend_instance
def _infer_decoder_layers_attr_name(model):
for k in __KNOWN_DECODER_LAYERS_ATTR_NAMES:
if k.lower() in model.__class__.__name__.lower():
return __KNOWN_DECODER_LAYERS_ATTR_NAMES[k]
raise ValueError(
f"We require the attribute name for the nn.ModuleList in the decoder storing the transformer block layers. Please supply this string manually."
)
def prepare_model_for_tuning(model: nn.Module, config):
if config.lora:
lora_config = LoraConfig(
r=config.lora_r,
lora_alpha=config.lora_alpha,
target_modules=config.lora_target_modules,
lora_dropout=config.lora_dropout,
bias="none", # won't use bias currently
modules_to_save=[], # TODO: might be helpful if save partial model
task_type="VL",
)
model.lang_encoder = get_peft_model(model.lang_encoder, peft_config=lora_config)
# manually unfreeze modules, we use a `substring` fashion mathcing
for name, param in model.named_parameters():
if any(substr in name for substr in config.unfrozen):
param.requires_grad = True
if config.vis and is_rank0():
Visualization(model).structure_graph()
return model
class Flamingo(nn.Module):
def __init__(
self,
vision_encoder: nn.Module,
lang_encoder: nn.Module,
eoc_token_id: int,
media_token_id: int,
vis_dim: int,
cross_attn_every_n_layers: int = 1,
use_media_placement_augmentation: bool = False,
):
"""
Args:
vision_encoder (nn.Module): HF CLIPModel
lang_encoder (nn.Module): HF causal language model
eoc_token_id (int): Token id for <|endofchunk|>
media_token_id (int): Token id for <image>
vis_dim (int): Dimension of the visual features.
Visual features are projected to match this shape along the last dimension.
cross_attn_every_n_layers (int, optional): How often to apply cross attention after transformer layer. Defaults to 1.
use_media_placement_augmentation (bool, optional): Whether to randomly assign images to the preceding or following text in training. Defaults to False.
"""
super().__init__()
self.eoc_token_id = eoc_token_id
self.media_token_id = media_token_id
self.use_media_placement_augmentation = use_media_placement_augmentation
self.vis_dim = vis_dim
self.vision_encoder = vision_encoder
self.perceiver = PerceiverResampler(dim=self.vis_dim)
self.lang_encoder = lang_encoder
self.lang_encoder.init_flamingo(
media_token_id=media_token_id,
vis_hidden_size=self.vis_dim,
cross_attn_every_n_layers=cross_attn_every_n_layers,
use_media_placement_augmentation=self.use_media_placement_augmentation,
)
def forward(
self,
vision_x: torch.Tensor,
lang_x: torch.Tensor,
attention_mask: torch.Tensor = None,
labels: torch.Tensor = None,
use_cached_vision_x: bool = False,
clear_conditioned_layers: bool = True,
past_key_values=None,
use_cache: bool = False,
):
"""
Forward pass of Flamingo.
Args:
vision_x (torch.Tensor): Vision input
shape (B, T_img, F, C, H, W) with F=1
lang_x (torch.Tensor): Language input ids
shape (B, T_txt)
attention_mask (torch.Tensor, optional): Attention mask. Defaults to None.
labels (torch.Tensor, optional): Labels. Defaults to None.
clear_conditioned_layers: if True, clear the conditioned layers
once the foward pass is completed. Set this to false if the
same set of images will be reused in another subsequent
forward pass.
past_key_values: pre-computed values to pass to language model.
See past_key_values documentation in Hugging Face
CausalLM models.
use_cache: whether to use cached key values. See use_cache
documentation in Hugging Face CausalLM models.
"""
if vision_x is None and use_cached_vision_x is False:
for layer in self.lang_encoder._get_decoder_layers():
layer.condition_only_lang_x(True)
output = self.lang_encoder(
input_ids=lang_x,
attention_mask=attention_mask,
labels=labels,
past_key_values=past_key_values,
use_cache=use_cache,
)
for layer in self.lang_encoder._get_decoder_layers():
layer.condition_only_lang_x(False)
return output
assert (
vision_x is not None
) or use_cached_vision_x, "Must provide either vision_x or use_cached_vision_x to True."
if use_cached_vision_x:
# Case: use cached; vision_x should be cached and other
# vision-related inputs should not be provided.
assert vision_x is None, "Expect vision_x to be None when use_cached_vision_x is True."
assert self.lang_encoder.is_conditioned()
else:
# Case: do not use caching (i.e. this is a standard forward pass);
self._encode_vision_x(vision_x=vision_x)
output = self.lang_encoder(
input_ids=lang_x,
attention_mask=attention_mask,
labels=labels,
past_key_values=past_key_values,
use_cache=use_cache,
)
if clear_conditioned_layers:
self.lang_encoder.clear_conditioned_layers()
return output
def generate(
self,
vision_x: torch.Tensor,
lang_x: torch.Tensor,
attention_mask: torch.Tensor = None,
num_beams=1,
max_new_tokens=None,
temperature=1.0,
top_k=0,
top_p=1.0,
no_repeat_ngram_size=0,
prefix_allowed_tokens_fn=None,
length_penalty=1.0,
num_return_sequences=1,
do_sample=False,
early_stopping=False,
):
"""
Generate text conditioned on vision and language inputs.
Args:
vision_x (torch.Tensor): Vision input
shape (B, T_img, F, C, H, W)
images in the same chunk are collated along T_img, and frames are collated along F
currently only F=1 is supported (single-frame videos)
lang_x (torch.Tensor): Language input
shape (B, T_txt)
max_length (int, optional): Maximum length of the output. Defaults to None.
attention_mask (torch.Tensor, optional): Attention mask. Defaults to None.
num_beams (int, optional): Number of beams. Defaults to 1.
max_new_tokens (int, optional): Maximum new tokens. Defaults to None.
temperature (float, optional): Temperature. Defaults to 1.0.
top_k (int, optional): Top k. Defaults to 0.
top_p (float, optional): Top p. Defaults to 1.0.
no_repeat_ngram_size (int, optional): No repeat ngram size. Defaults to 0.
length_penalty (float, optional): Length penalty. Defaults to 1.0.
num_return_sequences (int, optional): Number of return sequences. Defaults to 1.
do_sample (bool, optional): Do sample. Defaults to False.
early_stopping (bool, optional): Early stopping. Defaults to False.
Returns:
torch.Tensor: lang_x with generated tokens appended to it
"""
if num_beams > 1:
vision_x = vision_x.repeat_interleave(num_beams, dim=0)
self._encode_vision_x(vision_x=vision_x)
output = self.lang_encoder.generate(
lang_x,
attention_mask=attention_mask,
# eos_token_id=self.eoc_token_id,
num_beams=num_beams,
max_new_tokens=max_new_tokens,
temperature=temperature,
top_k=top_k,
top_p=top_p,
prefix_allowed_tokens_fn=prefix_allowed_tokens_fn,
no_repeat_ngram_size=no_repeat_ngram_size,
length_penalty=length_penalty,
num_return_sequences=num_return_sequences,
do_sample=do_sample,
early_stopping=early_stopping,
)
self.lang_encoder.clear_conditioned_layers()
return output
def _encode_vision_x(self, vision_x: torch.Tensor):
"""
Compute media tokens from vision input by passing it through vision encoder and conditioning language model.
Args:
vision_x (torch.Tensor): Vision input
shape (B, T_img, F, C, H, W)
Images in the same chunk are collated along T_img, and frames are collated along F
Currently only F=1 is supported (single-frame videos)
rearrange code based on https://github.com/dhansmair/flamingo-mini
"""
assert vision_x.ndim == 6, "vision_x should be of shape (b, T_img, F, C, H, W)"
b, T, F = vision_x.shape[:3]
assert F == 1, "Only single frame supported"
vision_x = rearrange(vision_x, "b T F c h w -> (b T F) c h w")
with torch.no_grad():
vision_x = self.vision_encoder.visual(vision_x)[1]
vision_x = rearrange(vision_x, "(b T F) v d -> b T F v d", b=b, T=T, F=F)
vision_x = self.perceiver(vision_x) # reshapes to (b, T, n, d)
for layer in self.lang_encoder._get_decoder_layers():
layer.condition_vis_x(vision_x)
class FlamingoLMMixin(nn.Module):
"""
Mixin to add cross-attention layers to a language model.
"""
def set_decoder_layers_attr_name(self, decoder_layers_attr_name):
self.decoder_layers_attr_name = decoder_layers_attr_name
def _get_decoder_layers(self):
return getattr_recursive(self, self.decoder_layers_attr_name)
def _set_decoder_layers(self, value):
setattr_recursive(self, self.decoder_layers_attr_name, value)
def init_flamingo(
self,
media_token_id,
vis_hidden_size,
cross_attn_every_n_layers,
use_media_placement_augmentation,
):
"""
Initialize Flamingo by adding a new gated cross attn to the decoder. Store the media token id for computing the media locations.
"""
self.gated_cross_attn_layers = nn.ModuleList(
[
GatedCrossAttentionBlock(dim=self.config.hidden_size, dim_visual=vis_hidden_size)
if (layer_idx + 1) % cross_attn_every_n_layers == 0
else None
for layer_idx, _ in enumerate(self._get_decoder_layers())
]
)
self._set_decoder_layers(
nn.ModuleList(
[
FlamingoLayer(gated_cross_attn_layer, decoder_layer)
for gated_cross_attn_layer, decoder_layer in zip(
self.gated_cross_attn_layers, self._get_decoder_layers()
)
]
)
)
self.media_token_id = media_token_id
self.use_media_placement_augmentation = use_media_placement_augmentation
self.initialized_flamingo = True
def forward(self, *input, **kwargs):
"""Condition the Flamingo layers on the media locations before forward()"""
if not self.initialized_flamingo:
raise ValueError("Flamingo layers are not initialized. Please call `init_flamingo` first.")
input_ids = kwargs["input_ids"] if "input_ids" in kwargs else input[0]
media_locations = input_ids == self.media_token_id
attend_previous = (random.random() < 0.5) if self.use_media_placement_augmentation else False
for layer in self.get_decoder().layers:
layer.condition_media_locations(media_locations)
layer.condition_attend_previous(attend_previous)
return super().forward(*input, **kwargs) # Call the other parent's forward method
def is_conditioned(self) -> bool:
"""Check whether all decoder layers are already conditioned."""
return all(l.is_conditioned() for l in self._get_decoder_layers())
def clear_conditioned_layers(self):
for layer in self._get_decoder_layers():
layer.condition_vis_x(None)
layer.condition_media_locations(None)
layer.condition_attend_previous(None)
def extend_instance(obj, mixin):
"""Apply mixins to a class instance after creation"""
base_cls = obj.__class__
base_cls_name = obj.__class__.__name__
obj.__class__ = type(
base_cls_name, (mixin, base_cls), {}
) # mixin needs to go first for our forward() logic to work
The provided code snippet includes necessary dependencies for implementing the `create_model_and_transforms` function. Write a Python function `def create_model_and_transforms( clip_vision_encoder_path: str, clip_vision_encoder_pretrained: str, lang_encoder_path: str, tokenizer_path: str, decoder_layers_attr_name: str = None, pretrained_model_path: str = None, tuning_config=None, **flamingo_kwargs, )` to solve the following problem:
Initialize a Flamingo model from a pretrained vision encoder and language encoder. Appends special tokens to the tokenizer and freezes backbones. Args: clip_vision_encoder_path (str): path to pretrained clip model (e.g. "ViT-B-32") clip_vision_encoder_pretrained (str): name of pretraining dataset for clip model (e.g. "laion2b_s32b_b79k") lang_encoder_path (str): path to pretrained language encoder tokenizer_path (str): path to pretrained tokenizer decoder_layers_attr_name (str, optional): name of the decoder layers attribute. Defaults to None. Returns: Flamingo: Flamingo model from pretrained vision and language encoders Image processor: Pipeline to preprocess input images Tokenizer: A tokenizer for the language model
Here is the function:
def create_model_and_transforms(
clip_vision_encoder_path: str,
clip_vision_encoder_pretrained: str,
lang_encoder_path: str,
tokenizer_path: str,
decoder_layers_attr_name: str = None,
pretrained_model_path: str = None,
tuning_config=None,
**flamingo_kwargs,
):
"""
Initialize a Flamingo model from a pretrained vision encoder and language encoder.
Appends special tokens to the tokenizer and freezes backbones.
Args:
clip_vision_encoder_path (str): path to pretrained clip model (e.g. "ViT-B-32")
clip_vision_encoder_pretrained (str): name of pretraining dataset for clip model (e.g. "laion2b_s32b_b79k")
lang_encoder_path (str): path to pretrained language encoder
tokenizer_path (str): path to pretrained tokenizer
decoder_layers_attr_name (str, optional): name of the decoder layers attribute. Defaults to None.
Returns:
Flamingo: Flamingo model from pretrained vision and language encoders
Image processor: Pipeline to preprocess input images
Tokenizer: A tokenizer for the language model
"""
print("init clip vision encoder")
vision_encoder, _, image_processor = open_clip.create_model_and_transforms(
clip_vision_encoder_path, pretrained=clip_vision_encoder_pretrained
)
# set the vision encoder to output the visual features
vision_encoder.visual.output_tokens = True
print("init tokenizer")
text_tokenizer = LlamaTokenizer.from_pretrained(tokenizer_path)
# add Flamingo special tokens to the tokenizer
text_tokenizer.add_special_tokens({"additional_special_tokens": ["<|endofchunk|>", "<image>"]})
if text_tokenizer.pad_token is None:
# Issue: GPT models don't have a pad token, which we use to
# modify labels for the loss.
text_tokenizer.add_special_tokens({"pad_token": "<PAD>"})
text_tokenizer.bos_token_id = 1
text_tokenizer.eos_token_id = 2
print("init llama")
lang_encoder = LlamaForCausalLM.from_pretrained(lang_encoder_path)
extend_instance(lang_encoder, FlamingoLMMixin)
if decoder_layers_attr_name is None:
decoder_layers_attr_name = _infer_decoder_layers_attr_name(lang_encoder)
lang_encoder.set_decoder_layers_attr_name(decoder_layers_attr_name)
lang_encoder.resize_token_embeddings(len(text_tokenizer))
model = Flamingo(
vision_encoder,
lang_encoder,
text_tokenizer.encode("<|endofchunk|>")[-1],
text_tokenizer.encode("<image>")[-1],
vis_dim=open_clip.get_model_config(clip_vision_encoder_path)["vision_cfg"]["width"],
cross_attn_every_n_layers=4,
**flamingo_kwargs,
)
if pretrained_model_path is not None:
print(f"loading pretrained model from {pretrained_model_path}")
model.load_state_dict(torch.load(pretrained_model_path), strict=False)
# Freeze all parameters
model.requires_grad_(False)
assert sum(p.numel() for p in model.parameters() if p.requires_grad) == 0
if tuning_config is not None:
model = prepare_model_for_tuning(model, tuning_config)
else:
raise ValueError("tuning_config must be provided")
print(
f"Flamingo model initialized with {sum(p.numel() for p in model.parameters() if p.requires_grad)} trainable parameters"
)
return model, image_processor, text_tokenizer | Initialize a Flamingo model from a pretrained vision encoder and language encoder. Appends special tokens to the tokenizer and freezes backbones. Args: clip_vision_encoder_path (str): path to pretrained clip model (e.g. "ViT-B-32") clip_vision_encoder_pretrained (str): name of pretraining dataset for clip model (e.g. "laion2b_s32b_b79k") lang_encoder_path (str): path to pretrained language encoder tokenizer_path (str): path to pretrained tokenizer decoder_layers_attr_name (str, optional): name of the decoder layers attribute. Defaults to None. Returns: Flamingo: Flamingo model from pretrained vision and language encoders Image processor: Pipeline to preprocess input images Tokenizer: A tokenizer for the language model |
188,079 | from .open_flamingo import create_model_and_transforms as create_open_flamingo_model_and_transforms
import torch.nn as nn
from transformers import LlamaTokenizer, LlamaForCausalLM
def create_model_and_transforms(
model_name: str,
clip_vision_encoder_path: str,
clip_vision_encoder_pretrained: str,
lang_encoder_path: str,
tokenizer_path: str,
tuning_config,
pretrained_model_path,
**kwargs,
):
if model_name == "open_flamingo":
return create_open_flamingo_model_and_transforms(
clip_vision_encoder_path=clip_vision_encoder_path,
clip_vision_encoder_pretrained=clip_vision_encoder_pretrained,
lang_encoder_path=lang_encoder_path,
tokenizer_path=tokenizer_path,
tuning_config=tuning_config,
pretrained_model_path=pretrained_model_path,
**kwargs,
)
# TODO: support BLIP2
else:
raise ValueError(f"Unknown model name: {model_name}") | null |
188,080 | from .open_flamingo import create_model_and_transforms as create_open_flamingo_model_and_transforms
import torch.nn as nn
from transformers import LlamaTokenizer, LlamaForCausalLM
def create_toy_model_and_transforms(
model_name: str,
clip_vision_encoder_path: str,
clip_vision_encoder_pretrained: str,
lang_encoder_path: str,
tokenizer_path: str,
tuning_config,
pretrained_model_path,
**kwargs,
):
print("init toy vision encoder")
import torchvision
image_processor = torchvision.transforms.Compose(
[
torchvision.transforms.Resize((224, 224)),
torchvision.transforms.ToTensor(),
]
)
print("init tokenizer")
text_tokenizer = LlamaTokenizer.from_pretrained(tokenizer_path)
# add Flamingo special tokens to the tokenizer
text_tokenizer.add_special_tokens({"additional_special_tokens": ["<|endofchunk|>", "<image>"]})
if text_tokenizer.pad_token is None:
# Issue: GPT models don't have a pad token, which we use to
# modify labels for the loss.
text_tokenizer.add_special_tokens({"pad_token": "<PAD>"})
class ToyModel(nn.Module):
def __init__(self, *args, **kwargs):
super().__init__()
self.input_embeddings = nn.Embedding(38000, 512)
self.layer = nn.Linear(512, 512)
self.config = {"hidden_size": 512}
def forward(self, lang_x, **kwargs):
x = self.input_embeddings(lang_x)
x = self.layer(x)
loss = x.sum()
return (loss,)
model = ToyModel()
return model, image_processor, text_tokenizer | null |
188,081 | import os
import gradio as gr
import torch
from PIL import Image
from mmgpt.models.builder import create_model_and_transforms
TEMPLATE = "Below is an instruction that describes a task. Write a response that appropriately completes the request."
class PromptGenerator:
def __init__(
self,
prompt_template=TEMPLATE,
ai_prefix="Response",
user_prefix="Instruction",
sep: str = "\n\n### ",
buffer_size=0,
):
def add_message(self, role, message):
def get_images(self):
def get_prompt(self):
def bot(
text,
image,
state,
prompt,
ai_prefix,
user_prefix,
seperator,
history_buffer,
max_new_token,
num_beams,
temperature,
top_k,
top_p,
do_sample,
):
def clear(state):
title_markdown = ("""
# 🤖 Multi-modal GPT
[[Project]](https://github.com/open-mmlab/Multimodal-GPT.git)""")
def build_conversation_demo():
with gr.Blocks(title="Multi-modal GPT") as demo:
gr.Markdown(title_markdown)
state = gr.State(PromptGenerator())
with gr.Row():
with gr.Column(scale=3):
memory_allocated = gr.Textbox(
value=init_memory, label="Memory")
imagebox = gr.Image(type="filepath")
# TODO config parameters
with gr.Accordion(
"Parameters",
open=True,
):
max_new_token_bar = gr.Slider(
0, 1024, 512, label="max_new_token", step=1)
num_beams_bar = gr.Slider(
0.0, 10, 3, label="num_beams", step=1)
temperature_bar = gr.Slider(
0.0, 1.0, 1.0, label="temperature", step=0.01)
topk_bar = gr.Slider(0, 100, 20, label="top_k", step=1)
topp_bar = gr.Slider(0, 1.0, 1.0, label="top_p", step=0.01)
do_sample = gr.Checkbox(True, label="do_sample")
with gr.Accordion(
"Prompt",
open=False,
):
with gr.Row():
ai_prefix = gr.Text("Response", label="AI Prefix")
user_prefix = gr.Text(
"Instruction", label="User Prefix")
seperator = gr.Text("\n\n### ", label="Seperator")
history_buffer = gr.Slider(
-1, 10, -1, label="History buffer", step=1)
prompt = gr.Text(TEMPLATE, label="Prompt")
model_inputs = gr.Textbox(label="Actual inputs for Model")
with gr.Column(scale=6):
with gr.Row():
with gr.Column():
chatbot = gr.Chatbot(elem_id="chatbot").style(
height=750)
with gr.Row():
with gr.Column(scale=8):
textbox = gr.Textbox(
show_label=False,
placeholder="Enter text and press ENTER",
).style(container=False)
submit_btn = gr.Button(value="Submit")
clear_btn = gr.Button(value="🗑️ Clear history")
cur_dir = os.path.dirname(os.path.abspath(__file__))
gr.Examples(
examples=[
[
f"{cur_dir}/docs/images/demo_image.jpg",
"What is in this image?"
],
],
inputs=[imagebox, textbox],
)
textbox.submit(
bot,
[
textbox,
imagebox,
state,
prompt,
ai_prefix,
user_prefix,
seperator,
history_buffer,
max_new_token_bar,
num_beams_bar,
temperature_bar,
topk_bar,
topp_bar,
do_sample,
],
[
state, chatbot, textbox, imagebox, model_inputs,
memory_allocated
],
)
submit_btn.click(
bot,
[
textbox,
imagebox,
state,
prompt,
ai_prefix,
user_prefix,
seperator,
history_buffer,
max_new_token_bar,
num_beams_bar,
temperature_bar,
topk_bar,
topp_bar,
do_sample,
],
[
state, chatbot, textbox, imagebox, model_inputs,
memory_allocated
],
)
clear_btn.click(clear, [state],
[state, chatbot, textbox, imagebox, model_inputs])
return demo | null |
188,082 | import nonebot
from nonebot import Driver
from configs.path_config import IMAGE_PATH
from services.log import logger
from utils.image_template import help_template
from utils.image_utils import BuildImage, build_sort_image, group_image, text2image
from utils.manager import group_manager, plugin_data_manager
from utils.manager.models import PluginType
class logger:
TEMPLATE_A = "{}"
TEMPLATE_B = "[<u><c>{}</c></u>]: {}"
TEMPLATE_C = "用户[<u><e>{}</e></u>] 触发 [<u><c>{}</c></u>]: {}"
TEMPLATE_D = "群聊[<u><e>{}</e></u>] 用户[<u><e>{}</e></u>] 触发 [<u><c>{}</c></u>]: {}"
TEMPLATE_E = "群聊[<u><e>{}</e></u>] 用户[<u><e>{}</e></u>] 触发 [<u><c>{}</c></u>] [Target](<u><e>{}</e></u>): {}"
TEMPLATE_USER = "用户[<u><e>{}</e></u>] "
TEMPLATE_GROUP = "群聊[<u><e>{}</e></u>] "
TEMPLATE_COMMAND = "CMD[<u><c>{}</c></u>] "
TEMPLATE_TARGET = "[Target]([<u><e>{}</e></u>]) "
SUCCESS_TEMPLATE = "[<u><c>{}</c></u>]: {} | 参数[{}] 返回: [<y>{}</y>]"
WARNING_TEMPLATE = "[<u><y>{}</y></u>]: {}"
ERROR_TEMPLATE = "[<u><r>{}</r></u>]: {}"
def info(
cls,
info: str,
command: Optional[str] = None,
user_id: Optional[Union[int, str]] = None,
group_id: Optional[Union[int, str]] = None,
target: Optional[Any] = None,
):
template = cls.__parser_template(info, command, user_id, group_id, target)
logger_.opt(colors=True).info(template)
def success(
cls,
info: str,
command: str,
param: Optional[Dict[str, Any]] = None,
result: Optional[str] = "",
):
param_str = ""
if param:
param_str = ",".join([f"<m>{k}</m>:<g>{v}</g>" for k, v in param.items()])
logger_.opt(colors=True).success(
cls.SUCCESS_TEMPLATE.format(command, info, param_str, result)
)
def warning(
cls,
info: str,
command: Optional[str] = None,
user_id: Optional[Union[int, str]] = None,
group_id: Optional[Union[int, str]] = None,
target: Optional[Any] = None,
e: Optional[Exception] = None,
):
template = cls.__parser_template(info, command, user_id, group_id, target)
if e:
template += f" || 错误<r>{type(e)}: {e}</r>"
logger_.opt(colors=True).warning(template)
def error(
cls,
info: str,
command: Optional[str] = None,
user_id: Optional[Union[int, str]] = None,
group_id: Optional[Union[int, str]] = None,
target: Optional[Any] = None,
e: Optional[Exception] = None,
):
template = cls.__parser_template(info, command, user_id, group_id, target)
if e:
template += f" || 错误 <r>{type(e)}: {e}</r>"
logger_.opt(colors=True).error(template)
def debug(
cls,
info: str,
command: Optional[str] = None,
user_id: Optional[Union[int, str]] = None,
group_id: Optional[Union[int, str]] = None,
target: Optional[Any] = None,
e: Optional[Exception] = None,
):
template = cls.__parser_template(info, command, user_id, group_id, target)
if e:
template += f" || 错误 <r>{type(e)}: {e}</r>"
logger_.opt(colors=True).debug(template)
def __parser_template(
cls,
info: str,
command: Optional[str] = None,
user_id: Optional[Union[int, str]] = None,
group_id: Optional[Union[int, str]] = None,
target: Optional[Any] = None,
) -> str:
arg_list = []
template = ""
if group_id is not None:
template += cls.TEMPLATE_GROUP
arg_list.append(group_id)
if user_id is not None:
template += cls.TEMPLATE_USER
arg_list.append(user_id)
if command is not None:
template += cls.TEMPLATE_COMMAND
arg_list.append(command)
if target is not None:
template += cls.TEMPLATE_TARGET
arg_list.append(target)
arg_list.append(info)
template += "{}"
return template.format(*arg_list)
async def init_task():
if not group_manager.get_task_data():
group_manager.load_task()
logger.info(f"已成功加载 {len(group_manager.get_task_data())} 个被动技能.") | null |
188,083 | import nonebot
from nonebot import Driver
from configs.path_config import IMAGE_PATH
from services.log import logger
from utils.image_template import help_template
from utils.image_utils import BuildImage, build_sort_image, group_image, text2image
from utils.manager import group_manager, plugin_data_manager
from utils.manager.models import PluginType
ADMIN_HELP_IMAGE = IMAGE_PATH / "admin_help_img.png"
class logger:
TEMPLATE_A = "{}"
TEMPLATE_B = "[<u><c>{}</c></u>]: {}"
TEMPLATE_C = "用户[<u><e>{}</e></u>] 触发 [<u><c>{}</c></u>]: {}"
TEMPLATE_D = "群聊[<u><e>{}</e></u>] 用户[<u><e>{}</e></u>] 触发 [<u><c>{}</c></u>]: {}"
TEMPLATE_E = "群聊[<u><e>{}</e></u>] 用户[<u><e>{}</e></u>] 触发 [<u><c>{}</c></u>] [Target](<u><e>{}</e></u>): {}"
TEMPLATE_USER = "用户[<u><e>{}</e></u>] "
TEMPLATE_GROUP = "群聊[<u><e>{}</e></u>] "
TEMPLATE_COMMAND = "CMD[<u><c>{}</c></u>] "
TEMPLATE_TARGET = "[Target]([<u><e>{}</e></u>]) "
SUCCESS_TEMPLATE = "[<u><c>{}</c></u>]: {} | 参数[{}] 返回: [<y>{}</y>]"
WARNING_TEMPLATE = "[<u><y>{}</y></u>]: {}"
ERROR_TEMPLATE = "[<u><r>{}</r></u>]: {}"
def info(
cls,
info: str,
command: Optional[str] = None,
user_id: Optional[Union[int, str]] = None,
group_id: Optional[Union[int, str]] = None,
target: Optional[Any] = None,
):
template = cls.__parser_template(info, command, user_id, group_id, target)
logger_.opt(colors=True).info(template)
def success(
cls,
info: str,
command: str,
param: Optional[Dict[str, Any]] = None,
result: Optional[str] = "",
):
param_str = ""
if param:
param_str = ",".join([f"<m>{k}</m>:<g>{v}</g>" for k, v in param.items()])
logger_.opt(colors=True).success(
cls.SUCCESS_TEMPLATE.format(command, info, param_str, result)
)
def warning(
cls,
info: str,
command: Optional[str] = None,
user_id: Optional[Union[int, str]] = None,
group_id: Optional[Union[int, str]] = None,
target: Optional[Any] = None,
e: Optional[Exception] = None,
):
template = cls.__parser_template(info, command, user_id, group_id, target)
if e:
template += f" || 错误<r>{type(e)}: {e}</r>"
logger_.opt(colors=True).warning(template)
def error(
cls,
info: str,
command: Optional[str] = None,
user_id: Optional[Union[int, str]] = None,
group_id: Optional[Union[int, str]] = None,
target: Optional[Any] = None,
e: Optional[Exception] = None,
):
template = cls.__parser_template(info, command, user_id, group_id, target)
if e:
template += f" || 错误 <r>{type(e)}: {e}</r>"
logger_.opt(colors=True).error(template)
def debug(
cls,
info: str,
command: Optional[str] = None,
user_id: Optional[Union[int, str]] = None,
group_id: Optional[Union[int, str]] = None,
target: Optional[Any] = None,
e: Optional[Exception] = None,
):
template = cls.__parser_template(info, command, user_id, group_id, target)
if e:
template += f" || 错误 <r>{type(e)}: {e}</r>"
logger_.opt(colors=True).debug(template)
def __parser_template(
cls,
info: str,
command: Optional[str] = None,
user_id: Optional[Union[int, str]] = None,
group_id: Optional[Union[int, str]] = None,
target: Optional[Any] = None,
) -> str:
arg_list = []
template = ""
if group_id is not None:
template += cls.TEMPLATE_GROUP
arg_list.append(group_id)
if user_id is not None:
template += cls.TEMPLATE_USER
arg_list.append(user_id)
if command is not None:
template += cls.TEMPLATE_COMMAND
arg_list.append(command)
if target is not None:
template += cls.TEMPLATE_TARGET
arg_list.append(target)
arg_list.append(info)
template += "{}"
return template.format(*arg_list)
async def help_template(title: str, usage: BuildImage) -> BuildImage:
"""
说明:
生成单个功能帮助模板
参数:
:param title: 标题
:param usage: 说明图片
"""
title_image = BuildImage(
0,
0,
font_size=35,
plain_text=title,
font_color=(255, 255, 255),
font="CJGaoDeGuo.otf",
)
background_image = BuildImage(
max(title_image.w, usage.w) + 50,
max(title_image.h, usage.h) + 100,
color=(114, 138, 204),
)
await background_image.apaste(usage, (25, 80), True)
await background_image.apaste(title_image, (25, 20), True)
await background_image.aline(
(25, title_image.h + 22, 25 + title_image.w, title_image.h + 22),
(204, 196, 151),
3,
)
return background_image
class BuildImage:
"""
快捷生成图片与操作图片的工具类
"""
def __init__(
self,
w: int,
h: int,
paste_image_width: int = 0,
paste_image_height: int = 0,
paste_space: int = 0,
color: Union[str, Tuple[int, int, int], Tuple[int, int, int, int]] = None,
image_mode: ModeType = "RGBA",
font_size: int = 10,
background: Union[Optional[str], BytesIO, Path] = None,
font: str = "yz.ttf",
ratio: float = 1,
is_alpha: bool = False,
plain_text: Optional[str] = None,
font_color: Optional[Union[str, Tuple[int, int, int]]] = None,
**kwargs,
):
"""
参数:
:param w: 自定义图片的宽度，w=0时为图片原本宽度
:param h: 自定义图片的高度，h=0时为图片原本高度
:param paste_image_width: 当图片做为背景图时，设置贴图的宽度，用于贴图自动换行
:param paste_image_height: 当图片做为背景图时，设置贴图的高度，用于贴图自动换行
:param paste_space: 自动贴图间隔
:param color: 生成图片的颜色
:param image_mode: 图片的类型
:param font_size: 文字大小
:param background: 打开图片的路径
:param font: 字体，默认在 resource/ttf/ 路径下
:param ratio: 倍率压缩
:param is_alpha: 是否背景透明
:param plain_text: 纯文字文本
"""
self.w = int(w)
self.h = int(h)
self.paste_image_width = int(paste_image_width)
self.paste_image_height = int(paste_image_height)
self.paste_space = int(paste_space)
self._current_w = 0
self._current_h = 0
self.uid = uuid.uuid1()
self.font_name = font
self.font_size = font_size
self.font = ImageFont.truetype(str(FONT_PATH / font), int(font_size))
if not plain_text and not color:
color = (255, 255, 255)
self.background = background
if not background:
if plain_text:
if not color:
color = (255, 255, 255, 0)
ttf_w, ttf_h = self.getsize(str(plain_text))
self.w = self.w if self.w > ttf_w else ttf_w
self.h = self.h if self.h > ttf_h else ttf_h
self.markImg = Image.new(image_mode, (self.w, self.h), color)
self.markImg.convert(image_mode)
else:
if not w and not h:
self.markImg = Image.open(background)
w, h = self.markImg.size
if ratio and ratio > 0 and ratio != 1:
self.w = int(ratio * w)
self.h = int(ratio * h)
self.markImg = self.markImg.resize(
(self.w, self.h), Image.ANTIALIAS
)
else:
self.w = w
self.h = h
else:
self.markImg = Image.open(background).resize(
(self.w, self.h), Image.ANTIALIAS
)
if is_alpha:
try:
if array := self.markImg.load():
for i in range(w):
for j in range(h):
pos = array[i, j]
is_edit = sum([1 for x in pos[0:3] if x > 240]) == 3
if is_edit:
array[i, j] = (255, 255, 255, 0)
except Exception as e:
logger.warning(f"背景透明化发生错误..{type(e)}：{e}")
self.draw = ImageDraw.Draw(self.markImg)
self.size = self.w, self.h
if plain_text:
fill = font_color if font_color else (0, 0, 0)
self.text((0, 0), str(plain_text), fill)
try:
self.loop = asyncio.get_event_loop()
except RuntimeError:
new_loop = asyncio.new_event_loop()
asyncio.set_event_loop(new_loop)
self.loop = asyncio.get_event_loop()
def load_font(cls, font: str, font_size: Optional[int]) -> FreeTypeFont:
"""
说明:
加载字体
参数:
:param font: 字体名称
:param font_size: 字体大小
"""
return ImageFont.truetype(str(FONT_PATH / font), font_size or cls.font_size)
async def apaste(
self,
img: "BuildImage" or Image,
pos: Optional[Tuple[int, int]] = None,
alpha: bool = False,
center_type: Optional[Literal["center", "by_height", "by_width"]] = None,
allow_negative: bool = False,
):
"""
说明:
异步 贴图
参数:
:param img: 已打开的图片文件，可以为 BuildImage 或 Image
:param pos: 贴图位置（左上角）
:param alpha: 图片背景是否为透明
:param center_type: 居中类型，可能的值 center: 完全居中，by_width: 水平居中，by_height: 垂直居中
:param allow_negative: 允许使用负数作为坐标且不超出图片范围，从右侧开始计算
"""
await self.loop.run_in_executor(
None, self.paste, img, pos, alpha, center_type, allow_negative
)
def paste(
self,
img: "BuildImage",
pos: Optional[Tuple[int, int]] = None,
alpha: bool = False,
center_type: Optional[Literal["center", "by_height", "by_width"]] = None,
allow_negative: bool = False,
):
"""
说明:
贴图
参数:
:param img: 已打开的图片文件，可以为 BuildImage 或 Image
:param pos: 贴图位置（左上角）
:param alpha: 图片背景是否为透明
:param center_type: 居中类型，可能的值 center: 完全居中，by_width: 水平居中，by_height: 垂直居中
:param allow_negative: 允许使用负数作为坐标且不超出图片范围，从右侧开始计算
"""
if center_type:
if center_type not in ["center", "by_height", "by_width"]:
raise ValueError(
"center_type must be 'center', 'by_width' or 'by_height'"
)
width, height = 0, 0
if not pos:
pos = (0, 0)
if center_type == "center":
width = int((self.w - img.w) / 2)
height = int((self.h - img.h) / 2)
elif center_type == "by_width":
width = int((self.w - img.w) / 2)
height = pos[1]
elif center_type == "by_height":
width = pos[0]
height = int((self.h - img.h) / 2)
pos = (width, height)
if pos and allow_negative:
if pos[0] < 0:
pos = (self.w + pos[0], pos[1])
if pos[1] < 0:
pos = (pos[0], self.h + pos[1])
if isinstance(img, BuildImage):
img = img.markImg
if self._current_w >= self.w:
self._current_w = 0
self._current_h += self.paste_image_height + self.paste_space
if not pos:
pos = (self._current_w, self._current_h)
if alpha:
try:
self.markImg.paste(img, pos, img)
except ValueError:
img = img.convert("RGBA")
self.markImg.paste(img, pos, img)
else:
self.markImg.paste(img, pos)
self._current_w += self.paste_image_width + self.paste_space
def get_text_size(cls, msg: str, font: str, font_size: int) -> Tuple[int, int]:
"""
说明:
获取文字在该图片 font_size 下所需要的空间
参数:
:param msg: 文字内容
:param font: 字体
:param font_size: 字体大小
"""
font_ = cls.load_font(font, font_size)
return font_.getsize(msg) # type: ignore
def getsize(self, msg: Any) -> Tuple[int, int]:
"""
说明:
获取文字在该图片 font_size 下所需要的空间
参数:
:param msg: 文字内容
"""
return self.font.getsize(str(msg)) # type: ignore
async def apoint(
self, pos: Tuple[int, int], fill: Optional[Tuple[int, int, int]] = None
):
"""
说明:
异步 绘制多个或单独的像素
参数:
:param pos: 坐标
:param fill: 填错颜色
"""
await self.loop.run_in_executor(None, self.point, pos, fill)
def point(self, pos: Tuple[int, int], fill: Optional[Tuple[int, int, int]] = None):
"""
说明:
绘制多个或单独的像素
参数:
:param pos: 坐标
:param fill: 填错颜色
"""
self.draw.point(pos, fill=fill)
async def aellipse(
self,
pos: Tuple[int, int, int, int],
fill: Optional[Tuple[int, int, int]] = None,
outline: Optional[Tuple[int, int, int]] = None,
width: int = 1,
):
"""
说明:
异步 绘制圆
参数:
:param pos: 坐标范围
:param fill: 填充颜色
:param outline: 描线颜色
:param width: 描线宽度
"""
await self.loop.run_in_executor(None, self.ellipse, pos, fill, outline, width)
def ellipse(
self,
pos: Tuple[int, int, int, int],
fill: Optional[Tuple[int, int, int]] = None,
outline: Optional[Tuple[int, int, int]] = None,
width: int = 1,
):
"""
说明:
绘制圆
参数:
:param pos: 坐标范围
:param fill: 填充颜色
:param outline: 描线颜色
:param width: 描线宽度
"""
self.draw.ellipse(pos, fill, outline, width)
async def atext(
self,
pos: Union[Tuple[int, int], Tuple[float, float]],
text: str,
fill: Union[str, Tuple[int, int, int]] = (0, 0, 0),
center_type: Optional[Literal["center", "by_height", "by_width"]] = None,
font: Optional[Union[FreeTypeFont, str]] = None,
font_size: Optional[int] = None,
**kwargs,
):
"""
说明:
异步 在图片上添加文字
参数:
:param pos: 文字位置
:param text: 文字内容
:param fill: 文字颜色
:param center_type: 居中类型，可能的值 center: 完全居中，by_width: 水平居中，by_height: 垂直居中
:param font: 字体
:param font_size: 字体大小
"""
await self.loop.run_in_executor(
None, self.text, pos, text, fill, center_type, font, font_size, **kwargs
)
def text(
self,
pos: Union[Tuple[int, int], Tuple[float, float]],
text: str,
fill: Union[str, Tuple[int, int, int]] = (0, 0, 0),
center_type: Optional[Literal["center", "by_height", "by_width"]] = None,
font: Optional[Union[FreeTypeFont, str]] = None,
font_size: Optional[int] = None,
**kwargs,
):
"""
说明:
在图片上添加文字
参数:
:param pos: 文字位置(使用center_type中的center后会失效,使用by_width后x失效,使用by_height后y失效)
:param text: 文字内容
:param fill: 文字颜色
:param center_type: 居中类型，可能的值 center: 完全居中，by_width: 水平居中，by_height: 垂直居中
:param font: 字体
:param font_size: 字体大小
"""
if center_type:
if center_type not in ["center", "by_height", "by_width"]:
raise ValueError(
"center_type must be 'center', 'by_width' or 'by_height'"
)
w, h = self.w, self.h
longgest_text = ""
sentence = text.split("\n")
for x in sentence:
longgest_text = x if len(x) > len(longgest_text) else longgest_text
ttf_w, ttf_h = self.getsize(longgest_text)
ttf_h = ttf_h * len(sentence)
if center_type == "center":
w = int((w - ttf_w) / 2)
h = int((h - ttf_h) / 2)
elif center_type == "by_width":
w = int((w - ttf_w) / 2)
h = pos[1]
elif center_type == "by_height":
h = int((h - ttf_h) / 2)
w = pos[0]
pos = (w, h)
if font:
if isinstance(font, str):
font = self.load_font(font, font_size)
elif font_size:
font = self.load_font(self.font_name, font_size)
self.draw.text(pos, text, fill=fill, font=font or self.font, **kwargs)
async def asave(self, path: Optional[Union[str, Path]] = None):
"""
说明:
异步 保存图片
参数:
:param path: 图片路径
"""
await self.loop.run_in_executor(None, self.save, path)
def save(self, path: Optional[Union[str, Path]] = None):
"""
说明:
保存图片
参数:
:param path: 图片路径
"""
self.markImg.save(path or self.background) # type: ignore
def show(self):
"""
说明:
显示图片
"""
self.markImg.show()
async def aresize(self, ratio: float = 0, w: int = 0, h: int = 0):
"""
说明:
异步 压缩图片
参数:
:param ratio: 压缩倍率
:param w: 压缩图片宽度至 w
:param h: 压缩图片高度至 h
"""
await self.loop.run_in_executor(None, self.resize, ratio, w, h)
def resize(self, ratio: float = 0, w: int = 0, h: int = 0):
"""
说明:
压缩图片
参数:
:param ratio: 压缩倍率
:param w: 压缩图片宽度至 w
:param h: 压缩图片高度至 h
"""
if not w and not h and not ratio:
raise Exception("缺少参数...")
if not w and not h and ratio:
w = int(self.w * ratio)
h = int(self.h * ratio)
self.markImg = self.markImg.resize((w, h), Image.ANTIALIAS)
self.w, self.h = self.markImg.size
self.size = self.w, self.h
self.draw = ImageDraw.Draw(self.markImg)
async def acrop(self, box: Tuple[int, int, int, int]):
"""
说明:
异步 裁剪图片
参数:
:param box: 左上角坐标，右下角坐标 (left, upper, right, lower)
"""
await self.loop.run_in_executor(None, self.crop, box)
def crop(self, box: Tuple[int, int, int, int]):
"""
说明:
裁剪图片
参数:
:param box: 左上角坐标，右下角坐标 (left, upper, right, lower)
"""
self.markImg = self.markImg.crop(box)
self.w, self.h = self.markImg.size
self.size = self.w, self.h
self.draw = ImageDraw.Draw(self.markImg)
def check_font_size(self, word: str) -> bool:
"""
说明:
检查文本所需宽度是否大于图片宽度
参数:
:param word: 文本内容
"""
return self.font.getsize(word)[0] > self.w
async def atransparent(self, alpha_ratio: float = 1, n: int = 0):
"""
说明:
异步 图片透明化
参数:
:param alpha_ratio: 透明化程度
:param n: 透明化大小内边距
"""
await self.loop.run_in_executor(None, self.transparent, alpha_ratio, n)
def transparent(self, alpha_ratio: float = 1, n: int = 0):
"""
说明:
图片透明化
参数:
:param alpha_ratio: 透明化程度
:param n: 透明化大小内边距
"""
self.markImg = self.markImg.convert("RGBA")
x, y = self.markImg.size
for i in range(n, x - n):
for k in range(n, y - n):
color = self.markImg.getpixel((i, k))
color = color[:-1] + (int(100 * alpha_ratio),)
self.markImg.putpixel((i, k), color)
self.draw = ImageDraw.Draw(self.markImg)
def pic2bs4(self) -> str:
"""
说明:
BuildImage 转 base64
"""
buf = BytesIO()
self.markImg.save(buf, format="PNG")
base64_str = base64.b64encode(buf.getvalue()).decode()
return "base64://" + base64_str
def convert(self, type_: ModeType):
"""
说明:
修改图片类型
参数:
:param type_: 类型
"""
self.markImg = self.markImg.convert(type_)
async def arectangle(
self,
xy: Tuple[int, int, int, int],
fill: Optional[Tuple[int, int, int]] = None,
outline: Optional[str] = None,
width: int = 1,
):
"""
说明:
异步 画框
参数:
:param xy: 坐标
:param fill: 填充颜色
:param outline: 轮廓颜色
:param width: 线宽
"""
await self.loop.run_in_executor(None, self.rectangle, xy, fill, outline, width)
def rectangle(
self,
xy: Tuple[int, int, int, int],
fill: Optional[Tuple[int, int, int]] = None,
outline: Optional[str] = None,
width: int = 1,
):
"""
说明:
画框
参数:
:param xy: 坐标
:param fill: 填充颜色
:param outline: 轮廓颜色
:param width: 线宽
"""
self.draw.rectangle(xy, fill, outline, width)
async def apolygon(
self,
xy: List[Tuple[int, int]],
fill: Tuple[int, int, int] = (0, 0, 0),
outline: int = 1,
):
"""
说明:
异步 画多边形
参数:
:param xy: 坐标
:param fill: 颜色
:param outline: 线宽
"""
await self.loop.run_in_executor(None, self.polygon, xy, fill, outline)
def polygon(
self,
xy: List[Tuple[int, int]],
fill: Tuple[int, int, int] = (0, 0, 0),
outline: int = 1,
):
"""
说明:
画多边形
参数:
:param xy: 坐标
:param fill: 颜色
:param outline: 线宽
"""
self.draw.polygon(xy, fill, outline)
async def aline(
self,
xy: Tuple[int, int, int, int],
fill: Optional[Union[str, Tuple[int, int, int]]] = None,
width: int = 1,
):
"""
说明:
异步 画线
参数:
:param xy: 坐标
:param fill: 填充
:param width: 线宽
"""
await self.loop.run_in_executor(None, self.line, xy, fill, width)
def line(
self,
xy: Tuple[int, int, int, int],
fill: Optional[Union[Tuple[int, int, int], str]] = None,
width: int = 1,
):
"""
说明:
画线
参数:
:param xy: 坐标
:param fill: 填充
:param width: 线宽
"""
self.draw.line(xy, fill, width)
async def acircle(self):
"""
说明:
异步 将 BuildImage 图片变为圆形
"""
await self.loop.run_in_executor(None, self.circle)
def circle(self):
"""
说明:
使图像变圆
"""
self.markImg.convert("RGBA")
size = self.markImg.size
r2 = min(size[0], size[1])
if size[0] != size[1]:
self.markImg = self.markImg.resize((r2, r2), Image.ANTIALIAS)
width = 1
antialias = 4
ellipse_box = [0, 0, r2 - 2, r2 - 2]
mask = Image.new(
size=[int(dim * antialias) for dim in self.markImg.size],
mode="L",
color="black",
)
draw = ImageDraw.Draw(mask)
for offset, fill in (width / -2.0, "black"), (width / 2.0, "white"):
left, top = [(value + offset) * antialias for value in ellipse_box[:2]]
right, bottom = [(value - offset) * antialias for value in ellipse_box[2:]]
draw.ellipse([left, top, right, bottom], fill=fill)
mask = mask.resize(self.markImg.size, Image.LANCZOS)
try:
self.markImg.putalpha(mask)
except ValueError:
pass
async def acircle_corner(
self,
radii: int = 30,
point_list: List[Literal["lt", "rt", "lb", "rb"]] = ["lt", "rt", "lb", "rb"],
):
"""
说明:
异步 矩形四角变圆
参数:
:param radii: 半径
:param point_list: 需要变化的角
"""
await self.loop.run_in_executor(None, self.circle_corner, radii, point_list)
def circle_corner(
self,
radii: int = 30,
point_list: List[Literal["lt", "rt", "lb", "rb"]] = ["lt", "rt", "lb", "rb"],
):
"""
说明:
矩形四角变圆
参数:
:param radii: 半径
:param point_list: 需要变化的角
"""
# 画圆（用于分离4个角）
img = self.markImg.convert("RGBA")
alpha = img.split()[-1]
circle = Image.new("L", (radii * 2, radii * 2), 0)
draw = ImageDraw.Draw(circle)
draw.ellipse((0, 0, radii * 2, radii * 2), fill=255) # 黑色方形内切白色圆形
w, h = img.size
if "lt" in point_list:
alpha.paste(circle.crop((0, 0, radii, radii)), (0, 0))
if "rt" in point_list:
alpha.paste(circle.crop((radii, 0, radii * 2, radii)), (w - radii, 0))
if "lb" in point_list:
alpha.paste(circle.crop((0, radii, radii, radii * 2)), (0, h - radii))
if "rb" in point_list:
alpha.paste(
circle.crop((radii, radii, radii * 2, radii * 2)),
(w - radii, h - radii),
)
img.putalpha(alpha)
self.markImg = img
self.draw = ImageDraw.Draw(self.markImg)
async def arotate(self, angle: int, expand: bool = False):
"""
说明:
异步 旋转图片
参数:
:param angle: 角度
:param expand: 放大图片适应角度
"""
await self.loop.run_in_executor(None, self.rotate, angle, expand)
def rotate(self, angle: int, expand: bool = False):
"""
说明:
旋转图片
参数:
:param angle: 角度
:param expand: 放大图片适应角度
"""
self.markImg = self.markImg.rotate(angle, expand=expand)
async def atranspose(self, angle: Literal[0, 1, 2, 3, 4, 5, 6]):
"""
说明:
异步 旋转图片(包括边框)
参数:
:param angle: 角度
"""
await self.loop.run_in_executor(None, self.transpose, angle)
def transpose(self, angle: Literal[0, 1, 2, 3, 4, 5, 6]):
"""
说明:
旋转图片(包括边框)
参数:
:param angle: 角度
"""
self.markImg.transpose(angle)
async def afilter(self, filter_: str, aud: Optional[int] = None):
"""
说明:
异步 图片变化
参数:
:param filter_: 变化效果
:param aud: 利率
"""
await self.loop.run_in_executor(None, self.filter, filter_, aud)
def filter(self, filter_: str, aud: Optional[int] = None):
"""
说明:
图片变化
参数:
:param filter_: 变化效果
:param aud: 利率
"""
_x = None
if filter_ == "GaussianBlur": # 高斯模糊
_x = ImageFilter.GaussianBlur
elif filter_ == "EDGE_ENHANCE": # 锐化效果
_x = ImageFilter.EDGE_ENHANCE
elif filter_ == "BLUR": # 模糊效果
_x = ImageFilter.BLUR
elif filter_ == "CONTOUR": # 铅笔滤镜
_x = ImageFilter.CONTOUR
elif filter_ == "FIND_EDGES": # 边缘检测
_x = ImageFilter.FIND_EDGES
if _x:
if aud:
self.markImg = self.markImg.filter(_x(aud))
else:
self.markImg = self.markImg.filter(_x)
self.draw = ImageDraw.Draw(self.markImg)
async def areplace_color_tran(
self,
src_color: Union[
Tuple[int, int, int], Tuple[Tuple[int, int, int], Tuple[int, int, int]]
],
replace_color: Tuple[int, int, int],
):
"""
说明:
异步 颜色替换
参数:
:param src_color: 目标颜色，或者使用列表，设置阈值
:param replace_color: 替换颜色
"""
self.loop.run_in_executor(
None, self.replace_color_tran, src_color, replace_color
)
def replace_color_tran(
self,
src_color: Union[
Tuple[int, int, int], Tuple[Tuple[int, int, int], Tuple[int, int, int]]
],
replace_color: Tuple[int, int, int],
):
"""
说明:
颜色替换
参数:
:param src_color: 目标颜色，或者使用元祖，设置阈值
:param replace_color: 替换颜色
"""
if isinstance(src_color, tuple):
start_ = src_color[0]
end_ = src_color[1]
else:
start_ = src_color
end_ = None
for i in range(self.w):
for j in range(self.h):
r, g, b = self.markImg.getpixel((i, j))
if not end_:
if r == start_[0] and g == start_[1] and b == start_[2]:
self.markImg.putpixel((i, j), replace_color)
else:
if (
start_[0] <= r <= end_[0]
and start_[1] <= g <= end_[1]
and start_[2] <= b <= end_[2]
):
self.markImg.putpixel((i, j), replace_color)
#
def getchannel(self, type_):
self.markImg = self.markImg.getchannel(type_)
async def text2image(
text: str,
auto_parse: bool = True,
font_size: int = 20,
color: Union[str, Tuple[int, int, int], Tuple[int, int, int, int]] = "white",
font: str = "CJGaoDeGuo.otf",
font_color: Union[str, Tuple[int, int, int]] = "black",
padding: Union[int, Tuple[int, int, int, int]] = 0,
_add_height: float = 0,
) -> BuildImage:
"""
说明:
解析文本并转为图片
使用标签
<f> </f>
可选配置项
font: str -> 特殊文本字体
fs / font_size: int -> 特殊文本大小
fc / font_color: Union[str, Tuple[int, int, int]] -> 特殊文本颜色
示例
在不在，<f font=YSHaoShenTi-2.ttf font_size=30 font_color=red>HibiKi小姐</f>，
你最近还好吗，<f font_size=15 font_color=black>我非常想你</f>，这段时间我非常不好过，
<f font_size=25>抽卡抽不到金色</f>，这让我很痛苦
参数:
:param text: 文本
:param auto_parse: 是否自动解析，否则原样发送
:param font_size: 普通字体大小
:param color: 背景颜色
:param font: 普通字体
:param font_color: 普通字体颜色
:param padding: 文本外边距，元组类型时为 （上，左，下，右）
:param _add_height: 由于get_size无法返回正确的高度，采用手动方式额外添加高度
"""
pw = ph = top_padding = left_padding = 0
if padding:
if isinstance(padding, int):
pw = padding * 2
ph = padding * 2
top_padding = left_padding = padding
elif isinstance(padding, tuple):
pw = padding[0] + padding[2]
ph = padding[1] + padding[3]
top_padding = padding[0]
left_padding = padding[1]
if auto_parse and re.search(r"<f(.*)>(.*)</f>", text):
_data = []
new_text = ""
placeholder_index = 0
for s in text.split("</f>"):
r = re.search(r"<f(.*)>(.*)", s)
if r:
start, end = r.span()
if start != 0 and (t := s[:start]):
new_text += t
_data.append(
[
(start, end),
f"[placeholder_{placeholder_index}]",
r.group(1).strip(),
r.group(2),
]
)
new_text += f"[placeholder_{placeholder_index}]"
placeholder_index += 1
new_text += text.split("</f>")[-1]
image_list = []
current_placeholder_index = 0
# 切分换行，每行为单张图片
for s in new_text.split("\n"):
_tmp_text = s
img_height = BuildImage(0, 0, font_size=font_size).getsize("正")[1]
img_width = 0
_tmp_index = current_placeholder_index
for _ in range(s.count("[placeholder_")):
placeholder = _data[_tmp_index]
if "font_size" in placeholder[2]:
r = re.search(r"font_size=['\"]?(\d+)", placeholder[2])
if r:
w, h = BuildImage(0, 0, font_size=int(r.group(1))).getsize(
placeholder[3]
)
img_height = img_height if img_height > h else h
img_width += w
else:
img_width += BuildImage(0, 0, font_size=font_size).getsize(
placeholder[3]
)[0]
_tmp_text = _tmp_text.replace(f"[placeholder_{_tmp_index}]", "")
_tmp_index += 1
img_width += BuildImage(0, 0, font_size=font_size).getsize(_tmp_text)[0]
# img_width += len(_tmp_text) * font_size
# 开始画图
A = BuildImage(
img_width, img_height, color=color, font=font, font_size=font_size
)
basic_font_h = A.getsize("正")[1]
current_width = 0
# 遍历占位符
for _ in range(s.count("[placeholder_")):
if not s.startswith(f"[placeholder_{current_placeholder_index}]"):
slice_ = s.split(f"[placeholder_{current_placeholder_index}]")
await A.atext(
(current_width, A.h - basic_font_h - 1), slice_[0], font_color
)
current_width += A.getsize(slice_[0])[0]
placeholder = _data[current_placeholder_index]
# 解析配置
_font = font
_font_size = font_size
_font_color = font_color
for e in placeholder[2].split():
if e.startswith("font="):
_font = e.split("=")[-1]
if e.startswith("font_size=") or e.startswith("fs="):
_font_size = int(e.split("=")[-1])
if _font_size > 1000:
_font_size = 1000
if _font_size < 1:
_font_size = 1
if e.startswith("font_color") or e.startswith("fc="):
_font_color = e.split("=")[-1]
text_img = BuildImage(
0,
0,
plain_text=placeholder[3],
font_size=_font_size,
font_color=_font_color,
font=_font,
)
_img_h = (
int(A.h / 2 - text_img.h / 2)
if new_text == "[placeholder_0]"
else A.h - text_img.h
)
await A.apaste(text_img, (current_width, _img_h - 1), True)
current_width += text_img.w
s = s[
s.index(f"[placeholder_{current_placeholder_index}]")
+ len(f"[placeholder_{current_placeholder_index}]") :
]
current_placeholder_index += 1
if s:
slice_ = s.split(f"[placeholder_{current_placeholder_index}]")
await A.atext((current_width, A.h - basic_font_h), slice_[0])
current_width += A.getsize(slice_[0])[0]
A.crop((0, 0, current_width, A.h))
# A.show()
image_list.append(A)
height = 0
width = 0
for img in image_list:
height += img.h
width = width if width > img.w else img.w
width += pw
height += ph
A = BuildImage(width + left_padding, height + top_padding, color=color)
current_height = top_padding
for img in image_list:
await A.apaste(img, (left_padding, current_height), True)
current_height += img.h
else:
width = 0
height = 0
_tmp = BuildImage(0, 0, font=font, font_size=font_size)
_, h = _tmp.getsize("正")
line_height = int(font_size / 3)
image_list = []
for x in text.split("\n"):
w, _ = _tmp.getsize(x.strip() or "正")
height += h + line_height
width = width if width > w else w
image_list.append(
BuildImage(
w,
h,
font=font,
font_size=font_size,
plain_text=x.strip(),
color=color,
)
)
width += pw
height += ph
A = BuildImage(
width + left_padding,
height + top_padding + 2,
color=color,
)
cur_h = ph
for img in image_list:
await A.apaste(img, (pw, cur_h), True)
cur_h += img.h + line_height
return A
def group_image(image_list: List[BuildImage]) -> Tuple[List[List[BuildImage]], int]:
"""
说明:
根据图片大小进行分组
参数:
:param image_list: 排序图片列表
"""
image_list.sort(key=lambda x: x.h, reverse=True)
max_image = max(image_list, key=lambda x: x.h)
image_list.remove(max_image)
max_h = max_image.h
total_w = 0
# 图片分组
image_group = [[max_image]]
is_use = []
surplus_list = image_list[:]
for image in image_list:
if image.uid not in is_use:
group = [image]
is_use.append(image.uid)
curr_h = image.h
while True:
surplus_list = [x for x in surplus_list if x.uid not in is_use]
for tmp in surplus_list:
temp_h = curr_h + tmp.h + 10
if temp_h < max_h or abs(max_h - temp_h) < 100:
curr_h += tmp.h + 15
is_use.append(tmp.uid)
group.append(tmp)
break
else:
break
total_w += max([x.w for x in group]) + 15
image_group.append(group)
while surplus_list:
surplus_list = [x for x in surplus_list if x.uid not in is_use]
if not surplus_list:
break
surplus_list.sort(key=lambda x: x.h, reverse=True)
for img in surplus_list:
if img.uid not in is_use:
_w = 0
index = -1
for i, ig in enumerate(image_group):
if s := sum([x.h for x in ig]) > _w:
_w = s
index = i
if index != -1:
image_group[index].append(img)
is_use.append(img.uid)
max_h = 0
max_w = 0
for ig in image_group:
if (_h := sum([x.h + 15 for x in ig])) > max_h:
max_h = _h
max_w += max([x.w for x in ig]) + 30
is_use.clear()
while abs(max_h - max_w) > 200 and len(image_group) - 1 >= len(image_group[-1]):
for img in image_group[-1]:
_min_h = 999999
_min_index = -1
for i, ig in enumerate(image_group):
# if i not in is_use and (_h := sum([x.h for x in ig]) + img.h) > _min_h:
if (_h := sum([x.h for x in ig]) + img.h) < _min_h:
_min_h = _h
_min_index = i
is_use.append(_min_index)
image_group[_min_index].append(img)
max_w -= max([x.w for x in image_group[-1]]) - 30
image_group.pop(-1)
max_h = max([sum([x.h + 15 for x in ig]) for ig in image_group])
return image_group, max(max_h + 250, max_w + 70)
async def build_sort_image(
image_group: List[List[BuildImage]],
h: Optional[int] = None,
padding_top: int = 200,
color: Union[str, Tuple[int, int, int], Tuple[int, int, int, int]] = (
255,
255,
255,
),
background_path: Optional[Path] = None,
background_handle: Callable[[BuildImage], Optional[Awaitable]] = None,
) -> BuildImage:
"""
说明:
对group_image的图片进行组装
参数:
:param image_group: 分组图片列表
:param h: max(宽，高)，一般为group_image的返回值，有值时，图片必定为正方形
:param padding_top: 图像列表与最顶层间距
:param color: 背景颜色
:param background_path: 背景图片文件夹路径（随机）
:param background_handle: 背景图额外操作
"""
bk_file = None
if background_path:
random_bk = os.listdir(background_path)
if random_bk:
bk_file = random.choice(random_bk)
image_w = 0
image_h = 0
if not h:
for ig in image_group:
_w = max([x.w + 30 for x in ig])
image_w += _w + 30
_h = sum([x.h + 10 for x in ig])
if _h > image_h:
image_h = _h
image_h += padding_top
else:
image_w = h
image_h = h
A = BuildImage(
image_w,
image_h,
font_size=24,
font="CJGaoDeGuo.otf",
color=color,
background=(background_path / bk_file) if bk_file else None,
)
if background_handle:
if is_coroutine_callable(background_handle):
await background_handle(A)
else:
background_handle(A)
curr_w = 50
for ig in image_group:
curr_h = padding_top - 20
for img in ig:
await A.apaste(img, (curr_w, curr_h), True)
curr_h += img.h + 10
curr_w += max([x.w for x in ig]) + 30
return A
lass PluginType(Enum):
"""
插件类型
"""
NORMAL = "normal"
ADMIN = "admin"
HIDDEN = "hidden"
SUPERUSER = "superuser"
The provided code snippet includes necessary dependencies for implementing the `create_help_image` function. Write a Python function `async def create_help_image()` to solve the following problem:
创建管理员帮助图片
Here is the function:
async def create_help_image():
"""
创建管理员帮助图片
"""
if ADMIN_HELP_IMAGE.exists():
return
plugin_data_ = plugin_data_manager.get_data()
image_list = []
task_list = []
for plugin_data in [plugin_data_[x] for x in plugin_data_]:
try:
usage = None
if plugin_data.plugin_type == PluginType.ADMIN and plugin_data.usage:
usage = await text2image(
plugin_data.usage, padding=5, color=(204, 196, 151)
)
if usage:
await usage.acircle_corner()
level = 5
if plugin_data.plugin_setting:
level = plugin_data.plugin_setting.level or level
image = await help_template(plugin_data.name + f"[{level}]", usage)
image_list.append(image)
if plugin_data.task:
for x in plugin_data.task.keys():
task_list.append(plugin_data.task[x])
except Exception as e:
logger.warning(
f"获取群管理员插件 {plugin_data.model}: {plugin_data.name} 设置失败...",
"管理员帮助",
e=e,
)
task_str = "\n".join(task_list)
task_str = "通过 开启/关闭 来控制群被动\n----------\n" + task_str
task_image = await text2image(task_str, padding=5, color=(204, 196, 151))
task_image = await help_template("被动任务", task_image)
image_list.append(task_image)
image_group, _ = group_image(image_list)
A = await build_sort_image(image_group, color="#f9f6f2", padding_top=180)
await A.apaste(
BuildImage(0, 0, font="CJGaoDeGuo.otf", plain_text="群管理员帮助", font_size=50),
(50, 30),
True,
)
await A.apaste(
BuildImage(
0,
0,
font="CJGaoDeGuo.otf",
plain_text="注: ‘*’ 代表可有多个相同参数 ‘?’ 代表可省略该参数",
font_size=30,
font_color="red",
),
(50, 90),
True,
)
await A.asave(ADMIN_HELP_IMAGE)
logger.info(f"已成功加载 {len(image_list)} 条管理员命令") | 创建管理员帮助图片 |
188,084 | import os
import shutil
import zipfile
from pathlib import Path
from typing import Tuple, Union
import ujson as json
from configs.path_config import DATA_PATH, TEMP_PATH
from services import logger
from utils.http_utils import AsyncHttpx
from utils.image_utils import BuildImage, text2image
from utils.manager import plugins_manager
from utils.utils import is_number
extensive_plugin_path = Path() / "extensive_plugin"
if not extensive_plugin_path.exists():
extensive_plugin_path.mkdir(parents=True, exist_ok=True)
data = {}
async def get_plugin_name(index: int) -> Tuple[str, int]:
"""
通过下标获取插件名
:param name: 下标
"""
if not data:
await show_plugin_repo()
if index < 1 or index > len(data.keys()):
return "下标超过上下限！", 999
name = list(data.keys())[index - 1]
return name, 200
class AsyncHttpx:
proxy = {"http://": get_local_proxy(), "https://": get_local_proxy()}
async def get(
cls,
url: str,
*,
params: Optional[Dict[str, Any]] = None,
headers: Optional[Dict[str, str]] = None,
cookies: Optional[Dict[str, str]] = None,
verify: bool = True,
use_proxy: bool = True,
proxy: Optional[Dict[str, str]] = None,
timeout: Optional[int] = 30,
**kwargs,
) -> Response:
"""
说明:
Get
参数:
:param url: url
:param params: params
:param headers: 请求头
:param cookies: cookies
:param verify: verify
:param use_proxy: 使用默认代理
:param proxy: 指定代理
:param timeout: 超时时间
"""
if not headers:
headers = get_user_agent()
proxy_ = proxy if proxy else cls.proxy if use_proxy else None
async with httpx.AsyncClient(proxies=proxy_, verify=verify) as client:
return await client.get(
url,
params=params,
headers=headers,
cookies=cookies,
timeout=timeout,
**kwargs,
)
async def post(
cls,
url: str,
*,
data: Optional[Dict[str, str]] = None,
content: Any = None,
files: Any = None,
verify: bool = True,
use_proxy: bool = True,
proxy: Optional[Dict[str, str]] = None,
json: Optional[Dict[str, Any]] = None,
params: Optional[Dict[str, str]] = None,
headers: Optional[Dict[str, str]] = None,
cookies: Optional[Dict[str, str]] = None,
timeout: Optional[int] = 30,
**kwargs,
) -> Response:
"""
说明:
Post
参数:
:param url: url
:param data: data
:param content: content
:param files: files
:param use_proxy: 是否默认代理
:param proxy: 指定代理
:param json: json
:param params: params
:param headers: 请求头
:param cookies: cookies
:param timeout: 超时时间
"""
if not headers:
headers = get_user_agent()
proxy_ = proxy if proxy else cls.proxy if use_proxy else None
async with httpx.AsyncClient(proxies=proxy_, verify=verify) as client:
return await client.post(
url,
content=content,
data=data,
files=files,
json=json,
params=params,
headers=headers,
cookies=cookies,
timeout=timeout,
**kwargs,
)
async def download_file(
cls,
url: str,
path: Union[str, Path],
*,
params: Optional[Dict[str, str]] = None,
verify: bool = True,
use_proxy: bool = True,
proxy: Optional[Dict[str, str]] = None,
headers: Optional[Dict[str, str]] = None,
cookies: Optional[Dict[str, str]] = None,
timeout: Optional[int] = 30,
stream: bool = False,
**kwargs,
) -> bool:
"""
说明:
下载文件
参数:
:param url: url
:param path: 存储路径
:param params: params
:param verify: verify
:param use_proxy: 使用代理
:param proxy: 指定代理
:param headers: 请求头
:param cookies: cookies
:param timeout: 超时时间
:param stream: 是否使用流式下载（流式写入+进度条，适用于下载大文件）
"""
if isinstance(path, str):
path = Path(path)
path.parent.mkdir(parents=True, exist_ok=True)
try:
for _ in range(3):
if not stream:
try:
content = (
await cls.get(
url,
params=params,
headers=headers,
cookies=cookies,
use_proxy=use_proxy,
proxy=proxy,
timeout=timeout,
**kwargs,
)
).content
async with aiofiles.open(path, "wb") as wf:
await wf.write(content)
logger.info(f"下载 {url} 成功.. Path：{path.absolute()}")
return True
except (TimeoutError, ConnectTimeout):
pass
else:
if not headers:
headers = get_user_agent()
proxy_ = proxy if proxy else cls.proxy if use_proxy else None
try:
async with httpx.AsyncClient(
proxies=proxy_, verify=verify
) as client:
async with client.stream(
"GET",
url,
params=params,
headers=headers,
cookies=cookies,
timeout=timeout,
**kwargs,
) as response:
logger.info(
f"开始下载 {path.name}.. Path: {path.absolute()}"
)
async with aiofiles.open(path, "wb") as wf:
total = int(response.headers["Content-Length"])
with rich.progress.Progress(
rich.progress.TextColumn(path.name),
"[progress.percentage]{task.percentage:>3.0f}%",
rich.progress.BarColumn(bar_width=None),
rich.progress.DownloadColumn(),
rich.progress.TransferSpeedColumn(),
) as progress:
download_task = progress.add_task(
"Download", total=total
)
async for chunk in response.aiter_bytes():
await wf.write(chunk)
await wf.flush()
progress.update(
download_task,
completed=response.num_bytes_downloaded,
)
logger.info(f"下载 {url} 成功.. Path：{path.absolute()}")
return True
except (TimeoutError, ConnectTimeout):
pass
else:
logger.error(f"下载 {url} 下载超时.. Path：{path.absolute()}")
except Exception as e:
logger.error(f"下载 {url} 错误 Path：{path.absolute()}", e=e)
return False
async def gather_download_file(
cls,
url_list: List[str],
path_list: List[Union[str, Path]],
*,
limit_async_number: Optional[int] = None,
params: Optional[Dict[str, str]] = None,
use_proxy: bool = True,
proxy: Optional[Dict[str, str]] = None,
headers: Optional[Dict[str, str]] = None,
cookies: Optional[Dict[str, str]] = None,
timeout: Optional[int] = 30,
**kwargs,
) -> List[bool]:
"""
说明:
分组同时下载文件
参数:
:param url_list: url列表
:param path_list: 存储路径列表
:param limit_async_number: 限制同时请求数量
:param params: params
:param use_proxy: 使用代理
:param proxy: 指定代理
:param headers: 请求头
:param cookies: cookies
:param timeout: 超时时间
"""
if n := len(url_list) != len(path_list):
raise UrlPathNumberNotEqual(
f"Url数量与Path数量不对等，Url：{len(url_list)}，Path：{len(path_list)}"
)
if limit_async_number and n > limit_async_number:
m = float(n) / limit_async_number
x = 0
j = limit_async_number
_split_url_list = []
_split_path_list = []
for _ in range(int(m)):
_split_url_list.append(url_list[x:j])
_split_path_list.append(path_list[x:j])
x += limit_async_number
j += limit_async_number
if int(m) < m:
_split_url_list.append(url_list[j:])
_split_path_list.append(path_list[j:])
else:
_split_url_list = [url_list]
_split_path_list = [path_list]
tasks = []
result_ = []
for x, y in zip(_split_url_list, _split_path_list):
for url, path in zip(x, y):
tasks.append(
asyncio.create_task(
cls.download_file(
url,
path,
params=params,
headers=headers,
cookies=cookies,
use_proxy=use_proxy,
timeout=timeout,
proxy=proxy,
**kwargs,
)
)
)
_x = await asyncio.gather(*tasks)
result_ = result_ + list(_x)
tasks.clear()
return result_
{
"run_sql": [], # 需要启动前运行的sql语句
"_shop_before_handle": {}, # 商品使用前函数
"_shop_after_handle": {}, # 商品使用后函数
}
def is_number(s: Union[int, str]) -> bool:
"""
说明:
检测 s 是否为数字
参数:
:param s: 文本
"""
if isinstance(s, int):
return True
try:
float(s)
return True
except ValueError:
pass
try:
import unicodedata
unicodedata.numeric(s)
return True
except (TypeError, ValueError):
pass
return False
The provided code snippet includes necessary dependencies for implementing the `install_plugin` function. Write a Python function `async def install_plugin(name: str) -> str` to solve the following problem:
安装插件 :param name: 插件名或下标
Here is the function:
async def install_plugin(name: str) -> str:
"""
安装插件
:param name: 插件名或下标
"""
try:
if is_number(name):
name, code = await get_plugin_name(int(name))
if code != 200:
return name
plugin_url = data[name]["download_url"]
url = (await AsyncHttpx.get(plugin_url)).headers.get("Location")
zip_file = TEMP_PATH / f"{name}.zip"
if zip_file.exists():
zip_file.unlink()
if await AsyncHttpx.download_file(url, zip_file):
logger.debug("开始解压插件压缩包...", "安装插件", target=name)
# 解压
zf = zipfile.ZipFile(zip_file, "r")
extract_path = TEMP_PATH / f"{name}"
if extract_path.exists():
shutil.rmtree(extract_path.absolute(), ignore_errors=True)
extract_path.mkdir(exist_ok=True, parents=True)
for file in zf.namelist():
zf.extract(file, extract_path)
zf.close()
logger.debug("解压插件压缩包完成...", "安装插件", target=name)
logger.debug("开始移动插件文件夹...", "安装插件", target=name)
if (extensive_plugin_path / f"{name}").exists():
logger.debug(
"extensive_plugin目录下文件夹已存在，删除该目录插件文件夹...", "安装插件", target=name
)
shutil.rmtree(
(extensive_plugin_path / f"{name}").absolute(), ignore_errors=True
)
extract_path.rename(extensive_plugin_path / f"{name}")
prompt = ""
if "pyproject.toml" in os.listdir(extensive_plugin_path / f"{name}"):
prompt = "检测到该插件含有额外依赖，当前安装无法保证依赖完全安装成功。"
os.system(
f"poetry run pip install -r {(extensive_plugin_path / f'{name}' / 'pyproject.toml').absolute()}"
)
elif "requirements.txt" in os.listdir(extensive_plugin_path / f"{name}"):
prompt = "检测到该插件含有额外依赖，当前安装无法保证依赖完全安装成功。"
os.system(
f"poetry run pip install -r {(extensive_plugin_path / f'{name}' / 'requirements.txt').absolute()}"
)
with open(extensive_plugin_path / f"{name}" / "plugin_info.json", "w") as f:
json.dump(data[name], f, ensure_ascii=False, indent=4)
logger.debug("移动插件文件夹完成...", "安装插件", target=name)
logger.info(f"成功安装插件 {name} 成功！\n{prompt}", "安装插件", target=name)
return f"成功安装插件 {name}，请重启真寻！"
except Exception as e:
logger.error(f"安装插失败", "安装插件", target=name, e=e)
return f"安装插件 {name} 失败 {type(e)}：{e}" | 安装插件 :param name: 插件名或下标 |
188,085 | import os
import shutil
import zipfile
from pathlib import Path
from typing import Tuple, Union
import ujson as json
from configs.path_config import DATA_PATH, TEMP_PATH
from services import logger
from utils.http_utils import AsyncHttpx
from utils.image_utils import BuildImage, text2image
from utils.manager import plugins_manager
from utils.utils import is_number
extensive_plugin_path = Path() / "extensive_plugin"
if not extensive_plugin_path.exists():
extensive_plugin_path.mkdir(parents=True, exist_ok=True)
async def get_plugin_name(index: int) -> Tuple[str, int]:
"""
通过下标获取插件名
:param name: 下标
"""
if not data:
await show_plugin_repo()
if index < 1 or index > len(data.keys()):
return "下标超过上下限！", 999
name = list(data.keys())[index - 1]
return name, 200
{
"run_sql": [], # 需要启动前运行的sql语句
"_shop_before_handle": {}, # 商品使用前函数
"_shop_after_handle": {}, # 商品使用后函数
}
def is_number(s: Union[int, str]) -> bool:
"""
说明:
检测 s 是否为数字
参数:
:param s: 文本
"""
if isinstance(s, int):
return True
try:
float(s)
return True
except ValueError:
pass
try:
import unicodedata
unicodedata.numeric(s)
return True
except (TypeError, ValueError):
pass
return False
The provided code snippet includes necessary dependencies for implementing the `uninstall_plugin` function. Write a Python function `async def uninstall_plugin(name: str) -> str` to solve the following problem:
删除插件 :param name: 插件名或下标
Here is the function:
async def uninstall_plugin(name: str) -> str:
"""
删除插件
:param name: 插件名或下标
"""
try:
if is_number(name):
name, code = await get_plugin_name(int(name))
if code != 200:
return name
if name not in os.listdir(extensive_plugin_path):
return f"未安装 {name} 插件！"
shutil.rmtree((extensive_plugin_path / name).absolute(), ignore_errors=True)
logger.info(f"插件 {name} 删除成功！")
return f"插件 {name} 删除成功！"
except Exception as e:
logger.error(f"删除插件失败", target=name, e=e)
return f"删除插件 {name} 失败 {type(e)}：{e}" | 删除插件 :param name: 插件名或下标 |
188,086 | from typing import Optional
from configs.path_config import IMAGE_PATH
from utils.image_utils import BuildImage
from utils.manager import admin_manager, plugin_data_manager, plugins2settings_manager
from ._utils import HelpImageBuild
class HelpImageBuild:
def __init__(self):
self._data: Dict[str, PluginData] = plugin_data_manager.get_data()
self._sort_data: Dict[str, List[PluginData]] = {}
self._image_list = []
self.icon2str = {
"normal": "fa fa-cog",
"原神相关": "fa fa-circle-o",
"常规插件": "fa fa-cubes",
"联系管理员": "fa fa-envelope-o",
"抽卡相关": "fa fa-credit-card-alt",
"来点好康的": "fa fa-picture-o",
"数据统计": "fa fa-bar-chart",
"一些工具": "fa fa-shopping-cart",
"商店": "fa fa-shopping-cart",
"其它": "fa fa-tags",
"群内小游戏": "fa fa-gamepad",
}
def sort_type(self):
"""
说明:
对插件按照菜单类型分类
"""
if not self._sort_data.keys():
for key in self._data.keys():
plugin_data = self._data[key]
if plugin_data.plugin_type == PluginType.NORMAL:
if not self._sort_data.get(plugin_data.menu_type[0]): # type: ignore
self._sort_data[plugin_data.menu_type[0]] = [] # type: ignore
self._sort_data[plugin_data.menu_type[0]].append(self._data[key]) # type: ignore
async def build_image(self, group_id: Optional[int]):
if group_id:
help_image = GROUP_HELP_PATH / f"{group_id}.png"
else:
help_image = IMAGE_PATH / f"simple_help.png"
build_type = Config.get_config("help", "TYPE")
if build_type == "HTML":
byt = await self.build_html_image(group_id)
with open(help_image, "wb") as f:
f.write(byt)
else:
img = await self.build_pil_image(group_id)
img.save(help_image)
async def build_html_image(self, group_id: Optional[int]) -> bytes:
from nonebot_plugin_htmlrender import template_to_pic
self.sort_type()
classify = {}
for menu in self._sort_data:
for plugin in self._sort_data[menu]:
sta = 0
if not plugin.plugin_status.status:
if group_id and plugin.plugin_status.block_type in ["all", "group"]:
sta = 2
if not group_id and plugin.plugin_status.block_type in [
"all",
"private",
]:
sta = 2
if group_id and not group_manager.get_plugin_super_status(
plugin.model, group_id
):
sta = 2
if group_id and not group_manager.get_plugin_status(
plugin.model, group_id
):
sta = 1
if classify.get(menu):
classify[menu].append(Item(plugin_name=plugin.name, sta=sta))
else:
classify[menu] = [Item(plugin_name=plugin.name, sta=sta)]
max_len = 0
flag_index = -1
max_data = None
plugin_list = []
for index, plu in enumerate(classify.keys()):
if plu in self.icon2str.keys():
icon = self.icon2str[plu]
else:
icon = "fa fa-pencil-square-o"
logo = LOGO_PATH / random.choice(os.listdir(LOGO_PATH))
data = {
"name": plu if plu != "normal" else "功能",
"items": classify[plu],
"icon": icon,
"logo": str(logo.absolute()),
}
if len(classify[plu]) > max_len:
max_len = len(classify[plu])
flag_index = index
max_data = data
plugin_list.append(data)
del plugin_list[flag_index]
plugin_list.insert(0, max_data)
pic = await template_to_pic(
template_path=str((TEMPLATE_PATH / "menu").absolute()),
template_name="zhenxun_menu.html",
templates={"plugin_list": plugin_list},
pages={
"viewport": {"width": 1903, "height": 975},
"base_url": f"file://{TEMPLATE_PATH}",
},
wait=2,
)
return pic
async def build_pil_image(self, group_id: Optional[int]) -> BuildImage:
"""
说明:
构造帮助图片
参数:
:param group_id: 群号
"""
self._image_list = []
self.sort_type()
font_size = 24
build_type = Config.get_config("help", "TYPE")
_image = BuildImage(0, 0, plain_text="1", font_size=font_size)
for idx, menu_type in enumerate(self._sort_data.keys()):
plugin_list = self._sort_data[menu_type]
wh_list = [_image.getsize(x.name) for x in plugin_list]
wh_list.append(_image.getsize(menu_type))
# sum_height = sum([x[1] for x in wh_list])
if build_type == "VV":
sum_height = 50 * len(plugin_list) + 10
else:
sum_height = (font_size + 6) * len(plugin_list) + 10
max_width = max([x[0] for x in wh_list]) + 20
bk = BuildImage(
max_width + 40,
sum_height + 50,
font_size=30,
color="#a7d1fc",
font="CJGaoDeGuo.otf",
)
title_size = bk.getsize(menu_type)
max_width = max_width if max_width > title_size[0] else title_size[0]
B = BuildImage(
max_width + 40,
sum_height,
font_size=font_size,
color="white" if not idx % 2 else "black",
)
curr_h = 10
for i, plugin_data in enumerate(plugin_list):
text_color = (255, 255, 255) if idx % 2 else (0, 0, 0)
if group_id and not group_manager.get_plugin_status(
plugin_data.model, group_id
):
text_color = (252, 75, 13)
pos = None
# 禁用状态划线
if (
not plugin_data.plugin_status.status
and plugin_data.plugin_status.block_type in ["group", "all"]
) or (
group_id
and not group_manager.get_plugin_super_status(
plugin_data.model, group_id
)
):
w = curr_h + int(B.getsize(plugin_data.name)[1] / 2) + 2
pos = (
7,
w,
B.getsize(plugin_data.name)[0] + 35,
w,
)
if build_type == "VV":
name_image = await self.build_name_image( # type: ignore
max_width,
plugin_data.name,
"black" if not idx % 2 else "white",
text_color,
pos,
)
await B.apaste(
name_image, (0, curr_h), True, center_type="by_width"
)
curr_h += name_image.h + 5
else:
await B.atext(
(10, curr_h), f"{i + 1}.{plugin_data.name}", text_color
)
if pos:
await B.aline(pos, (236, 66, 7), 3)
curr_h += font_size + 5
if menu_type == "normal":
menu_type = "功能"
await bk.atext((0, 14), menu_type, center_type="by_width")
await bk.apaste(B, (0, 50))
await bk.atransparent(2)
# await bk.acircle_corner(point_list=['lt', 'rt'])
self._image_list.append(bk)
image_group, h = group_image(self._image_list)
B = await build_sort_image(
image_group,
h,
background_path=BACKGROUND_PATH,
background_handle=lambda image: image.filter("GaussianBlur", 5),
)
w = 10
h = 10
for msg in [
"目前支持的功能列表:",
"可以通过 ‘帮助[功能名称]’ 来获取对应功能的使用方法",
]:
text = BuildImage(
0,
0,
plain_text=msg,
font_size=24,
font="HYWenHei-85W.ttf",
)
B.paste(text, (w, h), True)
h += 50
if msg == "目前支持的功能列表:":
w += 50
await B.apaste(
BuildImage(
0,
0,
plain_text="注: 红字代表功能被群管理员禁用，红线代表功能正在维护",
font_size=24,
font="HYWenHei-85W.ttf",
font_color=(231, 74, 57),
),
(300, 10),
True,
)
return B
The provided code snippet includes necessary dependencies for implementing the `create_help_img` function. Write a Python function `async def create_help_img(group_id: Optional[int])` to solve the following problem:
说明: 生成帮助图片 参数: :param group_id: 群号
Here is the function:
async def create_help_img(group_id: Optional[int]):
"""
说明:
生成帮助图片
参数:
:param group_id: 群号
"""
await HelpImageBuild().build_image(group_id) | 说明: 生成帮助图片 参数: :param group_id: 群号 |
188,087 | from typing import Optional
from configs.path_config import IMAGE_PATH
from utils.image_utils import BuildImage
from utils.manager import admin_manager, plugin_data_manager, plugins2settings_manager
from ._utils import HelpImageBuild
background = IMAGE_PATH / "background" / "0.png"
class BuildImage:
"""
快捷生成图片与操作图片的工具类
"""
def __init__(
self,
w: int,
h: int,
paste_image_width: int = 0,
paste_image_height: int = 0,
paste_space: int = 0,
color: Union[str, Tuple[int, int, int], Tuple[int, int, int, int]] = None,
image_mode: ModeType = "RGBA",
font_size: int = 10,
background: Union[Optional[str], BytesIO, Path] = None,
font: str = "yz.ttf",
ratio: float = 1,
is_alpha: bool = False,
plain_text: Optional[str] = None,
font_color: Optional[Union[str, Tuple[int, int, int]]] = None,
**kwargs,
):
"""
参数:
:param w: 自定义图片的宽度，w=0时为图片原本宽度
:param h: 自定义图片的高度，h=0时为图片原本高度
:param paste_image_width: 当图片做为背景图时，设置贴图的宽度，用于贴图自动换行
:param paste_image_height: 当图片做为背景图时，设置贴图的高度，用于贴图自动换行
:param paste_space: 自动贴图间隔
:param color: 生成图片的颜色
:param image_mode: 图片的类型
:param font_size: 文字大小
:param background: 打开图片的路径
:param font: 字体，默认在 resource/ttf/ 路径下
:param ratio: 倍率压缩
:param is_alpha: 是否背景透明
:param plain_text: 纯文字文本
"""
self.w = int(w)
self.h = int(h)
self.paste_image_width = int(paste_image_width)
self.paste_image_height = int(paste_image_height)
self.paste_space = int(paste_space)
self._current_w = 0
self._current_h = 0
self.uid = uuid.uuid1()
self.font_name = font
self.font_size = font_size
self.font = ImageFont.truetype(str(FONT_PATH / font), int(font_size))
if not plain_text and not color:
color = (255, 255, 255)
self.background = background
if not background:
if plain_text:
if not color:
color = (255, 255, 255, 0)
ttf_w, ttf_h = self.getsize(str(plain_text))
self.w = self.w if self.w > ttf_w else ttf_w
self.h = self.h if self.h > ttf_h else ttf_h
self.markImg = Image.new(image_mode, (self.w, self.h), color)
self.markImg.convert(image_mode)
else:
if not w and not h:
self.markImg = Image.open(background)
w, h = self.markImg.size
if ratio and ratio > 0 and ratio != 1:
self.w = int(ratio * w)
self.h = int(ratio * h)
self.markImg = self.markImg.resize(
(self.w, self.h), Image.ANTIALIAS
)
else:
self.w = w
self.h = h
else:
self.markImg = Image.open(background).resize(
(self.w, self.h), Image.ANTIALIAS
)
if is_alpha:
try:
if array := self.markImg.load():
for i in range(w):
for j in range(h):
pos = array[i, j]
is_edit = sum([1 for x in pos[0:3] if x > 240]) == 3
if is_edit:
array[i, j] = (255, 255, 255, 0)
except Exception as e:
logger.warning(f"背景透明化发生错误..{type(e)}：{e}")
self.draw = ImageDraw.Draw(self.markImg)
self.size = self.w, self.h
if plain_text:
fill = font_color if font_color else (0, 0, 0)
self.text((0, 0), str(plain_text), fill)
try:
self.loop = asyncio.get_event_loop()
except RuntimeError:
new_loop = asyncio.new_event_loop()
asyncio.set_event_loop(new_loop)
self.loop = asyncio.get_event_loop()
def load_font(cls, font: str, font_size: Optional[int]) -> FreeTypeFont:
"""
说明:
加载字体
参数:
:param font: 字体名称
:param font_size: 字体大小
"""
return ImageFont.truetype(str(FONT_PATH / font), font_size or cls.font_size)
async def apaste(
self,
img: "BuildImage" or Image,
pos: Optional[Tuple[int, int]] = None,
alpha: bool = False,
center_type: Optional[Literal["center", "by_height", "by_width"]] = None,
allow_negative: bool = False,
):
"""
说明:
异步 贴图
参数:
:param img: 已打开的图片文件，可以为 BuildImage 或 Image
:param pos: 贴图位置（左上角）
:param alpha: 图片背景是否为透明
:param center_type: 居中类型，可能的值 center: 完全居中，by_width: 水平居中，by_height: 垂直居中
:param allow_negative: 允许使用负数作为坐标且不超出图片范围，从右侧开始计算
"""
await self.loop.run_in_executor(
None, self.paste, img, pos, alpha, center_type, allow_negative
)
def paste(
self,
img: "BuildImage",
pos: Optional[Tuple[int, int]] = None,
alpha: bool = False,
center_type: Optional[Literal["center", "by_height", "by_width"]] = None,
allow_negative: bool = False,
):
"""
说明:
贴图
参数:
:param img: 已打开的图片文件，可以为 BuildImage 或 Image
:param pos: 贴图位置（左上角）
:param alpha: 图片背景是否为透明
:param center_type: 居中类型，可能的值 center: 完全居中，by_width: 水平居中，by_height: 垂直居中
:param allow_negative: 允许使用负数作为坐标且不超出图片范围，从右侧开始计算
"""
if center_type:
if center_type not in ["center", "by_height", "by_width"]:
raise ValueError(
"center_type must be 'center', 'by_width' or 'by_height'"
)
width, height = 0, 0
if not pos:
pos = (0, 0)
if center_type == "center":
width = int((self.w - img.w) / 2)
height = int((self.h - img.h) / 2)
elif center_type == "by_width":
width = int((self.w - img.w) / 2)
height = pos[1]
elif center_type == "by_height":
width = pos[0]
height = int((self.h - img.h) / 2)
pos = (width, height)
if pos and allow_negative:
if pos[0] < 0:
pos = (self.w + pos[0], pos[1])
if pos[1] < 0:
pos = (pos[0], self.h + pos[1])
if isinstance(img, BuildImage):
img = img.markImg
if self._current_w >= self.w:
self._current_w = 0
self._current_h += self.paste_image_height + self.paste_space
if not pos:
pos = (self._current_w, self._current_h)
if alpha:
try:
self.markImg.paste(img, pos, img)
except ValueError:
img = img.convert("RGBA")
self.markImg.paste(img, pos, img)
else:
self.markImg.paste(img, pos)
self._current_w += self.paste_image_width + self.paste_space
def get_text_size(cls, msg: str, font: str, font_size: int) -> Tuple[int, int]:
"""
说明:
获取文字在该图片 font_size 下所需要的空间
参数:
:param msg: 文字内容
:param font: 字体
:param font_size: 字体大小
"""
font_ = cls.load_font(font, font_size)
return font_.getsize(msg) # type: ignore
def getsize(self, msg: Any) -> Tuple[int, int]:
"""
说明:
获取文字在该图片 font_size 下所需要的空间
参数:
:param msg: 文字内容
"""
return self.font.getsize(str(msg)) # type: ignore
async def apoint(
self, pos: Tuple[int, int], fill: Optional[Tuple[int, int, int]] = None
):
"""
说明:
异步 绘制多个或单独的像素
参数:
:param pos: 坐标
:param fill: 填错颜色
"""
await self.loop.run_in_executor(None, self.point, pos, fill)
def point(self, pos: Tuple[int, int], fill: Optional[Tuple[int, int, int]] = None):
"""
说明:
绘制多个或单独的像素
参数:
:param pos: 坐标
:param fill: 填错颜色
"""
self.draw.point(pos, fill=fill)
async def aellipse(
self,
pos: Tuple[int, int, int, int],
fill: Optional[Tuple[int, int, int]] = None,
outline: Optional[Tuple[int, int, int]] = None,
width: int = 1,
):
"""
说明:
异步 绘制圆
参数:
:param pos: 坐标范围
:param fill: 填充颜色
:param outline: 描线颜色
:param width: 描线宽度
"""
await self.loop.run_in_executor(None, self.ellipse, pos, fill, outline, width)
def ellipse(
self,
pos: Tuple[int, int, int, int],
fill: Optional[Tuple[int, int, int]] = None,
outline: Optional[Tuple[int, int, int]] = None,
width: int = 1,
):
"""
说明:
绘制圆
参数:
:param pos: 坐标范围
:param fill: 填充颜色
:param outline: 描线颜色
:param width: 描线宽度
"""
self.draw.ellipse(pos, fill, outline, width)
async def atext(
self,
pos: Union[Tuple[int, int], Tuple[float, float]],
text: str,
fill: Union[str, Tuple[int, int, int]] = (0, 0, 0),
center_type: Optional[Literal["center", "by_height", "by_width"]] = None,
font: Optional[Union[FreeTypeFont, str]] = None,
font_size: Optional[int] = None,
**kwargs,
):
"""
说明:
异步 在图片上添加文字
参数:
:param pos: 文字位置
:param text: 文字内容
:param fill: 文字颜色
:param center_type: 居中类型，可能的值 center: 完全居中，by_width: 水平居中，by_height: 垂直居中
:param font: 字体
:param font_size: 字体大小
"""
await self.loop.run_in_executor(
None, self.text, pos, text, fill, center_type, font, font_size, **kwargs
)
def text(
self,
pos: Union[Tuple[int, int], Tuple[float, float]],
text: str,
fill: Union[str, Tuple[int, int, int]] = (0, 0, 0),
center_type: Optional[Literal["center", "by_height", "by_width"]] = None,
font: Optional[Union[FreeTypeFont, str]] = None,
font_size: Optional[int] = None,
**kwargs,
):
"""
说明:
在图片上添加文字
参数:
:param pos: 文字位置(使用center_type中的center后会失效,使用by_width后x失效,使用by_height后y失效)
:param text: 文字内容
:param fill: 文字颜色
:param center_type: 居中类型，可能的值 center: 完全居中，by_width: 水平居中，by_height: 垂直居中
:param font: 字体
:param font_size: 字体大小
"""
if center_type:
if center_type not in ["center", "by_height", "by_width"]:
raise ValueError(
"center_type must be 'center', 'by_width' or 'by_height'"
)
w, h = self.w, self.h
longgest_text = ""
sentence = text.split("\n")
for x in sentence:
longgest_text = x if len(x) > len(longgest_text) else longgest_text
ttf_w, ttf_h = self.getsize(longgest_text)
ttf_h = ttf_h * len(sentence)
if center_type == "center":
w = int((w - ttf_w) / 2)
h = int((h - ttf_h) / 2)
elif center_type == "by_width":
w = int((w - ttf_w) / 2)
h = pos[1]
elif center_type == "by_height":
h = int((h - ttf_h) / 2)
w = pos[0]
pos = (w, h)
if font:
if isinstance(font, str):
font = self.load_font(font, font_size)
elif font_size:
font = self.load_font(self.font_name, font_size)
self.draw.text(pos, text, fill=fill, font=font or self.font, **kwargs)
async def asave(self, path: Optional[Union[str, Path]] = None):
"""
说明:
异步 保存图片
参数:
:param path: 图片路径
"""
await self.loop.run_in_executor(None, self.save, path)
def save(self, path: Optional[Union[str, Path]] = None):
"""
说明:
保存图片
参数:
:param path: 图片路径
"""
self.markImg.save(path or self.background) # type: ignore
def show(self):
"""
说明:
显示图片
"""
self.markImg.show()
async def aresize(self, ratio: float = 0, w: int = 0, h: int = 0):
"""
说明:
异步 压缩图片
参数:
:param ratio: 压缩倍率
:param w: 压缩图片宽度至 w
:param h: 压缩图片高度至 h
"""
await self.loop.run_in_executor(None, self.resize, ratio, w, h)
def resize(self, ratio: float = 0, w: int = 0, h: int = 0):
"""
说明:
压缩图片
参数:
:param ratio: 压缩倍率
:param w: 压缩图片宽度至 w
:param h: 压缩图片高度至 h
"""
if not w and not h and not ratio:
raise Exception("缺少参数...")
if not w and not h and ratio:
w = int(self.w * ratio)
h = int(self.h * ratio)
self.markImg = self.markImg.resize((w, h), Image.ANTIALIAS)
self.w, self.h = self.markImg.size
self.size = self.w, self.h
self.draw = ImageDraw.Draw(self.markImg)
async def acrop(self, box: Tuple[int, int, int, int]):
"""
说明:
异步 裁剪图片
参数:
:param box: 左上角坐标，右下角坐标 (left, upper, right, lower)
"""
await self.loop.run_in_executor(None, self.crop, box)
def crop(self, box: Tuple[int, int, int, int]):
"""
说明:
裁剪图片
参数:
:param box: 左上角坐标，右下角坐标 (left, upper, right, lower)
"""
self.markImg = self.markImg.crop(box)
self.w, self.h = self.markImg.size
self.size = self.w, self.h
self.draw = ImageDraw.Draw(self.markImg)
def check_font_size(self, word: str) -> bool:
"""
说明:
检查文本所需宽度是否大于图片宽度
参数:
:param word: 文本内容
"""
return self.font.getsize(word)[0] > self.w
async def atransparent(self, alpha_ratio: float = 1, n: int = 0):
"""
说明:
异步 图片透明化
参数:
:param alpha_ratio: 透明化程度
:param n: 透明化大小内边距
"""
await self.loop.run_in_executor(None, self.transparent, alpha_ratio, n)
def transparent(self, alpha_ratio: float = 1, n: int = 0):
"""
说明:
图片透明化
参数:
:param alpha_ratio: 透明化程度
:param n: 透明化大小内边距
"""
self.markImg = self.markImg.convert("RGBA")
x, y = self.markImg.size
for i in range(n, x - n):
for k in range(n, y - n):
color = self.markImg.getpixel((i, k))
color = color[:-1] + (int(100 * alpha_ratio),)
self.markImg.putpixel((i, k), color)
self.draw = ImageDraw.Draw(self.markImg)
def pic2bs4(self) -> str:
"""
说明:
BuildImage 转 base64
"""
buf = BytesIO()
self.markImg.save(buf, format="PNG")
base64_str = base64.b64encode(buf.getvalue()).decode()
return "base64://" + base64_str
def convert(self, type_: ModeType):
"""
说明:
修改图片类型
参数:
:param type_: 类型
"""
self.markImg = self.markImg.convert(type_)
async def arectangle(
self,
xy: Tuple[int, int, int, int],
fill: Optional[Tuple[int, int, int]] = None,
outline: Optional[str] = None,
width: int = 1,
):
"""
说明:
异步 画框
参数:
:param xy: 坐标
:param fill: 填充颜色
:param outline: 轮廓颜色
:param width: 线宽
"""
await self.loop.run_in_executor(None, self.rectangle, xy, fill, outline, width)
def rectangle(
self,
xy: Tuple[int, int, int, int],
fill: Optional[Tuple[int, int, int]] = None,
outline: Optional[str] = None,
width: int = 1,
):
"""
说明:
画框
参数:
:param xy: 坐标
:param fill: 填充颜色
:param outline: 轮廓颜色
:param width: 线宽
"""
self.draw.rectangle(xy, fill, outline, width)
async def apolygon(
self,
xy: List[Tuple[int, int]],
fill: Tuple[int, int, int] = (0, 0, 0),
outline: int = 1,
):
"""
说明:
异步 画多边形
参数:
:param xy: 坐标
:param fill: 颜色
:param outline: 线宽
"""
await self.loop.run_in_executor(None, self.polygon, xy, fill, outline)
def polygon(
self,
xy: List[Tuple[int, int]],
fill: Tuple[int, int, int] = (0, 0, 0),
outline: int = 1,
):
"""
说明:
画多边形
参数:
:param xy: 坐标
:param fill: 颜色
:param outline: 线宽
"""
self.draw.polygon(xy, fill, outline)
async def aline(
self,
xy: Tuple[int, int, int, int],
fill: Optional[Union[str, Tuple[int, int, int]]] = None,
width: int = 1,
):
"""
说明:
异步 画线
参数:
:param xy: 坐标
:param fill: 填充
:param width: 线宽
"""
await self.loop.run_in_executor(None, self.line, xy, fill, width)
def line(
self,
xy: Tuple[int, int, int, int],
fill: Optional[Union[Tuple[int, int, int], str]] = None,
width: int = 1,
):
"""
说明:
画线
参数:
:param xy: 坐标
:param fill: 填充
:param width: 线宽
"""
self.draw.line(xy, fill, width)
async def acircle(self):
"""
说明:
异步 将 BuildImage 图片变为圆形
"""
await self.loop.run_in_executor(None, self.circle)
def circle(self):
"""
说明:
使图像变圆
"""
self.markImg.convert("RGBA")
size = self.markImg.size
r2 = min(size[0], size[1])
if size[0] != size[1]:
self.markImg = self.markImg.resize((r2, r2), Image.ANTIALIAS)
width = 1
antialias = 4
ellipse_box = [0, 0, r2 - 2, r2 - 2]
mask = Image.new(
size=[int(dim * antialias) for dim in self.markImg.size],
mode="L",
color="black",
)
draw = ImageDraw.Draw(mask)
for offset, fill in (width / -2.0, "black"), (width / 2.0, "white"):
left, top = [(value + offset) * antialias for value in ellipse_box[:2]]
right, bottom = [(value - offset) * antialias for value in ellipse_box[2:]]
draw.ellipse([left, top, right, bottom], fill=fill)
mask = mask.resize(self.markImg.size, Image.LANCZOS)
try:
self.markImg.putalpha(mask)
except ValueError:
pass
async def acircle_corner(
self,
radii: int = 30,
point_list: List[Literal["lt", "rt", "lb", "rb"]] = ["lt", "rt", "lb", "rb"],
):
"""
说明:
异步 矩形四角变圆
参数:
:param radii: 半径
:param point_list: 需要变化的角
"""
await self.loop.run_in_executor(None, self.circle_corner, radii, point_list)
def circle_corner(
self,
radii: int = 30,
point_list: List[Literal["lt", "rt", "lb", "rb"]] = ["lt", "rt", "lb", "rb"],
):
"""
说明:
矩形四角变圆
参数:
:param radii: 半径
:param point_list: 需要变化的角
"""
# 画圆（用于分离4个角）
img = self.markImg.convert("RGBA")
alpha = img.split()[-1]
circle = Image.new("L", (radii * 2, radii * 2), 0)
draw = ImageDraw.Draw(circle)
draw.ellipse((0, 0, radii * 2, radii * 2), fill=255) # 黑色方形内切白色圆形
w, h = img.size
if "lt" in point_list:
alpha.paste(circle.crop((0, 0, radii, radii)), (0, 0))
if "rt" in point_list:
alpha.paste(circle.crop((radii, 0, radii * 2, radii)), (w - radii, 0))
if "lb" in point_list:
alpha.paste(circle.crop((0, radii, radii, radii * 2)), (0, h - radii))
if "rb" in point_list:
alpha.paste(
circle.crop((radii, radii, radii * 2, radii * 2)),
(w - radii, h - radii),
)
img.putalpha(alpha)
self.markImg = img
self.draw = ImageDraw.Draw(self.markImg)
async def arotate(self, angle: int, expand: bool = False):
"""
说明:
异步 旋转图片
参数:
:param angle: 角度
:param expand: 放大图片适应角度
"""
await self.loop.run_in_executor(None, self.rotate, angle, expand)
def rotate(self, angle: int, expand: bool = False):
"""
说明:
旋转图片
参数:
:param angle: 角度
:param expand: 放大图片适应角度
"""
self.markImg = self.markImg.rotate(angle, expand=expand)
async def atranspose(self, angle: Literal[0, 1, 2, 3, 4, 5, 6]):
"""
说明:
异步 旋转图片(包括边框)
参数:
:param angle: 角度
"""
await self.loop.run_in_executor(None, self.transpose, angle)
def transpose(self, angle: Literal[0, 1, 2, 3, 4, 5, 6]):
"""
说明:
旋转图片(包括边框)
参数:
:param angle: 角度
"""
self.markImg.transpose(angle)
async def afilter(self, filter_: str, aud: Optional[int] = None):
"""
说明:
异步 图片变化
参数:
:param filter_: 变化效果
:param aud: 利率
"""
await self.loop.run_in_executor(None, self.filter, filter_, aud)
def filter(self, filter_: str, aud: Optional[int] = None):
"""
说明:
图片变化
参数:
:param filter_: 变化效果
:param aud: 利率
"""
_x = None
if filter_ == "GaussianBlur": # 高斯模糊
_x = ImageFilter.GaussianBlur
elif filter_ == "EDGE_ENHANCE": # 锐化效果
_x = ImageFilter.EDGE_ENHANCE
elif filter_ == "BLUR": # 模糊效果
_x = ImageFilter.BLUR
elif filter_ == "CONTOUR": # 铅笔滤镜
_x = ImageFilter.CONTOUR
elif filter_ == "FIND_EDGES": # 边缘检测
_x = ImageFilter.FIND_EDGES
if _x:
if aud:
self.markImg = self.markImg.filter(_x(aud))
else:
self.markImg = self.markImg.filter(_x)
self.draw = ImageDraw.Draw(self.markImg)
async def areplace_color_tran(
self,
src_color: Union[
Tuple[int, int, int], Tuple[Tuple[int, int, int], Tuple[int, int, int]]
],
replace_color: Tuple[int, int, int],
):
"""
说明:
异步 颜色替换
参数:
:param src_color: 目标颜色，或者使用列表，设置阈值
:param replace_color: 替换颜色
"""
self.loop.run_in_executor(
None, self.replace_color_tran, src_color, replace_color
)
def replace_color_tran(
self,
src_color: Union[
Tuple[int, int, int], Tuple[Tuple[int, int, int], Tuple[int, int, int]]
],
replace_color: Tuple[int, int, int],
):
"""
说明:
颜色替换
参数:
:param src_color: 目标颜色，或者使用元祖，设置阈值
:param replace_color: 替换颜色
"""
if isinstance(src_color, tuple):
start_ = src_color[0]
end_ = src_color[1]
else:
start_ = src_color
end_ = None
for i in range(self.w):
for j in range(self.h):
r, g, b = self.markImg.getpixel((i, j))
if not end_:
if r == start_[0] and g == start_[1] and b == start_[2]:
self.markImg.putpixel((i, j), replace_color)
else:
if (
start_[0] <= r <= end_[0]
and start_[1] <= g <= end_[1]
and start_[2] <= b <= end_[2]
):
self.markImg.putpixel((i, j), replace_color)
#
def getchannel(self, type_):
self.markImg = self.markImg.getchannel(type_)
The provided code snippet includes necessary dependencies for implementing the `get_plugin_help` function. Write a Python function `def get_plugin_help(msg: str, is_super: bool = False) -> Optional[str]` to solve the following problem:
说明: 获取功能的帮助信息 参数: :param msg: 功能cmd :param is_super: 是否为超级用户
Here is the function:
def get_plugin_help(msg: str, is_super: bool = False) -> Optional[str]:
"""
说明:
获取功能的帮助信息
参数:
:param msg: 功能cmd
:param is_super: 是否为超级用户
"""
module = plugins2settings_manager.get_plugin_module(
msg
) or admin_manager.get_plugin_module(msg)
if module and (plugin_data := plugin_data_manager.get(module)):
plugin_data.superuser_usage
if is_super:
result = plugin_data.superuser_usage
else:
result = plugin_data.usage
if result:
width = 0
for x in result.split("\n"):
_width = len(x) * 24
width = width if width > _width else _width
height = len(result.split("\n")) * 45
A = BuildImage(width, height, font_size=24)
bk = BuildImage(
width,
height,
background=IMAGE_PATH / "background" / "1.png",
)
A.paste(bk, alpha=True)
A.text((int(width * 0.048), int(height * 0.21)), result)
return A.pic2bs4()
return None | 说明: 获取功能的帮助信息 参数: :param msg: 功能cmd :param is_super: 是否为超级用户 |
188,088 | import random
from asyncio.exceptions import TimeoutError
import nonebot
from nonebot.adapters.onebot.v11 import Bot
from nonebot.drivers import Driver
from configs.path_config import TEXT_PATH
from models.bag_user import BagUser
from models.group_info import GroupInfo
from services.log import logger
from utils.http_utils import AsyncHttpx
from utils.utils import GDict, scheduler
class GroupInfo(Model):
group_id = fields.CharField(255, pk=True)
"""群聊id"""
group_name = fields.TextField(default="")
"""群聊名称"""
max_member_count = fields.IntField(default=0)
"""最大人数"""
member_count = fields.IntField(default=0)
"""当前人数"""
group_flag: int = fields.IntField(default=0)
"""群认证标记"""
class Meta:
table = "group_info"
table_description = "群聊信息表"
def _run_script(cls):
return ["ALTER TABLE group_info ADD group_flag Integer NOT NULL DEFAULT 0;", # group_info表添加一个group_flag
"ALTER TABLE group_info ALTER COLUMN group_id TYPE character varying(255);"
# 将group_id字段类型改为character varying(255)
]
class logger:
TEMPLATE_A = "{}"
TEMPLATE_B = "[<u><c>{}</c></u>]: {}"
TEMPLATE_C = "用户[<u><e>{}</e></u>] 触发 [<u><c>{}</c></u>]: {}"
TEMPLATE_D = "群聊[<u><e>{}</e></u>] 用户[<u><e>{}</e></u>] 触发 [<u><c>{}</c></u>]: {}"
TEMPLATE_E = "群聊[<u><e>{}</e></u>] 用户[<u><e>{}</e></u>] 触发 [<u><c>{}</c></u>] [Target](<u><e>{}</e></u>): {}"
TEMPLATE_USER = "用户[<u><e>{}</e></u>] "
TEMPLATE_GROUP = "群聊[<u><e>{}</e></u>] "
TEMPLATE_COMMAND = "CMD[<u><c>{}</c></u>] "
TEMPLATE_TARGET = "[Target]([<u><e>{}</e></u>]) "
SUCCESS_TEMPLATE = "[<u><c>{}</c></u>]: {} | 参数[{}] 返回: [<y>{}</y>]"
WARNING_TEMPLATE = "[<u><y>{}</y></u>]: {}"
ERROR_TEMPLATE = "[<u><r>{}</r></u>]: {}"
def info(
cls,
info: str,
command: Optional[str] = None,
user_id: Optional[Union[int, str]] = None,
group_id: Optional[Union[int, str]] = None,
target: Optional[Any] = None,
):
template = cls.__parser_template(info, command, user_id, group_id, target)
logger_.opt(colors=True).info(template)
def success(
cls,
info: str,
command: str,
param: Optional[Dict[str, Any]] = None,
result: Optional[str] = "",
):
param_str = ""
if param:
param_str = ",".join([f"<m>{k}</m>:<g>{v}</g>" for k, v in param.items()])
logger_.opt(colors=True).success(
cls.SUCCESS_TEMPLATE.format(command, info, param_str, result)
)
def warning(
cls,
info: str,
command: Optional[str] = None,
user_id: Optional[Union[int, str]] = None,
group_id: Optional[Union[int, str]] = None,
target: Optional[Any] = None,
e: Optional[Exception] = None,
):
template = cls.__parser_template(info, command, user_id, group_id, target)
if e:
template += f" || 错误<r>{type(e)}: {e}</r>"
logger_.opt(colors=True).warning(template)
def error(
cls,
info: str,
command: Optional[str] = None,
user_id: Optional[Union[int, str]] = None,
group_id: Optional[Union[int, str]] = None,
target: Optional[Any] = None,
e: Optional[Exception] = None,
):
template = cls.__parser_template(info, command, user_id, group_id, target)
if e:
template += f" || 错误 <r>{type(e)}: {e}</r>"
logger_.opt(colors=True).error(template)
def debug(
cls,
info: str,
command: Optional[str] = None,
user_id: Optional[Union[int, str]] = None,
group_id: Optional[Union[int, str]] = None,
target: Optional[Any] = None,
e: Optional[Exception] = None,
):
template = cls.__parser_template(info, command, user_id, group_id, target)
if e:
template += f" || 错误 <r>{type(e)}: {e}</r>"
logger_.opt(colors=True).debug(template)
def __parser_template(
cls,
info: str,
command: Optional[str] = None,
user_id: Optional[Union[int, str]] = None,
group_id: Optional[Union[int, str]] = None,
target: Optional[Any] = None,
) -> str:
arg_list = []
template = ""
if group_id is not None:
template += cls.TEMPLATE_GROUP
arg_list.append(group_id)
if user_id is not None:
template += cls.TEMPLATE_USER
arg_list.append(user_id)
if command is not None:
template += cls.TEMPLATE_COMMAND
arg_list.append(command)
if target is not None:
template += cls.TEMPLATE_TARGET
arg_list.append(target)
arg_list.append(info)
template += "{}"
return template.format(*arg_list)
The provided code snippet includes necessary dependencies for implementing the `_` function. Write a Python function `async def _(bot: Bot)` to solve the following problem:
版本某些需要的变换
Here is the function:
async def _(bot: Bot):
"""
版本某些需要的变换
"""
# 清空不存在的群聊信息，并将已所有已存在的群聊group_flag设置为1（认证所有已存在的群）
if not await GroupInfo.get_or_none(group_id=114514):
# 标识符，该功能只需执行一次
await GroupInfo.create(
group_id=114514,
group_name="114514",
max_member_count=114514,
member_count=114514,
group_flag=1,
)
group_list = await bot.get_group_list()
group_list = [g["group_id"] for g in group_list]
_gl = [x.group_id for x in await GroupInfo.all()]
if 114514 in _gl:
_gl.remove(114514)
for group_id in _gl:
if group_id in group_list:
if group := await GroupInfo.get_or_none(group_id=group_id):
group.group_flag = 1
await group.save(update_fields=["group_flag"])
else:
group_info = await bot.get_group_info(group_id=group_id)
await GroupInfo.create(
group_id=group_info["group_id"],
group_name=group_info["group_name"],
max_member_count=group_info["max_member_count"],
member_count=group_info["member_count"],
group_flag=1,
)
logger.info(f"已添加群认证...", group_id=group_id)
else:
await GroupInfo.filter(group_id=group_id).delete()
logger.info(f"移除不存在的群聊信息", group_id=group_id) | 版本某些需要的变换 |
188,089 | import random
from asyncio.exceptions import TimeoutError
import nonebot
from nonebot.adapters.onebot.v11 import Bot
from nonebot.drivers import Driver
from configs.path_config import TEXT_PATH
from models.bag_user import BagUser
from models.group_info import GroupInfo
from services.log import logger
from utils.http_utils import AsyncHttpx
from utils.utils import GDict, scheduler
async def update_city():
"""
部分插件需要中国省份城市
这里直接更新，避免插件内代码重复
"""
china_city = TEXT_PATH / "china_city.json"
data = {}
if not china_city.exists():
try:
logger.debug("开始更新城市列表...")
res = await AsyncHttpx.get(
"http://www.weather.com.cn/data/city3jdata/china.html", timeout=5
)
res.encoding = "utf8"
provinces_data = json.loads(res.text)
for province in provinces_data.keys():
data[provinces_data[province]] = []
res = await AsyncHttpx.get(
f"http://www.weather.com.cn/data/city3jdata/provshi/{province}.html",
timeout=5,
)
res.encoding = "utf8"
city_data = json.loads(res.text)
for city in city_data.keys():
data[provinces_data[province]].append(city_data[city])
with open(china_city, "w", encoding="utf8") as f:
json.dump(data, f, indent=4, ensure_ascii=False)
logger.info("自动更新城市列表完成.....")
except TimeoutError as e:
logger.warning("自动更新城市列表超时...", e=e)
except ValueError as e:
logger.warning("自动城市列表失败.....", e=e)
except Exception as e:
logger.error(f"自动城市列表未知错误", e=e)
async def _():
await update_city() | null |
188,090 | from nonebot import on_command
from nonebot.permission import SUPERUSER
from nonebot.rule import to_me
from configs.config import Config
from services.log import logger
from utils.manager import (
group_manager,
plugins2block_manager,
plugins2cd_manager,
plugins2settings_manager,
)
from utils.utils import scheduler
reload_plugins_manager = on_command(
"重载配置", rule=to_me(), permission=SUPERUSER, priority=1, block=True
)
async def _():
plugins2settings_manager.reload()
plugins2cd_manager.reload()
plugins2block_manager.reload()
group_manager.reload()
Config.reload()
await reload_plugins_manager.send("重载完成...") | null |
188,091 | from nonebot import on_command
from nonebot.permission import SUPERUSER
from nonebot.rule import to_me
from configs.config import Config
from services.log import logger
from utils.manager import (
group_manager,
plugins2block_manager,
plugins2cd_manager,
plugins2settings_manager,
)
from utils.utils import scheduler
class logger:
TEMPLATE_A = "{}"
TEMPLATE_B = "[<u><c>{}</c></u>]: {}"
TEMPLATE_C = "用户[<u><e>{}</e></u>] 触发 [<u><c>{}</c></u>]: {}"
TEMPLATE_D = "群聊[<u><e>{}</e></u>] 用户[<u><e>{}</e></u>] 触发 [<u><c>{}</c></u>]: {}"
TEMPLATE_E = "群聊[<u><e>{}</e></u>] 用户[<u><e>{}</e></u>] 触发 [<u><c>{}</c></u>] [Target](<u><e>{}</e></u>): {}"
TEMPLATE_USER = "用户[<u><e>{}</e></u>] "
TEMPLATE_GROUP = "群聊[<u><e>{}</e></u>] "
TEMPLATE_COMMAND = "CMD[<u><c>{}</c></u>] "
TEMPLATE_TARGET = "[Target]([<u><e>{}</e></u>]) "
SUCCESS_TEMPLATE = "[<u><c>{}</c></u>]: {} | 参数[{}] 返回: [<y>{}</y>]"
WARNING_TEMPLATE = "[<u><y>{}</y></u>]: {}"
ERROR_TEMPLATE = "[<u><r>{}</r></u>]: {}"
def info(
cls,
info: str,
command: Optional[str] = None,
user_id: Optional[Union[int, str]] = None,
group_id: Optional[Union[int, str]] = None,
target: Optional[Any] = None,
):
template = cls.__parser_template(info, command, user_id, group_id, target)
logger_.opt(colors=True).info(template)
def success(
cls,
info: str,
command: str,
param: Optional[Dict[str, Any]] = None,
result: Optional[str] = "",
):
param_str = ""
if param:
param_str = ",".join([f"<m>{k}</m>:<g>{v}</g>" for k, v in param.items()])
logger_.opt(colors=True).success(
cls.SUCCESS_TEMPLATE.format(command, info, param_str, result)
)
def warning(
cls,
info: str,
command: Optional[str] = None,
user_id: Optional[Union[int, str]] = None,
group_id: Optional[Union[int, str]] = None,
target: Optional[Any] = None,
e: Optional[Exception] = None,
):
template = cls.__parser_template(info, command, user_id, group_id, target)
if e:
template += f" || 错误<r>{type(e)}: {e}</r>"
logger_.opt(colors=True).warning(template)
def error(
cls,
info: str,
command: Optional[str] = None,
user_id: Optional[Union[int, str]] = None,
group_id: Optional[Union[int, str]] = None,
target: Optional[Any] = None,
e: Optional[Exception] = None,
):
template = cls.__parser_template(info, command, user_id, group_id, target)
if e:
template += f" || 错误 <r>{type(e)}: {e}</r>"
logger_.opt(colors=True).error(template)
def debug(
cls,
info: str,
command: Optional[str] = None,
user_id: Optional[Union[int, str]] = None,
group_id: Optional[Union[int, str]] = None,
target: Optional[Any] = None,
e: Optional[Exception] = None,
):
template = cls.__parser_template(info, command, user_id, group_id, target)
if e:
template += f" || 错误 <r>{type(e)}: {e}</r>"
logger_.opt(colors=True).debug(template)
def __parser_template(
cls,
info: str,
command: Optional[str] = None,
user_id: Optional[Union[int, str]] = None,
group_id: Optional[Union[int, str]] = None,
target: Optional[Any] = None,
) -> str:
arg_list = []
template = ""
if group_id is not None:
template += cls.TEMPLATE_GROUP
arg_list.append(group_id)
if user_id is not None:
template += cls.TEMPLATE_USER
arg_list.append(user_id)
if command is not None:
template += cls.TEMPLATE_COMMAND
arg_list.append(command)
if target is not None:
template += cls.TEMPLATE_TARGET
arg_list.append(target)
arg_list.append(info)
template += "{}"
return template.format(*arg_list)
async def _():
if Config.get_config("reload_setting", "AUTO_RELOAD"):
plugins2settings_manager.reload()
plugins2cd_manager.reload()
plugins2block_manager.reload()
group_manager.reload()
Config.reload()
logger.debug("已自动重载所有配置文件...") | null |
188,092 | from nonebot import on_command
from nonebot.adapters.onebot.v11 import Bot, MessageEvent
from nonebot.permission import SUPERUSER
from nonebot.rule import to_me
from models.friend_user import FriendUser
from models.group_info import GroupInfo
from services.log import logger
update_group_info = on_command(
"更新群信息", rule=to_me(), permission=SUPERUSER, priority=1, block=True
)
class GroupInfo(Model):
group_id = fields.CharField(255, pk=True)
"""群聊id"""
group_name = fields.TextField(default="")
"""群聊名称"""
max_member_count = fields.IntField(default=0)
"""最大人数"""
member_count = fields.IntField(default=0)
"""当前人数"""
group_flag: int = fields.IntField(default=0)
"""群认证标记"""
class Meta:
table = "group_info"
table_description = "群聊信息表"
def _run_script(cls):
return ["ALTER TABLE group_info ADD group_flag Integer NOT NULL DEFAULT 0;", # group_info表添加一个group_flag
"ALTER TABLE group_info ALTER COLUMN group_id TYPE character varying(255);"
# 将group_id字段类型改为character varying(255)
]
class logger:
TEMPLATE_A = "{}"
TEMPLATE_B = "[<u><c>{}</c></u>]: {}"
TEMPLATE_C = "用户[<u><e>{}</e></u>] 触发 [<u><c>{}</c></u>]: {}"
TEMPLATE_D = "群聊[<u><e>{}</e></u>] 用户[<u><e>{}</e></u>] 触发 [<u><c>{}</c></u>]: {}"
TEMPLATE_E = "群聊[<u><e>{}</e></u>] 用户[<u><e>{}</e></u>] 触发 [<u><c>{}</c></u>] [Target](<u><e>{}</e></u>): {}"
TEMPLATE_USER = "用户[<u><e>{}</e></u>] "
TEMPLATE_GROUP = "群聊[<u><e>{}</e></u>] "
TEMPLATE_COMMAND = "CMD[<u><c>{}</c></u>] "
TEMPLATE_TARGET = "[Target]([<u><e>{}</e></u>]) "
SUCCESS_TEMPLATE = "[<u><c>{}</c></u>]: {} | 参数[{}] 返回: [<y>{}</y>]"
WARNING_TEMPLATE = "[<u><y>{}</y></u>]: {}"
ERROR_TEMPLATE = "[<u><r>{}</r></u>]: {}"
def info(
cls,
info: str,
command: Optional[str] = None,
user_id: Optional[Union[int, str]] = None,
group_id: Optional[Union[int, str]] = None,
target: Optional[Any] = None,
):
template = cls.__parser_template(info, command, user_id, group_id, target)
logger_.opt(colors=True).info(template)
def success(
cls,
info: str,
command: str,
param: Optional[Dict[str, Any]] = None,
result: Optional[str] = "",
):
param_str = ""
if param:
param_str = ",".join([f"<m>{k}</m>:<g>{v}</g>" for k, v in param.items()])
logger_.opt(colors=True).success(
cls.SUCCESS_TEMPLATE.format(command, info, param_str, result)
)
def warning(
cls,
info: str,
command: Optional[str] = None,
user_id: Optional[Union[int, str]] = None,
group_id: Optional[Union[int, str]] = None,
target: Optional[Any] = None,
e: Optional[Exception] = None,
):
template = cls.__parser_template(info, command, user_id, group_id, target)
if e:
template += f" || 错误<r>{type(e)}: {e}</r>"
logger_.opt(colors=True).warning(template)
def error(
cls,
info: str,
command: Optional[str] = None,
user_id: Optional[Union[int, str]] = None,
group_id: Optional[Union[int, str]] = None,
target: Optional[Any] = None,
e: Optional[Exception] = None,
):
template = cls.__parser_template(info, command, user_id, group_id, target)
if e:
template += f" || 错误 <r>{type(e)}: {e}</r>"
logger_.opt(colors=True).error(template)
def debug(
cls,
info: str,
command: Optional[str] = None,
user_id: Optional[Union[int, str]] = None,
group_id: Optional[Union[int, str]] = None,
target: Optional[Any] = None,
e: Optional[Exception] = None,
):
template = cls.__parser_template(info, command, user_id, group_id, target)
if e:
template += f" || 错误 <r>{type(e)}: {e}</r>"
logger_.opt(colors=True).debug(template)
def __parser_template(
cls,
info: str,
command: Optional[str] = None,
user_id: Optional[Union[int, str]] = None,
group_id: Optional[Union[int, str]] = None,
target: Optional[Any] = None,
) -> str:
arg_list = []
template = ""
if group_id is not None:
template += cls.TEMPLATE_GROUP
arg_list.append(group_id)
if user_id is not None:
template += cls.TEMPLATE_USER
arg_list.append(user_id)
if command is not None:
template += cls.TEMPLATE_COMMAND
arg_list.append(command)
if target is not None:
template += cls.TEMPLATE_TARGET
arg_list.append(target)
arg_list.append(info)
template += "{}"
return template.format(*arg_list)
async def _(bot: Bot, event: MessageEvent):
gl = await bot.get_group_list()
gl = [g["group_id"] for g in gl]
num = 0
for g in gl:
try:
group_info = await bot.get_group_info(group_id=g)
await GroupInfo.update_or_create(
group_id=str(group_info["group_id"]),
defaults={
"group_name": group_info["group_name"],
"max_member_count": group_info["max_member_count"],
"member_count": group_info["member_count"],
},
)
num += 1
logger.debug(
"群聊信息更新成功", "更新群信息", event.user_id, target=group_info["group_id"]
)
except Exception as e:
logger.error(f"更新群聊信息失败", "更新群信息", event.user_id, target=g, e=e)
await update_group_info.send(f"成功更新了 {len(gl)} 个群的信息")
logger.info(f"更新群聊信息完成，共更新了 {len(gl)} 个群的信息", "更新群信息", event.user_id) | null |
188,093 | from nonebot import on_command
from nonebot.adapters.onebot.v11 import Bot, MessageEvent
from nonebot.permission import SUPERUSER
from nonebot.rule import to_me
from models.friend_user import FriendUser
from models.group_info import GroupInfo
from services.log import logger
update_friend_info = on_command(
"更新好友信息", rule=to_me(), permission=SUPERUSER, priority=1, block=True
)
class FriendUser(Model):
async def get_user_name(cls, user_id: Union[int, str]) -> str:
async def get_user_nickname(cls, user_id: Union[int, str]) -> str:
async def set_user_nickname(cls, user_id: Union[int, str], nickname: str):
async def _run_script(cls):
class logger:
def info(
cls,
info: str,
command: Optional[str] = None,
user_id: Optional[Union[int, str]] = None,
group_id: Optional[Union[int, str]] = None,
target: Optional[Any] = None,
):
def success(
cls,
info: str,
command: str,
param: Optional[Dict[str, Any]] = None,
result: Optional[str] = "",
):
def warning(
cls,
info: str,
command: Optional[str] = None,
user_id: Optional[Union[int, str]] = None,
group_id: Optional[Union[int, str]] = None,
target: Optional[Any] = None,
e: Optional[Exception] = None,
):
def error(
cls,
info: str,
command: Optional[str] = None,
user_id: Optional[Union[int, str]] = None,
group_id: Optional[Union[int, str]] = None,
target: Optional[Any] = None,
e: Optional[Exception] = None,
):
def debug(
cls,
info: str,
command: Optional[str] = None,
user_id: Optional[Union[int, str]] = None,
group_id: Optional[Union[int, str]] = None,
target: Optional[Any] = None,
e: Optional[Exception] = None,
):
def __parser_template(
cls,
info: str,
command: Optional[str] = None,
user_id: Optional[Union[int, str]] = None,
group_id: Optional[Union[int, str]] = None,
target: Optional[Any] = None,
) -> str:
async def _(bot: Bot, event: MessageEvent):
num = 0
error_list = []
fl = await bot.get_friend_list()
for f in fl:
try:
await FriendUser.update_or_create(
user_id=str(f["user_id"]), defaults={"nickname": f["nickname"]}
)
logger.debug(f"更新好友信息成功", "更新好友信息", event.user_id, target=f["user_id"])
num += 1
except Exception as e:
logger.error(f"更新好友信息失败", "更新好友信息", event.user_id, target=f["user_id"], e=e)
await update_friend_info.send(f"成功更新了 {num} 个好友的信息")
if error_list:
await update_friend_info.send(f"以下好友更新失败:\n" + "\n".join(error_list))
logger.info(f"更新好友信息完成，共更新了 {num} 个群的信息", "更新好友信息", event.user_id) | null |
188,094 | import asyncio
import os
import time
from nonebot import on_command
from nonebot.permission import SUPERUSER
from nonebot.rule import to_me
from configs.path_config import TEMP_PATH
from services.log import logger
from utils.manager import resources_manager
from utils.utils import scheduler
clear_data = on_command(
"清理临时数据", rule=to_me(), permission=SUPERUSER, priority=1, block=True
)
logger.debug("开始清理临时文件...")
size = 0
class logger:
TEMPLATE_A = "{}"
TEMPLATE_B = "[<u><c>{}</c></u>]: {}"
TEMPLATE_C = "用户[<u><e>{}</e></u>] 触发 [<u><c>{}</c></u>]: {}"
TEMPLATE_D = "群聊[<u><e>{}</e></u>] 用户[<u><e>{}</e></u>] 触发 [<u><c>{}</c></u>]: {}"
TEMPLATE_E = "群聊[<u><e>{}</e></u>] 用户[<u><e>{}</e></u>] 触发 [<u><c>{}</c></u>] [Target](<u><e>{}</e></u>): {}"
TEMPLATE_USER = "用户[<u><e>{}</e></u>] "
TEMPLATE_GROUP = "群聊[<u><e>{}</e></u>] "
TEMPLATE_COMMAND = "CMD[<u><c>{}</c></u>] "
TEMPLATE_TARGET = "[Target]([<u><e>{}</e></u>]) "
SUCCESS_TEMPLATE = "[<u><c>{}</c></u>]: {} | 参数[{}] 返回: [<y>{}</y>]"
WARNING_TEMPLATE = "[<u><y>{}</y></u>]: {}"
ERROR_TEMPLATE = "[<u><r>{}</r></u>]: {}"
def info(
cls,
info: str,
command: Optional[str] = None,
user_id: Optional[Union[int, str]] = None,
group_id: Optional[Union[int, str]] = None,
target: Optional[Any] = None,
):
template = cls.__parser_template(info, command, user_id, group_id, target)
logger_.opt(colors=True).info(template)
def success(
cls,
info: str,
command: str,
param: Optional[Dict[str, Any]] = None,
result: Optional[str] = "",
):
param_str = ""
if param:
param_str = ",".join([f"<m>{k}</m>:<g>{v}</g>" for k, v in param.items()])
logger_.opt(colors=True).success(
cls.SUCCESS_TEMPLATE.format(command, info, param_str, result)
)
def warning(
cls,
info: str,
command: Optional[str] = None,
user_id: Optional[Union[int, str]] = None,
group_id: Optional[Union[int, str]] = None,
target: Optional[Any] = None,
e: Optional[Exception] = None,
):
template = cls.__parser_template(info, command, user_id, group_id, target)
if e:
template += f" || 错误<r>{type(e)}: {e}</r>"
logger_.opt(colors=True).warning(template)
def error(
cls,
info: str,
command: Optional[str] = None,
user_id: Optional[Union[int, str]] = None,
group_id: Optional[Union[int, str]] = None,
target: Optional[Any] = None,
e: Optional[Exception] = None,
):
template = cls.__parser_template(info, command, user_id, group_id, target)
if e:
template += f" || 错误 <r>{type(e)}: {e}</r>"
logger_.opt(colors=True).error(template)
def debug(
cls,
info: str,
command: Optional[str] = None,
user_id: Optional[Union[int, str]] = None,
group_id: Optional[Union[int, str]] = None,
target: Optional[Any] = None,
e: Optional[Exception] = None,
):
template = cls.__parser_template(info, command, user_id, group_id, target)
if e:
template += f" || 错误 <r>{type(e)}: {e}</r>"
logger_.opt(colors=True).debug(template)
def __parser_template(
cls,
info: str,
command: Optional[str] = None,
user_id: Optional[Union[int, str]] = None,
group_id: Optional[Union[int, str]] = None,
target: Optional[Any] = None,
) -> str:
arg_list = []
template = ""
if group_id is not None:
template += cls.TEMPLATE_GROUP
arg_list.append(group_id)
if user_id is not None:
template += cls.TEMPLATE_USER
arg_list.append(user_id)
if command is not None:
template += cls.TEMPLATE_COMMAND
arg_list.append(command)
if target is not None:
template += cls.TEMPLATE_TARGET
arg_list.append(target)
arg_list.append(info)
template += "{}"
return template.format(*arg_list)
async def _():
await clear_data.send("开始清理临时数据....")
size = await asyncio.get_event_loop().run_in_executor(None, _clear_data)
await clear_data.send("共清理了 {:.2f}MB 的数据...".format(size / 1024 / 1024))
logger.info("清理临时数据完成，" + "共清理了 {:.2f}MB 的数据...".format(size / 1024 / 1024)) | null |
188,095 | import asyncio
import os
import time
from nonebot import on_command
from nonebot.permission import SUPERUSER
from nonebot.rule import to_me
from configs.path_config import TEMP_PATH
from services.log import logger
from utils.manager import resources_manager
from utils.utils import scheduler
logger.debug("开始清理临时文件...")
size = 0
class logger:
def info(
cls,
info: str,
command: Optional[str] = None,
user_id: Optional[Union[int, str]] = None,
group_id: Optional[Union[int, str]] = None,
target: Optional[Any] = None,
):
def success(
cls,
info: str,
command: str,
param: Optional[Dict[str, Any]] = None,
result: Optional[str] = "",
):
def warning(
cls,
info: str,
command: Optional[str] = None,
user_id: Optional[Union[int, str]] = None,
group_id: Optional[Union[int, str]] = None,
target: Optional[Any] = None,
e: Optional[Exception] = None,
):
def error(
cls,
info: str,
command: Optional[str] = None,
user_id: Optional[Union[int, str]] = None,
group_id: Optional[Union[int, str]] = None,
target: Optional[Any] = None,
e: Optional[Exception] = None,
):
def debug(
cls,
info: str,
command: Optional[str] = None,
user_id: Optional[Union[int, str]] = None,
group_id: Optional[Union[int, str]] = None,
target: Optional[Any] = None,
e: Optional[Exception] = None,
):
def __parser_template(
cls,
info: str,
command: Optional[str] = None,
user_id: Optional[Union[int, str]] = None,
group_id: Optional[Union[int, str]] = None,
target: Optional[Any] = None,
) -> str:
async def _():
size = await asyncio.get_event_loop().run_in_executor(None, _clear_data)
logger.info("自动清理临时数据完成，" + "共清理了 {:.2f}MB 的数据...".format(size / 1024 / 1024)) | null |
188,096 | import asyncio
from nonebot import on_command
from nonebot.adapters.onebot.v11 import Bot, GroupMessageEvent, Message, MessageEvent
from nonebot.params import CommandArg
from nonebot.permission import SUPERUSER
from nonebot.rule import to_me
from tortoise import Tortoise
from services.db_context import TestSQL
from services.log import logger
from utils.message_builder import custom_forward_msg
exec_ = on_command("exec", rule=to_me(), permission=SUPERUSER, priority=1, block=True)
class TestSQL(Model):
id = fields.IntField(pk=True, generated=True, auto_increment=True)
"""自增id"""
class Meta:
table = "test_sql"
table_description = "执行SQL命令，不记录任何数据"
def custom_forward_msg(
msg_list: List[Union[str, Message]],
uin: Union[int, str],
name: str = f"这里是{NICKNAME}",
) -> List[dict]:
"""
说明:
生成自定义合并消息
参数:
:param msg_list: 消息列表
:param uin: 发送者 QQ
:param name: 自定义名称
"""
uin = int(uin)
mes_list = []
for _message in msg_list:
data = {
"type": "node",
"data": {
"name": name,
"uin": f"{uin}",
"content": _message,
},
}
mes_list.append(data)
return mes_list
async def _(bot: Bot, event: MessageEvent, arg: Message = CommandArg()):
sql = arg.extract_plain_text().strip()
if not sql:
await exec_.finish("未接受到sql语句")
db = Tortoise.get_connection("default")
# try:
# 判断是否为SELECT语句
if sql.lower().startswith("select"):
pass
# # 分割语句
try:
page = int(sql.split(" ")[-1]) - 1
sql_list = sql.split(" ")[:-1]
except ValueError:
page = 0
sql_list = sql.split(" ")
# 拼接语句
sql = " ".join(sql_list)
res = await db.execute_query_dict(sql)
msg_list = [f"第{page+1}页查询结果："]
# logger.info(res)
# 获取所有字段
keys = res[0].keys()
# 每页10条
for i in res[page * 10 : (page + 1) * 10]:
msg = ""
for key in keys:
msg += f"{key}: {i[key]}\n"
msg += f"第{page+1}页第{res.index(i)+1}条"
msg_list.append(msg)
# 检查是私聊还是群聊
if isinstance(event, GroupMessageEvent):
forward_msg_list = custom_forward_msg(msg_list, bot.self_id)
await bot.send_group_forward_msg(
group_id=event.group_id, messages=forward_msg_list
)
else:
for msg in msg_list:
await exec_.send(msg)
await asyncio.sleep(0.2)
return
else:
await TestSQL.raw(sql)
await exec_.send("执行 sql 语句成功.")
# except Exception as e:
# await exec_.send(f"执行 sql 语句失败 {type(e)}：{e}")
# logger.error(f"执行 sql 语句失败 {type(e)}：{e}") | null |
188,097 | import asyncio
from nonebot import on_command
from nonebot.adapters.onebot.v11 import Bot, GroupMessageEvent, Message, MessageEvent
from nonebot.params import CommandArg
from nonebot.permission import SUPERUSER
from nonebot.rule import to_me
from tortoise import Tortoise
from services.db_context import TestSQL
from services.log import logger
from utils.message_builder import custom_forward_msg
tables = on_command("查看所有表", rule=to_me(), permission=SUPERUSER, priority=1, block=True)
async def _(bot: Bot, event: MessageEvent):
# 获取所有表
db = Tortoise.get_connection("default")
query = await db.execute_query_dict(
"select tablename from pg_tables where schemaname = 'public'"
)
msg = "数据库中的所有表名：\n"
for tablename in query:
msg += str(tablename["tablename"]) + "\n"
await tables.finish(msg) | null |
188,098 | from typing import Tuple
from nonebot import on_command
from nonebot.adapters.onebot.v11 import Bot, Message, MessageEvent
from nonebot.params import Command, CommandArg
from nonebot.permission import SUPERUSER
from nonebot.rule import to_me
from models.group_info import GroupInfo
from services.log import logger
from utils.depends import OneCommand
from utils.manager import requests_manager
from utils.message_builder import image
from utils.utils import is_number
cls_group = on_command(
"查看所有群组", rule=to_me(), permission=SUPERUSER, priority=1, block=True
)
async def _(bot: Bot):
gl = await bot.get_group_list()
msg = ["{group_id} {group_name}".format_map(g) for g in gl]
msg = "\n".join(msg)
msg = f"bot:{bot.self_id}\n| 群号 | 群名 | 共{len(gl)}个群\n" + msg
await cls_group.send(msg) | null |
188,099 | from typing import Tuple
from nonebot import on_command
from nonebot.adapters.onebot.v11 import Bot, Message, MessageEvent
from nonebot.params import Command, CommandArg
from nonebot.permission import SUPERUSER
from nonebot.rule import to_me
from models.group_info import GroupInfo
from services.log import logger
from utils.depends import OneCommand
from utils.manager import requests_manager
from utils.message_builder import image
from utils.utils import is_number
cls_friend = on_command(
"查看所有好友", rule=to_me(), permission=SUPERUSER, priority=1, block=True
)
async def _(bot: Bot):
gl = await bot.get_friend_list()
msg = ["{user_id} {nickname}".format_map(g) for g in gl]
msg = "\n".join(msg)
msg = f"| QQ号 | 昵称 | 共{len(gl)}个好友\n" + msg
await cls_friend.send(msg) | null |
188,100 | from typing import Tuple
from nonebot import on_command
from nonebot.adapters.onebot.v11 import Bot, Message, MessageEvent
from nonebot.params import Command, CommandArg
from nonebot.permission import SUPERUSER
from nonebot.rule import to_me
from models.group_info import GroupInfo
from services.log import logger
from utils.depends import OneCommand
from utils.manager import requests_manager
from utils.message_builder import image
from utils.utils import is_number
friend_handle = on_command(
"同意好友请求", aliases={"拒绝好友请求"}, permission=SUPERUSER, priority=1, block=True
)
def OneCommand():
"""
获取单个命令Command
"""
async def dependency(
cmd: Tuple[str, ...] = Command(),
):
return cmd[0] if cmd else None
return Depends(dependency)
{
"run_sql": [], # 需要启动前运行的sql语句
"_shop_before_handle": {}, # 商品使用前函数
"_shop_after_handle": {}, # 商品使用后函数
}
def is_number(s: Union[int, str]) -> bool:
"""
说明:
检测 s 是否为数字
参数:
:param s: 文本
"""
if isinstance(s, int):
return True
try:
float(s)
return True
except ValueError:
pass
try:
import unicodedata
unicodedata.numeric(s)
return True
except (TypeError, ValueError):
pass
return False
async def _(bot: Bot, cmd: str = OneCommand(), arg: Message = CommandArg()):
id_ = arg.extract_plain_text().strip()
if is_number(id_):
id_ = int(id_)
if cmd[:2] == "同意":
flag = await requests_manager.approve(bot, id_, "private")
else:
flag = await requests_manager.refused(bot, id_, "private")
if flag == 1:
await friend_handle.send(f"{cmd[:2]}好友请求失败，该请求已失效..")
requests_manager.delete_request(id_, "private")
elif flag == 2:
await friend_handle.send(f"{cmd[:2]}好友请求失败，未找到此id的请求..")
else:
await friend_handle.send(f"{cmd[:2]}好友请求成功！")
else:
await friend_handle.send("id必须为纯数字！") | null |
188,101 | from typing import Tuple
from nonebot import on_command
from nonebot.adapters.onebot.v11 import Bot, Message, MessageEvent
from nonebot.params import Command, CommandArg
from nonebot.permission import SUPERUSER
from nonebot.rule import to_me
from models.group_info import GroupInfo
from services.log import logger
from utils.depends import OneCommand
from utils.manager import requests_manager
from utils.message_builder import image
from utils.utils import is_number
group_handle = on_command(
"同意群聊请求", aliases={"拒绝群聊请求"}, permission=SUPERUSER, priority=1, block=True
)
class GroupInfo(Model):
group_id = fields.CharField(255, pk=True)
"""群聊id"""
group_name = fields.TextField(default="")
"""群聊名称"""
max_member_count = fields.IntField(default=0)
"""最大人数"""
member_count = fields.IntField(default=0)
"""当前人数"""
group_flag: int = fields.IntField(default=0)
"""群认证标记"""
class Meta:
table = "group_info"
table_description = "群聊信息表"
def _run_script(cls):
return ["ALTER TABLE group_info ADD group_flag Integer NOT NULL DEFAULT 0;", # group_info表添加一个group_flag
"ALTER TABLE group_info ALTER COLUMN group_id TYPE character varying(255);"
# 将group_id字段类型改为character varying(255)
]
class logger:
TEMPLATE_A = "{}"
TEMPLATE_B = "[<u><c>{}</c></u>]: {}"
TEMPLATE_C = "用户[<u><e>{}</e></u>] 触发 [<u><c>{}</c></u>]: {}"
TEMPLATE_D = "群聊[<u><e>{}</e></u>] 用户[<u><e>{}</e></u>] 触发 [<u><c>{}</c></u>]: {}"
TEMPLATE_E = "群聊[<u><e>{}</e></u>] 用户[<u><e>{}</e></u>] 触发 [<u><c>{}</c></u>] [Target](<u><e>{}</e></u>): {}"
TEMPLATE_USER = "用户[<u><e>{}</e></u>] "
TEMPLATE_GROUP = "群聊[<u><e>{}</e></u>] "
TEMPLATE_COMMAND = "CMD[<u><c>{}</c></u>] "
TEMPLATE_TARGET = "[Target]([<u><e>{}</e></u>]) "
SUCCESS_TEMPLATE = "[<u><c>{}</c></u>]: {} | 参数[{}] 返回: [<y>{}</y>]"
WARNING_TEMPLATE = "[<u><y>{}</y></u>]: {}"
ERROR_TEMPLATE = "[<u><r>{}</r></u>]: {}"
def info(
cls,
info: str,
command: Optional[str] = None,
user_id: Optional[Union[int, str]] = None,
group_id: Optional[Union[int, str]] = None,
target: Optional[Any] = None,
):
template = cls.__parser_template(info, command, user_id, group_id, target)
logger_.opt(colors=True).info(template)
def success(
cls,
info: str,
command: str,
param: Optional[Dict[str, Any]] = None,
result: Optional[str] = "",
):
param_str = ""
if param:
param_str = ",".join([f"<m>{k}</m>:<g>{v}</g>" for k, v in param.items()])
logger_.opt(colors=True).success(
cls.SUCCESS_TEMPLATE.format(command, info, param_str, result)
)
def warning(
cls,
info: str,
command: Optional[str] = None,
user_id: Optional[Union[int, str]] = None,
group_id: Optional[Union[int, str]] = None,
target: Optional[Any] = None,
e: Optional[Exception] = None,
):
template = cls.__parser_template(info, command, user_id, group_id, target)
if e:
template += f" || 错误<r>{type(e)}: {e}</r>"
logger_.opt(colors=True).warning(template)
def error(
cls,
info: str,
command: Optional[str] = None,
user_id: Optional[Union[int, str]] = None,
group_id: Optional[Union[int, str]] = None,
target: Optional[Any] = None,
e: Optional[Exception] = None,
):
template = cls.__parser_template(info, command, user_id, group_id, target)
if e:
template += f" || 错误 <r>{type(e)}: {e}</r>"
logger_.opt(colors=True).error(template)
def debug(
cls,
info: str,
command: Optional[str] = None,
user_id: Optional[Union[int, str]] = None,
group_id: Optional[Union[int, str]] = None,
target: Optional[Any] = None,
e: Optional[Exception] = None,
):
template = cls.__parser_template(info, command, user_id, group_id, target)
if e:
template += f" || 错误 <r>{type(e)}: {e}</r>"
logger_.opt(colors=True).debug(template)
def __parser_template(
cls,
info: str,
command: Optional[str] = None,
user_id: Optional[Union[int, str]] = None,
group_id: Optional[Union[int, str]] = None,
target: Optional[Any] = None,
) -> str:
arg_list = []
template = ""
if group_id is not None:
template += cls.TEMPLATE_GROUP
arg_list.append(group_id)
if user_id is not None:
template += cls.TEMPLATE_USER
arg_list.append(user_id)
if command is not None:
template += cls.TEMPLATE_COMMAND
arg_list.append(command)
if target is not None:
template += cls.TEMPLATE_TARGET
arg_list.append(target)
arg_list.append(info)
template += "{}"
return template.format(*arg_list)
def OneCommand():
"""
获取单个命令Command
"""
async def dependency(
cmd: Tuple[str, ...] = Command(),
):
return cmd[0] if cmd else None
return Depends(dependency)
{
"run_sql": [], # 需要启动前运行的sql语句
"_shop_before_handle": {}, # 商品使用前函数
"_shop_after_handle": {}, # 商品使用后函数
}
def is_number(s: Union[int, str]) -> bool:
"""
说明:
检测 s 是否为数字
参数:
:param s: 文本
"""
if isinstance(s, int):
return True
try:
float(s)
return True
except ValueError:
pass
try:
import unicodedata
unicodedata.numeric(s)
return True
except (TypeError, ValueError):
pass
return False
async def _(
bot: Bot, event: MessageEvent, cmd: str = OneCommand(), arg: Message = CommandArg()
):
id_ = arg.extract_plain_text().strip()
flag = None
if is_number(id_):
id_ = int(id_)
if cmd[:2] == "同意":
rid = requests_manager.get_group_id(id_)
if rid:
if group := await GroupInfo.get_or_none(group_id=str(rid)):
group.group_flag = 1
await group.save(update_fields=["group_flag"])
else:
group_info = await bot.get_group_info(group_id=rid)
await GroupInfo.create(
group_id=str(rid),
group_name=group_info["group_name"],
max_member_count=group_info["max_member_count"],
member_count=group_info["member_count"],
group_flag=1,
)
flag = await requests_manager.approve(bot, id_, "group")
else:
await group_handle.send("同意群聊请求失败，未找到此id的请求..")
logger.info("同意群聊请求失败，未找到此id的请求..", cmd, event.user_id)
else:
flag = await requests_manager.refused(bot, id_, "group")
if flag == 1:
await group_handle.send(f"{cmd[:2]}群聊请求失败，该请求已失效..")
requests_manager.delete_request(id_, "group")
elif flag == 2:
await group_handle.send(f"{cmd[:2]}群聊请求失败，未找到此id的请求..")
else:
await group_handle.send(f"{cmd[:2]}群聊请求成功！")
else:
await group_handle.send("id必须为纯数字！") | null |
188,102 | from typing import Tuple
from nonebot import on_command
from nonebot.adapters.onebot.v11 import Bot, Message, MessageEvent
from nonebot.params import Command, CommandArg
from nonebot.permission import SUPERUSER
from nonebot.rule import to_me
from models.group_info import GroupInfo
from services.log import logger
from utils.depends import OneCommand
from utils.manager import requests_manager
from utils.message_builder import image
from utils.utils import is_number
t = on_command("查看所有请求", permission=SUPERUSER, priority=1, block=True)
def image(
file: Optional[Union[str, Path, bytes, BuildImage, io.BytesIO, BuildMat]] = None,
b64: Optional[str] = None,
) -> MessageSegment:
async def _():
_str = ""
for type_ in ["private", "group"]:
msg = await requests_manager.show(type_)
if msg:
_str += image(msg)
else:
_str += "没有任何好友请求.." if type_ == "private" else "没有任何群聊请求.."
if type_ == "private":
_str += "\n--------------------\n"
await cls_request.send(Message(_str)) | null |
188,103 | from typing import Tuple
from nonebot import on_command
from nonebot.adapters.onebot.v11 import Bot, Message, MessageEvent
from nonebot.params import Command, CommandArg
from nonebot.permission import SUPERUSER
from nonebot.rule import to_me
from models.group_info import GroupInfo
from services.log import logger
from utils.depends import OneCommand
from utils.manager import requests_manager
from utils.message_builder import image
from utils.utils import is_number
clear_request = on_command("清空所有请求", permission=SUPERUSER, priority=1, block=True)
async def _():
requests_manager.clear()
await clear_request.send("已清空所有好友/群聊请求..") | null |
188,104 | from typing import List, Tuple
from nonebot import on_command
from nonebot.adapters.onebot.v11 import Bot, GroupMessageEvent, Message, MessageEvent
from nonebot.exception import ActionFailed
from nonebot.params import CommandArg
from nonebot.permission import SUPERUSER
from models.level_user import LevelUser
from services.log import logger
from utils.depends import AtList, OneCommand
from utils.message_builder import at
from utils.utils import is_number
age__ = """
usage：
增删改用户的权限
指令：
添加权限 [at] [权限]
添加权限 [qq] [group_id] [权限]
删除权限 [at]
删除权限 [qq] [group_id]
""".strip()
super_cmd = on_command(
"添加管理",
aliases={"删除管理", "添加权限", "删除权限"},
priority=1,
permission=SUPERUSER,
block=True,
)
class LevelUser(Model):
async def get_user_level(cls, user_id: Union[int, str], group_id: Union[int, str]) -> int:
async def set_level(
cls, user_id: Union[int, str], group_id: Union[int, str], level: int, group_flag: int = 0
):
async def delete_level(cls, user_id: Union[int, str], group_id: Union[int, str]) -> bool:
async def check_level(cls, user_id: Union[int, str], group_id: Union[int, str], level: int) -> bool:
async def is_group_flag(cls, user_id: Union[int, str], group_id: Union[int, str]) -> bool:
async def _run_script(cls):
class logger:
def info(
cls,
info: str,
command: Optional[str] = None,
user_id: Optional[Union[int, str]] = None,
group_id: Optional[Union[int, str]] = None,
target: Optional[Any] = None,
):
def success(
cls,
info: str,
command: str,
param: Optional[Dict[str, Any]] = None,
result: Optional[str] = "",
):
def warning(
cls,
info: str,
command: Optional[str] = None,
user_id: Optional[Union[int, str]] = None,
group_id: Optional[Union[int, str]] = None,
target: Optional[Any] = None,
e: Optional[Exception] = None,
):
def error(
cls,
info: str,
command: Optional[str] = None,
user_id: Optional[Union[int, str]] = None,
group_id: Optional[Union[int, str]] = None,
target: Optional[Any] = None,
e: Optional[Exception] = None,
):
def debug(
cls,
info: str,
command: Optional[str] = None,
user_id: Optional[Union[int, str]] = None,
group_id: Optional[Union[int, str]] = None,
target: Optional[Any] = None,
e: Optional[Exception] = None,
):
def __parser_template(
cls,
info: str,
command: Optional[str] = None,
user_id: Optional[Union[int, str]] = None,
group_id: Optional[Union[int, str]] = None,
target: Optional[Any] = None,
) -> str:
def OneCommand():
def AtList(msg: Optional[str] = None, contain_reply: bool = True) -> List[int]:
def at(qq: Union[int, str]) -> MessageSegment:
{
"run_sql": [], # 需要启动前运行的sql语句
"_shop_before_handle": {}, # 商品使用前函数
"_shop_after_handle": {}, # 商品使用后函数
}
def is_number(s: Union[int, str]) -> bool:
async def _(
bot: Bot,
event: MessageEvent,
cmd: str = OneCommand(),
arg: Message = CommandArg(),
at_list: List[int] = AtList(),
):
group_id = event.group_id if isinstance(event, GroupMessageEvent) else -1
level = None
args = arg.extract_plain_text().strip().split()
flag = 2
qq = None
try:
if at_list:
qq = at_list[0]
if cmd[:2] == "添加" and args and is_number(args[0]):
level = int(args[0])
else:
if cmd[:2] == "添加":
if (
len(args) > 2
and is_number(args[0])
and is_number(args[1])
and is_number(args[2])
):
qq = int(args[0])
group_id = int(args[1])
level = int(args[2])
else:
if len(args) > 1 and is_number(args[0]) and is_number(args[1]):
qq = int(args[0])
group_id = int(args[1])
flag = 1
level = -1 if cmd[:2] == "删除" else level
if group_id == -1 or not level or not qq:
raise IndexError()
except IndexError:
await super_cmd.finish(__plugin_usage__)
if not qq:
await super_cmd.finish("未指定对象...")
try:
if cmd[:2] == "添加":
await LevelUser.set_level(qq, group_id, level, 1)
result = f"设置权限成功, 权限: {level}"
else:
if await LevelUser.delete_level(qq, group_id):
result = "删除管理成功!"
else:
result = "该账号无管理权限!"
if flag == 2:
await super_cmd.send(result)
elif flag == 1:
try:
await bot.send_group_msg(
group_id=group_id,
message=Message(
f"{at(qq)}管理员修改了你的权限"
f"\n--------\n你当前的权限等级：{level if level != -1 else 0}"
),
)
except ActionFailed:
pass
await super_cmd.send("修改成功")
logger.info(
f"修改权限: {level if level != -1 else 0}", cmd, event.user_id, group_id, qq
)
except Exception as e:
await super_cmd.send("执行指令失败!")
logger.error(f"执行指令失败", cmd, event.user_id, group_id, qq, e=e) | null |
188,105 | from typing import Tuple
from nonebot import on_command, on_regex
from nonebot.adapters.onebot.v11 import (
GROUP,
Bot,
GroupMessageEvent,
Message,
MessageEvent,
)
from nonebot.params import Command, CommandArg
from nonebot.permission import SUPERUSER
from nonebot.rule import to_me
from configs.config import NICKNAME
from models.group_info import GroupInfo
from services.log import logger
from utils.depends import OneCommand
from utils.image_utils import text2image
from utils.manager import group_manager, plugins2settings_manager
from utils.message_builder import image
from utils.utils import is_number
del_group = on_command("退群", rule=to_me(), permission=SUPERUSER, priority=1, block=True)
class GroupInfo(Model):
group_id = fields.CharField(255, pk=True)
"""群聊id"""
group_name = fields.TextField(default="")
"""群聊名称"""
max_member_count = fields.IntField(default=0)
"""最大人数"""
member_count = fields.IntField(default=0)
"""当前人数"""
group_flag: int = fields.IntField(default=0)
"""群认证标记"""
class Meta:
table = "group_info"
table_description = "群聊信息表"
def _run_script(cls):
return ["ALTER TABLE group_info ADD group_flag Integer NOT NULL DEFAULT 0;", # group_info表添加一个group_flag
"ALTER TABLE group_info ALTER COLUMN group_id TYPE character varying(255);"
# 将group_id字段类型改为character varying(255)
]
class logger:
TEMPLATE_A = "{}"
TEMPLATE_B = "[<u><c>{}</c></u>]: {}"
TEMPLATE_C = "用户[<u><e>{}</e></u>] 触发 [<u><c>{}</c></u>]: {}"
TEMPLATE_D = "群聊[<u><e>{}</e></u>] 用户[<u><e>{}</e></u>] 触发 [<u><c>{}</c></u>]: {}"
TEMPLATE_E = "群聊[<u><e>{}</e></u>] 用户[<u><e>{}</e></u>] 触发 [<u><c>{}</c></u>] [Target](<u><e>{}</e></u>): {}"
TEMPLATE_USER = "用户[<u><e>{}</e></u>] "
TEMPLATE_GROUP = "群聊[<u><e>{}</e></u>] "
TEMPLATE_COMMAND = "CMD[<u><c>{}</c></u>] "
TEMPLATE_TARGET = "[Target]([<u><e>{}</e></u>]) "
SUCCESS_TEMPLATE = "[<u><c>{}</c></u>]: {} | 参数[{}] 返回: [<y>{}</y>]"
WARNING_TEMPLATE = "[<u><y>{}</y></u>]: {}"
ERROR_TEMPLATE = "[<u><r>{}</r></u>]: {}"
def info(
cls,
info: str,
command: Optional[str] = None,
user_id: Optional[Union[int, str]] = None,
group_id: Optional[Union[int, str]] = None,
target: Optional[Any] = None,
):
template = cls.__parser_template(info, command, user_id, group_id, target)
logger_.opt(colors=True).info(template)
def success(
cls,
info: str,
command: str,
param: Optional[Dict[str, Any]] = None,
result: Optional[str] = "",
):
param_str = ""
if param:
param_str = ",".join([f"<m>{k}</m>:<g>{v}</g>" for k, v in param.items()])
logger_.opt(colors=True).success(
cls.SUCCESS_TEMPLATE.format(command, info, param_str, result)
)
def warning(
cls,
info: str,
command: Optional[str] = None,
user_id: Optional[Union[int, str]] = None,
group_id: Optional[Union[int, str]] = None,
target: Optional[Any] = None,
e: Optional[Exception] = None,
):
template = cls.__parser_template(info, command, user_id, group_id, target)
if e:
template += f" || 错误<r>{type(e)}: {e}</r>"
logger_.opt(colors=True).warning(template)
def error(
cls,
info: str,
command: Optional[str] = None,
user_id: Optional[Union[int, str]] = None,
group_id: Optional[Union[int, str]] = None,
target: Optional[Any] = None,
e: Optional[Exception] = None,
):
template = cls.__parser_template(info, command, user_id, group_id, target)
if e:
template += f" || 错误 <r>{type(e)}: {e}</r>"
logger_.opt(colors=True).error(template)
def debug(
cls,
info: str,
command: Optional[str] = None,
user_id: Optional[Union[int, str]] = None,
group_id: Optional[Union[int, str]] = None,
target: Optional[Any] = None,
e: Optional[Exception] = None,
):
template = cls.__parser_template(info, command, user_id, group_id, target)
if e:
template += f" || 错误 <r>{type(e)}: {e}</r>"
logger_.opt(colors=True).debug(template)
def __parser_template(
cls,
info: str,
command: Optional[str] = None,
user_id: Optional[Union[int, str]] = None,
group_id: Optional[Union[int, str]] = None,
target: Optional[Any] = None,
) -> str:
arg_list = []
template = ""
if group_id is not None:
template += cls.TEMPLATE_GROUP
arg_list.append(group_id)
if user_id is not None:
template += cls.TEMPLATE_USER
arg_list.append(user_id)
if command is not None:
template += cls.TEMPLATE_COMMAND
arg_list.append(command)
if target is not None:
template += cls.TEMPLATE_TARGET
arg_list.append(target)
arg_list.append(info)
template += "{}"
return template.format(*arg_list)
{
"run_sql": [], # 需要启动前运行的sql语句
"_shop_before_handle": {}, # 商品使用前函数
"_shop_after_handle": {}, # 商品使用后函数
}
def is_number(s: Union[int, str]) -> bool:
"""
说明:
检测 s 是否为数字
参数:
:param s: 文本
"""
if isinstance(s, int):
return True
try:
float(s)
return True
except ValueError:
pass
try:
import unicodedata
unicodedata.numeric(s)
return True
except (TypeError, ValueError):
pass
return False
async def _(bot: Bot, event: MessageEvent, arg: Message = CommandArg()):
group_id = arg.extract_plain_text().strip()
if not group_id and isinstance(event, GroupMessageEvent):
group_id = event.group_id
if group_id:
if is_number(group_id):
group_list = [x["group_id"] for x in await bot.get_group_list()]
group_id = int(group_id)
if group_id not in group_list:
logger.debug("群聊不存在", "退群", event.user_id, target=group_id)
await del_group.finish(f"{NICKNAME}未在该群聊中...")
try:
await bot.set_group_leave(group_id=group_id)
logger.info(f"{NICKNAME}退出群聊成功", "退群", event.user_id, target=group_id)
await del_group.send(f"退出群聊 {group_id} 成功", at_sender=True)
group_manager.delete_group(group_id)
await GroupInfo.filter(group_id=group_id).delete()
except Exception as e:
logger.error(f"退出群聊失败", "退群", event.user_id, target=group_id, e=e)
await del_group.send(f"退出群聊 {group_id} 失败", at_sender=True)
else:
await del_group.send(f"请输入正确的群号", at_sender=True)
else:
await del_group.send(f"请输入群号", at_sender=True) | null |
188,106 | from typing import Tuple
from nonebot import on_command, on_regex
from nonebot.adapters.onebot.v11 import (
GROUP,
Bot,
GroupMessageEvent,
Message,
MessageEvent,
)
from nonebot.params import Command, CommandArg
from nonebot.permission import SUPERUSER
from nonebot.rule import to_me
from configs.config import NICKNAME
from models.group_info import GroupInfo
from services.log import logger
from utils.depends import OneCommand
from utils.image_utils import text2image
from utils.manager import group_manager, plugins2settings_manager
from utils.message_builder import image
from utils.utils import is_number
d_group_level = on_command("修改群权限", priority=1, permission=SUPERUSER, block=True)
class logger:
TEMPLATE_A = "{}"
TEMPLATE_B = "[<u><c>{}</c></u>]: {}"
TEMPLATE_C = "用户[<u><e>{}</e></u>] 触发 [<u><c>{}</c></u>]: {}"
TEMPLATE_D = "群聊[<u><e>{}</e></u>] 用户[<u><e>{}</e></u>] 触发 [<u><c>{}</c></u>]: {}"
TEMPLATE_E = "群聊[<u><e>{}</e></u>] 用户[<u><e>{}</e></u>] 触发 [<u><c>{}</c></u>] [Target](<u><e>{}</e></u>): {}"
TEMPLATE_USER = "用户[<u><e>{}</e></u>] "
TEMPLATE_GROUP = "群聊[<u><e>{}</e></u>] "
TEMPLATE_COMMAND = "CMD[<u><c>{}</c></u>] "
TEMPLATE_TARGET = "[Target]([<u><e>{}</e></u>]) "
SUCCESS_TEMPLATE = "[<u><c>{}</c></u>]: {} | 参数[{}] 返回: [<y>{}</y>]"
WARNING_TEMPLATE = "[<u><y>{}</y></u>]: {}"
ERROR_TEMPLATE = "[<u><r>{}</r></u>]: {}"
def info(
cls,
info: str,
command: Optional[str] = None,
user_id: Optional[Union[int, str]] = None,
group_id: Optional[Union[int, str]] = None,
target: Optional[Any] = None,
):
template = cls.__parser_template(info, command, user_id, group_id, target)
logger_.opt(colors=True).info(template)
def success(
cls,
info: str,
command: str,
param: Optional[Dict[str, Any]] = None,
result: Optional[str] = "",
):
param_str = ""
if param:
param_str = ",".join([f"<m>{k}</m>:<g>{v}</g>" for k, v in param.items()])
logger_.opt(colors=True).success(
cls.SUCCESS_TEMPLATE.format(command, info, param_str, result)
)
def warning(
cls,
info: str,
command: Optional[str] = None,
user_id: Optional[Union[int, str]] = None,
group_id: Optional[Union[int, str]] = None,
target: Optional[Any] = None,
e: Optional[Exception] = None,
):
template = cls.__parser_template(info, command, user_id, group_id, target)
if e:
template += f" || 错误<r>{type(e)}: {e}</r>"
logger_.opt(colors=True).warning(template)
def error(
cls,
info: str,
command: Optional[str] = None,
user_id: Optional[Union[int, str]] = None,
group_id: Optional[Union[int, str]] = None,
target: Optional[Any] = None,
e: Optional[Exception] = None,
):
template = cls.__parser_template(info, command, user_id, group_id, target)
if e:
template += f" || 错误 <r>{type(e)}: {e}</r>"
logger_.opt(colors=True).error(template)
def debug(
cls,
info: str,
command: Optional[str] = None,
user_id: Optional[Union[int, str]] = None,
group_id: Optional[Union[int, str]] = None,
target: Optional[Any] = None,
e: Optional[Exception] = None,
):
template = cls.__parser_template(info, command, user_id, group_id, target)
if e:
template += f" || 错误 <r>{type(e)}: {e}</r>"
logger_.opt(colors=True).debug(template)
def __parser_template(
cls,
info: str,
command: Optional[str] = None,
user_id: Optional[Union[int, str]] = None,
group_id: Optional[Union[int, str]] = None,
target: Optional[Any] = None,
) -> str:
arg_list = []
template = ""
if group_id is not None:
template += cls.TEMPLATE_GROUP
arg_list.append(group_id)
if user_id is not None:
template += cls.TEMPLATE_USER
arg_list.append(user_id)
if command is not None:
template += cls.TEMPLATE_COMMAND
arg_list.append(command)
if target is not None:
template += cls.TEMPLATE_TARGET
arg_list.append(target)
arg_list.append(info)
template += "{}"
return template.format(*arg_list)
{
"run_sql": [], # 需要启动前运行的sql语句
"_shop_before_handle": {}, # 商品使用前函数
"_shop_after_handle": {}, # 商品使用后函数
}
def is_number(s: Union[int, str]) -> bool:
"""
说明:
检测 s 是否为数字
参数:
:param s: 文本
"""
if isinstance(s, int):
return True
try:
float(s)
return True
except ValueError:
pass
try:
import unicodedata
unicodedata.numeric(s)
return True
except (TypeError, ValueError):
pass
return False
async def _(bot: Bot, event: MessageEvent, arg: Message = CommandArg()):
msg = arg.extract_plain_text().strip()
msg = msg.split()
group_id = 0
level = 0
if isinstance(event, GroupMessageEvent) and len(msg) == 1:
msg = [event.group_id, msg[0]]
if not msg:
await add_group_level.finish("缺失参数...")
if len(msg) < 2:
await add_group_level.finish("缺失参数...")
if is_number(msg[0]) and is_number(msg[1]):
group_id = str(msg[0])
level = int(msg[1])
else:
await add_group_level.finish("参数错误...群号和等级必须是数字..")
old_level = group_manager.get_group_level(group_id)
group_manager.set_group_level(group_id, level)
await add_group_level.send("修改成功...", at_sender=True)
if level > -1:
await bot.send_group_msg(
group_id=int(group_id), message=f"管理员修改了此群权限：{old_level} -> {level}"
)
logger.info(f"修改群权限：{level}", "修改群权限", event.user_id, target=group_id) | null |
188,107 | from typing import Tuple
from nonebot import on_command, on_regex
from nonebot.adapters.onebot.v11 import (
GROUP,
Bot,
GroupMessageEvent,
Message,
MessageEvent,
)
from nonebot.params import Command, CommandArg
from nonebot.permission import SUPERUSER
from nonebot.rule import to_me
from configs.config import NICKNAME
from models.group_info import GroupInfo
from services.log import logger
from utils.depends import OneCommand
from utils.image_utils import text2image
from utils.manager import group_manager, plugins2settings_manager
from utils.message_builder import image
from utils.utils import is_number
level = on_command(
"查看群权限", aliases={"群权限"}, priority=5, permission=GROUP, block=True
)
async def text2image(
text: str,
auto_parse: bool = True,
font_size: int = 20,
color: Union[str, Tuple[int, int, int], Tuple[int, int, int, int]] = "white",
font: str = "CJGaoDeGuo.otf",
font_color: Union[str, Tuple[int, int, int]] = "black",
padding: Union[int, Tuple[int, int, int, int]] = 0,
_add_height: float = 0,
) -> BuildImage:
def image(
file: Optional[Union[str, Path, bytes, BuildImage, io.BytesIO, BuildMat]] = None,
b64: Optional[str] = None,
) -> MessageSegment:
async def _(event: GroupMessageEvent):
level = group_manager.get_group_level(event.group_id)
tmp = ""
data = plugins2settings_manager.get_data()
for module in data:
if data[module].level > level:
plugin_name = data[module].cmd[0]
if plugin_name == "pixiv":
plugin_name = "搜图 p站排行"
tmp += f"{plugin_name}\n"
if not tmp:
await my_group_level.finish(f"当前群权限：{level}")
await my_group_level.finish(
f"当前群权限：{level}\n目前无法使用的功能:\n"
+ image(await text2image(tmp, padding=10, color="#f9f6f2"))
) | null |
188,108 | from typing import Tuple
from nonebot import on_command, on_regex
from nonebot.adapters.onebot.v11 import (
GROUP,
Bot,
GroupMessageEvent,
Message,
MessageEvent,
)
from nonebot.params import Command, CommandArg
from nonebot.permission import SUPERUSER
from nonebot.rule import to_me
from configs.config import NICKNAME
from models.group_info import GroupInfo
from services.log import logger
from utils.depends import OneCommand
from utils.image_utils import text2image
from utils.manager import group_manager, plugins2settings_manager
from utils.message_builder import image
from utils.utils import is_number
what_up_group_level = on_regex(
"(:?提高|提升|升高|增加|加上).*?群权限",
rule=to_me(),
priority=5,
permission=GROUP,
block=True,
)
async def _():
await what_up_group_level.finish(
f"[此功能用于防止内鬼，如果引起不便那真是抱歉了]\n" f"目前提高群权限的方法：\n" f"\t1.超级管理员修改权限"
) | null |
188,109 | from typing import Tuple
from nonebot import on_command, on_regex
from nonebot.adapters.onebot.v11 import (
GROUP,
Bot,
GroupMessageEvent,
Message,
MessageEvent,
)
from nonebot.params import Command, CommandArg
from nonebot.permission import SUPERUSER
from nonebot.rule import to_me
from configs.config import NICKNAME
from models.group_info import GroupInfo
from services.log import logger
from utils.depends import OneCommand
from utils.image_utils import text2image
from utils.manager import group_manager, plugins2settings_manager
from utils.message_builder import image
from utils.utils import is_number
manager_group_whitelist = on_command(
"添加群白名单", aliases={"删除群白名单"}, priority=1, permission=SUPERUSER, block=True
)
class logger:
TEMPLATE_A = "{}"
TEMPLATE_B = "[<u><c>{}</c></u>]: {}"
TEMPLATE_C = "用户[<u><e>{}</e></u>] 触发 [<u><c>{}</c></u>]: {}"
TEMPLATE_D = "群聊[<u><e>{}</e></u>] 用户[<u><e>{}</e></u>] 触发 [<u><c>{}</c></u>]: {}"
TEMPLATE_E = "群聊[<u><e>{}</e></u>] 用户[<u><e>{}</e></u>] 触发 [<u><c>{}</c></u>] [Target](<u><e>{}</e></u>): {}"
TEMPLATE_USER = "用户[<u><e>{}</e></u>] "
TEMPLATE_GROUP = "群聊[<u><e>{}</e></u>] "
TEMPLATE_COMMAND = "CMD[<u><c>{}</c></u>] "
TEMPLATE_TARGET = "[Target]([<u><e>{}</e></u>]) "
SUCCESS_TEMPLATE = "[<u><c>{}</c></u>]: {} | 参数[{}] 返回: [<y>{}</y>]"
WARNING_TEMPLATE = "[<u><y>{}</y></u>]: {}"
ERROR_TEMPLATE = "[<u><r>{}</r></u>]: {}"
def info(
cls,
info: str,
command: Optional[str] = None,
user_id: Optional[Union[int, str]] = None,
group_id: Optional[Union[int, str]] = None,
target: Optional[Any] = None,
):
template = cls.__parser_template(info, command, user_id, group_id, target)
logger_.opt(colors=True).info(template)
def success(
cls,
info: str,
command: str,
param: Optional[Dict[str, Any]] = None,
result: Optional[str] = "",
):
param_str = ""
if param:
param_str = ",".join([f"<m>{k}</m>:<g>{v}</g>" for k, v in param.items()])
logger_.opt(colors=True).success(
cls.SUCCESS_TEMPLATE.format(command, info, param_str, result)
)
def warning(
cls,
info: str,
command: Optional[str] = None,
user_id: Optional[Union[int, str]] = None,
group_id: Optional[Union[int, str]] = None,
target: Optional[Any] = None,
e: Optional[Exception] = None,
):
template = cls.__parser_template(info, command, user_id, group_id, target)
if e:
template += f" || 错误<r>{type(e)}: {e}</r>"
logger_.opt(colors=True).warning(template)
def error(
cls,
info: str,
command: Optional[str] = None,
user_id: Optional[Union[int, str]] = None,
group_id: Optional[Union[int, str]] = None,
target: Optional[Any] = None,
e: Optional[Exception] = None,
):
template = cls.__parser_template(info, command, user_id, group_id, target)
if e:
template += f" || 错误 <r>{type(e)}: {e}</r>"
logger_.opt(colors=True).error(template)
def debug(
cls,
info: str,
command: Optional[str] = None,
user_id: Optional[Union[int, str]] = None,
group_id: Optional[Union[int, str]] = None,
target: Optional[Any] = None,
e: Optional[Exception] = None,
):
template = cls.__parser_template(info, command, user_id, group_id, target)
if e:
template += f" || 错误 <r>{type(e)}: {e}</r>"
logger_.opt(colors=True).debug(template)
def __parser_template(
cls,
info: str,
command: Optional[str] = None,
user_id: Optional[Union[int, str]] = None,
group_id: Optional[Union[int, str]] = None,
target: Optional[Any] = None,
) -> str:
arg_list = []
template = ""
if group_id is not None:
template += cls.TEMPLATE_GROUP
arg_list.append(group_id)
if user_id is not None:
template += cls.TEMPLATE_USER
arg_list.append(user_id)
if command is not None:
template += cls.TEMPLATE_COMMAND
arg_list.append(command)
if target is not None:
template += cls.TEMPLATE_TARGET
arg_list.append(target)
arg_list.append(info)
template += "{}"
return template.format(*arg_list)
def OneCommand():
"""
获取单个命令Command
"""
async def dependency(
cmd: Tuple[str, ...] = Command(),
):
return cmd[0] if cmd else None
return Depends(dependency)
{
"run_sql": [], # 需要启动前运行的sql语句
"_shop_before_handle": {}, # 商品使用前函数
"_shop_after_handle": {}, # 商品使用后函数
}
def is_number(s: Union[int, str]) -> bool:
"""
说明:
检测 s 是否为数字
参数:
:param s: 文本
"""
if isinstance(s, int):
return True
try:
float(s)
return True
except ValueError:
pass
try:
import unicodedata
unicodedata.numeric(s)
return True
except (TypeError, ValueError):
pass
return False
async def _(
bot: Bot, event: MessageEvent, cmd: str = OneCommand(), arg: Message = CommandArg()
):
msg = arg.extract_plain_text().strip().split()
if not msg and isinstance(event, GroupMessageEvent):
msg = [event.group_id]
if not msg:
await manager_group_whitelist.finish("请输入群号")
all_group = [g["group_id"] for g in await bot.get_group_list()]
error_group = []
group_list = []
for group_id in msg:
if is_number(group_id) and int(group_id) in all_group:
group_list.append(int(group_id))
else:
logger.debug(f"群号不合法或不存在", cmd, target=group_id)
error_group.append(group_id)
if group_list:
for group_id in group_list:
if cmd in ["添加群白名单"]:
group_manager.add_group_white_list(group_id)
else:
group_manager.delete_group_white_list(group_id)
group_list = [str(x) for x in group_list]
await manager_group_whitelist.send("已成功将 " + "\n".join(group_list) + " " + cmd)
group_manager.save()
if error_group:
await manager_group_whitelist.send("以下群聊不合法或不存在:\n" + "\n".join(error_group)) | null |
188,110 | from typing import Tuple
from nonebot import on_command, on_regex
from nonebot.adapters.onebot.v11 import (
GROUP,
Bot,
GroupMessageEvent,
Message,
MessageEvent,
)
from nonebot.params import Command, CommandArg
from nonebot.permission import SUPERUSER
from nonebot.rule import to_me
from configs.config import NICKNAME
from models.group_info import GroupInfo
from services.log import logger
from utils.depends import OneCommand
from utils.image_utils import text2image
from utils.manager import group_manager, plugins2settings_manager
from utils.message_builder import image
from utils.utils import is_number
show_group_whitelist = on_command(
"查看群白名单", priority=1, permission=SUPERUSER, block=True
)
async def _():
group = [str(g) for g in group_manager.get_group_white_list()]
if not group:
await show_group_whitelist.finish("没有任何群在群白名单...")
await show_group_whitelist.send("目前的群白名单:\n" + "\n".join(group)) | null |
188,111 | from typing import Tuple
from nonebot import on_command, on_regex
from nonebot.adapters.onebot.v11 import (
GROUP,
Bot,
GroupMessageEvent,
Message,
MessageEvent,
)
from nonebot.params import Command, CommandArg
from nonebot.permission import SUPERUSER
from nonebot.rule import to_me
from configs.config import NICKNAME
from models.group_info import GroupInfo
from services.log import logger
from utils.depends import OneCommand
from utils.image_utils import text2image
from utils.manager import group_manager, plugins2settings_manager
from utils.message_builder import image
from utils.utils import is_number
manager_group_whitelist = on_command(
"添加群白名单", aliases={"删除群白名单"}, priority=1, permission=SUPERUSER, block=True
)
group_auth = on_command(
"添加群认证", aliases={"删除群认证"}, priority=1, permission=SUPERUSER, block=True
)
class GroupInfo(Model):
group_id = fields.CharField(255, pk=True)
"""群聊id"""
group_name = fields.TextField(default="")
"""群聊名称"""
max_member_count = fields.IntField(default=0)
"""最大人数"""
member_count = fields.IntField(default=0)
"""当前人数"""
group_flag: int = fields.IntField(default=0)
"""群认证标记"""
class Meta:
table = "group_info"
table_description = "群聊信息表"
def _run_script(cls):
return ["ALTER TABLE group_info ADD group_flag Integer NOT NULL DEFAULT 0;", # group_info表添加一个group_flag
"ALTER TABLE group_info ALTER COLUMN group_id TYPE character varying(255);"
# 将group_id字段类型改为character varying(255)
]
class logger:
TEMPLATE_A = "{}"
TEMPLATE_B = "[<u><c>{}</c></u>]: {}"
TEMPLATE_C = "用户[<u><e>{}</e></u>] 触发 [<u><c>{}</c></u>]: {}"
TEMPLATE_D = "群聊[<u><e>{}</e></u>] 用户[<u><e>{}</e></u>] 触发 [<u><c>{}</c></u>]: {}"
TEMPLATE_E = "群聊[<u><e>{}</e></u>] 用户[<u><e>{}</e></u>] 触发 [<u><c>{}</c></u>] [Target](<u><e>{}</e></u>): {}"
TEMPLATE_USER = "用户[<u><e>{}</e></u>] "
TEMPLATE_GROUP = "群聊[<u><e>{}</e></u>] "
TEMPLATE_COMMAND = "CMD[<u><c>{}</c></u>] "
TEMPLATE_TARGET = "[Target]([<u><e>{}</e></u>]) "
SUCCESS_TEMPLATE = "[<u><c>{}</c></u>]: {} | 参数[{}] 返回: [<y>{}</y>]"
WARNING_TEMPLATE = "[<u><y>{}</y></u>]: {}"
ERROR_TEMPLATE = "[<u><r>{}</r></u>]: {}"
def info(
cls,
info: str,
command: Optional[str] = None,
user_id: Optional[Union[int, str]] = None,
group_id: Optional[Union[int, str]] = None,
target: Optional[Any] = None,
):
template = cls.__parser_template(info, command, user_id, group_id, target)
logger_.opt(colors=True).info(template)
def success(
cls,
info: str,
command: str,
param: Optional[Dict[str, Any]] = None,
result: Optional[str] = "",
):
param_str = ""
if param:
param_str = ",".join([f"<m>{k}</m>:<g>{v}</g>" for k, v in param.items()])
logger_.opt(colors=True).success(
cls.SUCCESS_TEMPLATE.format(command, info, param_str, result)
)
def warning(
cls,
info: str,
command: Optional[str] = None,
user_id: Optional[Union[int, str]] = None,
group_id: Optional[Union[int, str]] = None,
target: Optional[Any] = None,
e: Optional[Exception] = None,
):
template = cls.__parser_template(info, command, user_id, group_id, target)
if e:
template += f" || 错误<r>{type(e)}: {e}</r>"
logger_.opt(colors=True).warning(template)
def error(
cls,
info: str,
command: Optional[str] = None,
user_id: Optional[Union[int, str]] = None,
group_id: Optional[Union[int, str]] = None,
target: Optional[Any] = None,
e: Optional[Exception] = None,
):
template = cls.__parser_template(info, command, user_id, group_id, target)
if e:
template += f" || 错误 <r>{type(e)}: {e}</r>"
logger_.opt(colors=True).error(template)
def debug(
cls,
info: str,
command: Optional[str] = None,
user_id: Optional[Union[int, str]] = None,
group_id: Optional[Union[int, str]] = None,
target: Optional[Any] = None,
e: Optional[Exception] = None,
):
template = cls.__parser_template(info, command, user_id, group_id, target)
if e:
template += f" || 错误 <r>{type(e)}: {e}</r>"
logger_.opt(colors=True).debug(template)
def __parser_template(
cls,
info: str,
command: Optional[str] = None,
user_id: Optional[Union[int, str]] = None,
group_id: Optional[Union[int, str]] = None,
target: Optional[Any] = None,
) -> str:
arg_list = []
template = ""
if group_id is not None:
template += cls.TEMPLATE_GROUP
arg_list.append(group_id)
if user_id is not None:
template += cls.TEMPLATE_USER
arg_list.append(user_id)
if command is not None:
template += cls.TEMPLATE_COMMAND
arg_list.append(command)
if target is not None:
template += cls.TEMPLATE_TARGET
arg_list.append(target)
arg_list.append(info)
template += "{}"
return template.format(*arg_list)
def OneCommand():
"""
获取单个命令Command
"""
async def dependency(
cmd: Tuple[str, ...] = Command(),
):
return cmd[0] if cmd else None
return Depends(dependency)
async def _(
bot: Bot, event: MessageEvent, cmd: str = OneCommand(), arg: Message = CommandArg()
):
msg = arg.extract_plain_text().strip().split()
if isinstance(event, GroupMessageEvent) and not msg:
msg = [event.group_id]
if not msg:
await manager_group_whitelist.finish("请输入群号")
error_group = []
for group_id in msg:
group_id = int(group_id)
if cmd[:2] == "添加":
try:
await GroupInfo.update_or_create(
group_id=group_id,
defaults={
"group_flag": 1,
},
)
except Exception as e:
await group_auth.send(f"添加群认证 {group_id} 发生错误！")
logger.error(f"添加群认证发生错误", cmd, target=group_id, e=e)
else:
await group_auth.send(f"已为 {group_id} {cmd[:2]}群认证..")
logger.info(f"添加群认证成功", cmd, target=group_id)
else:
if group := await GroupInfo.filter(group_id=group_id).first():
await group.update_or_create(
group_id=group_id, defaults={"group_flag": 0}
)
await group_auth.send(f"已删除 {group_id} 群认证..")
logger.info(f"删除群认证成功", cmd, target=group_id)
else:
await group_auth.send(f"未查找到群聊: {group_id}")
logger.info(f"未找到群聊", cmd, target=group_id)
if error_group:
await manager_group_whitelist.send("以下群聊不合法或不存在:\n" + "\n".join(error_group)) | null |
188,112 | from typing import List
from nonebot import on_command
from nonebot.adapters.onebot.v11 import GroupMessageEvent, Message
from nonebot.adapters.onebot.v11.permission import GROUP
from nonebot.params import CommandArg
from configs.config import Config
from services.log import logger
from utils.depends import ImageList, OneCommand
from ._data_source import custom_group_welcome
= """
usage：
指令：
自定义进群欢迎消息 ?[文本] ?[图片]
Note：可以通过[at]来确认是否艾特新成员
示例：自定义进群欢迎消息 欢迎新人！[图片]
示例：自定义进群欢迎消息 欢迎你[at]
""".strip()
custom_welcome = on_command(
"自定义进群欢迎消息",
aliases={"自定义欢迎消息", "自定义群欢迎消息", "设置群欢迎消息"},
permission=GROUP,
priority=5,
block=True,
)
class logger:
TEMPLATE_A = "{}"
TEMPLATE_B = "[<u><c>{}</c></u>]: {}"
TEMPLATE_C = "用户[<u><e>{}</e></u>] 触发 [<u><c>{}</c></u>]: {}"
TEMPLATE_D = "群聊[<u><e>{}</e></u>] 用户[<u><e>{}</e></u>] 触发 [<u><c>{}</c></u>]: {}"
TEMPLATE_E = "群聊[<u><e>{}</e></u>] 用户[<u><e>{}</e></u>] 触发 [<u><c>{}</c></u>] [Target](<u><e>{}</e></u>): {}"
TEMPLATE_USER = "用户[<u><e>{}</e></u>] "
TEMPLATE_GROUP = "群聊[<u><e>{}</e></u>] "
TEMPLATE_COMMAND = "CMD[<u><c>{}</c></u>] "
TEMPLATE_TARGET = "[Target]([<u><e>{}</e></u>]) "
SUCCESS_TEMPLATE = "[<u><c>{}</c></u>]: {} | 参数[{}] 返回: [<y>{}</y>]"
WARNING_TEMPLATE = "[<u><y>{}</y></u>]: {}"
ERROR_TEMPLATE = "[<u><r>{}</r></u>]: {}"
def info(
cls,
info: str,
command: Optional[str] = None,
user_id: Optional[Union[int, str]] = None,
group_id: Optional[Union[int, str]] = None,
target: Optional[Any] = None,
):
template = cls.__parser_template(info, command, user_id, group_id, target)
logger_.opt(colors=True).info(template)
def success(
cls,
info: str,
command: str,
param: Optional[Dict[str, Any]] = None,
result: Optional[str] = "",
):
param_str = ""
if param:
param_str = ",".join([f"<m>{k}</m>:<g>{v}</g>" for k, v in param.items()])
logger_.opt(colors=True).success(
cls.SUCCESS_TEMPLATE.format(command, info, param_str, result)
)
def warning(
cls,
info: str,
command: Optional[str] = None,
user_id: Optional[Union[int, str]] = None,
group_id: Optional[Union[int, str]] = None,
target: Optional[Any] = None,
e: Optional[Exception] = None,
):
template = cls.__parser_template(info, command, user_id, group_id, target)
if e:
template += f" || 错误<r>{type(e)}: {e}</r>"
logger_.opt(colors=True).warning(template)
def error(
cls,
info: str,
command: Optional[str] = None,
user_id: Optional[Union[int, str]] = None,
group_id: Optional[Union[int, str]] = None,
target: Optional[Any] = None,
e: Optional[Exception] = None,
):
template = cls.__parser_template(info, command, user_id, group_id, target)
if e:
template += f" || 错误 <r>{type(e)}: {e}</r>"
logger_.opt(colors=True).error(template)
def debug(
cls,
info: str,
command: Optional[str] = None,
user_id: Optional[Union[int, str]] = None,
group_id: Optional[Union[int, str]] = None,
target: Optional[Any] = None,
e: Optional[Exception] = None,
):
template = cls.__parser_template(info, command, user_id, group_id, target)
if e:
template += f" || 错误 <r>{type(e)}: {e}</r>"
logger_.opt(colors=True).debug(template)
def __parser_template(
cls,
info: str,
command: Optional[str] = None,
user_id: Optional[Union[int, str]] = None,
group_id: Optional[Union[int, str]] = None,
target: Optional[Any] = None,
) -> str:
arg_list = []
template = ""
if group_id is not None:
template += cls.TEMPLATE_GROUP
arg_list.append(group_id)
if user_id is not None:
template += cls.TEMPLATE_USER
arg_list.append(user_id)
if command is not None:
template += cls.TEMPLATE_COMMAND
arg_list.append(command)
if target is not None:
template += cls.TEMPLATE_TARGET
arg_list.append(target)
arg_list.append(info)
template += "{}"
return template.format(*arg_list)
def OneCommand():
"""
获取单个命令Command
"""
async def dependency(
cmd: Tuple[str, ...] = Command(),
):
return cmd[0] if cmd else None
return Depends(dependency)
def ImageList(msg: Optional[str] = None, contain_reply: bool = True) -> List[str]:
"""
说明:
获取图片列表（包括回复时），含有msg时不能为空，为空时提示并结束事件
参数:
:param msg: 提示文本
:param contain_reply: 包含回复内容
"""
async def dependency(matcher: Matcher, event: MessageEvent):
return await _match(matcher, event, msg, get_message_img, contain_reply)
return Depends(dependency)
async def custom_group_welcome(
msg: str, img_list: List[str], user_id: str, group_id: str
) -> Union[str, Message]:
"""
说明:
替换群欢迎消息
参数:
:param msg: 欢迎消息文本
:param img_list: 欢迎消息图片
:param user_id: 用户id，用于log记录
:param group_id: 群号
"""
img_result = ""
result = ""
img = img_list[0] if img_list else ""
msg_image = DATA_PATH / "custom_welcome_msg" / f"{group_id}.jpg"
if msg_image.exists():
msg_image.unlink()
data = {}
if CUSTOM_WELCOME_FILE.exists():
data = json.load(CUSTOM_WELCOME_FILE.open("r", encoding="utf8"))
try:
if msg:
data[group_id] = msg
json.dump(
data,
CUSTOM_WELCOME_FILE.open("w", encoding="utf8"),
indent=4,
ensure_ascii=False,
)
logger.info(f"更换群欢迎消息 {msg}", "更换群欢迎信息", user_id, group_id)
result += msg
if img:
await AsyncHttpx.download_file(img, msg_image)
img_result = image(msg_image)
logger.info(f"更换群欢迎消息图片", "更换群欢迎信息", user_id, group_id)
except Exception as e:
logger.error(f"替换群消息失败", "更换群欢迎信息", user_id, group_id, e=e)
return "替换群消息失败..."
return f"替换群欢迎消息成功：\n{result}" + img_result
async def _(
event: GroupMessageEvent,
cmd: str = OneCommand(),
arg: Message = CommandArg(),
img: List[str] = ImageList(),
):
msg = arg.extract_plain_text().strip()
if not msg and not img:
await custom_welcome.finish(__plugin_usage__)
try:
await custom_welcome.send(
await custom_group_welcome(
msg, img, str(event.user_id), str(event.group_id)
),
at_sender=True,
)
logger.info(f"自定义群欢迎消息：{msg}", cmd, event.user_id, event.group_id)
except Exception as e:
logger.error(
f"自定义进群欢迎消息发生错误", cmd, event.user_id, getattr(event, "group_id", None), e=e
)
await custom_welcome.send("发生了一些未知错误...") | null |
188,113 | import time
from nonebot.adapters.onebot.v11 import Event
from services.log import logger
from utils.manager import group_manager, plugins2settings_manager
from utils.utils import get_message_text
cmd = []
v = time.time()
class logger:
TEMPLATE_A = "{}"
TEMPLATE_B = "[<u><c>{}</c></u>]: {}"
TEMPLATE_C = "用户[<u><e>{}</e></u>] 触发 [<u><c>{}</c></u>]: {}"
TEMPLATE_D = "群聊[<u><e>{}</e></u>] 用户[<u><e>{}</e></u>] 触发 [<u><c>{}</c></u>]: {}"
TEMPLATE_E = "群聊[<u><e>{}</e></u>] 用户[<u><e>{}</e></u>] 触发 [<u><c>{}</c></u>] [Target](<u><e>{}</e></u>): {}"
TEMPLATE_USER = "用户[<u><e>{}</e></u>] "
TEMPLATE_GROUP = "群聊[<u><e>{}</e></u>] "
TEMPLATE_COMMAND = "CMD[<u><c>{}</c></u>] "
TEMPLATE_TARGET = "[Target]([<u><e>{}</e></u>]) "
SUCCESS_TEMPLATE = "[<u><c>{}</c></u>]: {} | 参数[{}] 返回: [<y>{}</y>]"
WARNING_TEMPLATE = "[<u><y>{}</y></u>]: {}"
ERROR_TEMPLATE = "[<u><r>{}</r></u>]: {}"
def info(
cls,
info: str,
command: Optional[str] = None,
user_id: Optional[Union[int, str]] = None,
group_id: Optional[Union[int, str]] = None,
target: Optional[Any] = None,
):
template = cls.__parser_template(info, command, user_id, group_id, target)
logger_.opt(colors=True).info(template)
def success(
cls,
info: str,
command: str,
param: Optional[Dict[str, Any]] = None,
result: Optional[str] = "",
):
param_str = ""
if param:
param_str = ",".join([f"<m>{k}</m>:<g>{v}</g>" for k, v in param.items()])
logger_.opt(colors=True).success(
cls.SUCCESS_TEMPLATE.format(command, info, param_str, result)
)
def warning(
cls,
info: str,
command: Optional[str] = None,
user_id: Optional[Union[int, str]] = None,
group_id: Optional[Union[int, str]] = None,
target: Optional[Any] = None,
e: Optional[Exception] = None,
):
template = cls.__parser_template(info, command, user_id, group_id, target)
if e:
template += f" || 错误<r>{type(e)}: {e}</r>"
logger_.opt(colors=True).warning(template)
def error(
cls,
info: str,
command: Optional[str] = None,
user_id: Optional[Union[int, str]] = None,
group_id: Optional[Union[int, str]] = None,
target: Optional[Any] = None,
e: Optional[Exception] = None,
):
template = cls.__parser_template(info, command, user_id, group_id, target)
if e:
template += f" || 错误 <r>{type(e)}: {e}</r>"
logger_.opt(colors=True).error(template)
def debug(
cls,
info: str,
command: Optional[str] = None,
user_id: Optional[Union[int, str]] = None,
group_id: Optional[Union[int, str]] = None,
target: Optional[Any] = None,
e: Optional[Exception] = None,
):
template = cls.__parser_template(info, command, user_id, group_id, target)
if e:
template += f" || 错误 <r>{type(e)}: {e}</r>"
logger_.opt(colors=True).debug(template)
def __parser_template(
cls,
info: str,
command: Optional[str] = None,
user_id: Optional[Union[int, str]] = None,
group_id: Optional[Union[int, str]] = None,
target: Optional[Any] = None,
) -> str:
arg_list = []
template = ""
if group_id is not None:
template += cls.TEMPLATE_GROUP
arg_list.append(group_id)
if user_id is not None:
template += cls.TEMPLATE_USER
arg_list.append(user_id)
if command is not None:
template += cls.TEMPLATE_COMMAND
arg_list.append(command)
if target is not None:
template += cls.TEMPLATE_TARGET
arg_list.append(target)
arg_list.append(info)
template += "{}"
return template.format(*arg_list)
{
"run_sql": [], # 需要启动前运行的sql语句
"_shop_before_handle": {}, # 商品使用前函数
"_shop_after_handle": {}, # 商品使用后函数
}
def get_message_text(data: Union[str, Message]) -> str:
"""
说明:
获取消息中 纯文本 的信息
参数:
:param data: event.json()
"""
result = ""
if isinstance(data, str):
event = json.loads(data)
if data and (message := event.get("message")):
if isinstance(message, str):
return message.strip()
for msg in message:
if msg["type"] == "text":
result += msg["data"]["text"].strip() + " "
return result.strip()
else:
for seg in data["text"]:
result += seg.data["text"] + " "
return result.strip()
The provided code snippet includes necessary dependencies for implementing the `switch_rule` function. Write a Python function `def switch_rule(event: Event) -> bool` to solve the following problem:
说明: 检测文本是否是关闭功能命令 参数: :param event: pass
Here is the function:
def switch_rule(event: Event) -> bool:
"""
说明:
检测文本是否是关闭功能命令
参数:
:param event: pass
"""
global cmd, v
try:
if not cmd or time.time() - v > 60 * 60:
cmd = ["关闭全部被动", "开启全部被动", "开启全部功能", "关闭全部功能"]
_data = group_manager.get_task_data()
for key in _data:
cmd.append(f"开启{_data[key]}")
cmd.append(f"关闭{_data[key]}")
cmd.append(f"开启被动{_data[key]}")
cmd.append(f"关闭被动{_data[key]}")
cmd.append(f"开启 {_data[key]}")
cmd.append(f"关闭 {_data[key]}")
_data = plugins2settings_manager.get_data()
for key in _data.keys():
try:
if isinstance(_data[key].cmd, list):
for x in _data[key].cmd:
cmd.append(f"开启{x}")
cmd.append(f"关闭{x}")
cmd.append(f"开启 {x}")
cmd.append(f"关闭 {x}")
else:
cmd.append(f"开启{key}")
cmd.append(f"关闭{key}")
cmd.append(f"开启 {key}")
cmd.append(f"关闭 {key}")
except KeyError:
pass
v = time.time()
msg = get_message_text(event.json()).split()
msg = msg[0] if msg else ""
return msg in cmd
except Exception as e:
logger.error(f"检测是否为功能开关命令发生错误", e=e)
return False | 说明: 检测文本是否是关闭功能命令 参数: :param event: pass |
188,114 | from typing import Any, Tuple
from nonebot import on_command, on_message, on_regex
from nonebot.adapters.onebot.v11 import (
GROUP,
Bot,
GroupMessageEvent,
Message,
MessageEvent,
PrivateMessageEvent,
)
from nonebot.params import CommandArg, RegexGroup
from nonebot.permission import SUPERUSER
from configs.config import NICKNAME, Config
from services.log import logger
from utils.message_builder import image
from utils.utils import get_message_text, is_number
from ._data_source import (
change_global_task_status,
change_group_switch,
get_plugin_status,
group_current_status,
set_group_bot_status,
set_plugin_status,
)
from .rule import switch_rule
switch_rule_matcher = on_message(rule=switch_rule, priority=4, block=True)
class logger:
TEMPLATE_A = "{}"
TEMPLATE_B = "[<u><c>{}</c></u>]: {}"
TEMPLATE_C = "用户[<u><e>{}</e></u>] 触发 [<u><c>{}</c></u>]: {}"
TEMPLATE_D = "群聊[<u><e>{}</e></u>] 用户[<u><e>{}</e></u>] 触发 [<u><c>{}</c></u>]: {}"
TEMPLATE_E = "群聊[<u><e>{}</e></u>] 用户[<u><e>{}</e></u>] 触发 [<u><c>{}</c></u>] [Target](<u><e>{}</e></u>): {}"
TEMPLATE_USER = "用户[<u><e>{}</e></u>] "
TEMPLATE_GROUP = "群聊[<u><e>{}</e></u>] "
TEMPLATE_COMMAND = "CMD[<u><c>{}</c></u>] "
TEMPLATE_TARGET = "[Target]([<u><e>{}</e></u>]) "
SUCCESS_TEMPLATE = "[<u><c>{}</c></u>]: {} | 参数[{}] 返回: [<y>{}</y>]"
WARNING_TEMPLATE = "[<u><y>{}</y></u>]: {}"
ERROR_TEMPLATE = "[<u><r>{}</r></u>]: {}"
def info(
cls,
info: str,
command: Optional[str] = None,
user_id: Optional[Union[int, str]] = None,
group_id: Optional[Union[int, str]] = None,
target: Optional[Any] = None,
):
template = cls.__parser_template(info, command, user_id, group_id, target)
logger_.opt(colors=True).info(template)
def success(
cls,
info: str,
command: str,
param: Optional[Dict[str, Any]] = None,
result: Optional[str] = "",
):
param_str = ""
if param:
param_str = ",".join([f"<m>{k}</m>:<g>{v}</g>" for k, v in param.items()])
logger_.opt(colors=True).success(
cls.SUCCESS_TEMPLATE.format(command, info, param_str, result)
)
def warning(
cls,
info: str,
command: Optional[str] = None,
user_id: Optional[Union[int, str]] = None,
group_id: Optional[Union[int, str]] = None,
target: Optional[Any] = None,
e: Optional[Exception] = None,
):
template = cls.__parser_template(info, command, user_id, group_id, target)
if e:
template += f" || 错误<r>{type(e)}: {e}</r>"
logger_.opt(colors=True).warning(template)
def error(
cls,
info: str,
command: Optional[str] = None,
user_id: Optional[Union[int, str]] = None,
group_id: Optional[Union[int, str]] = None,
target: Optional[Any] = None,
e: Optional[Exception] = None,
):
template = cls.__parser_template(info, command, user_id, group_id, target)
if e:
template += f" || 错误 <r>{type(e)}: {e}</r>"
logger_.opt(colors=True).error(template)
def debug(
cls,
info: str,
command: Optional[str] = None,
user_id: Optional[Union[int, str]] = None,
group_id: Optional[Union[int, str]] = None,
target: Optional[Any] = None,
e: Optional[Exception] = None,
):
template = cls.__parser_template(info, command, user_id, group_id, target)
if e:
template += f" || 错误 <r>{type(e)}: {e}</r>"
logger_.opt(colors=True).debug(template)
def __parser_template(
cls,
info: str,
command: Optional[str] = None,
user_id: Optional[Union[int, str]] = None,
group_id: Optional[Union[int, str]] = None,
target: Optional[Any] = None,
) -> str:
arg_list = []
template = ""
if group_id is not None:
template += cls.TEMPLATE_GROUP
arg_list.append(group_id)
if user_id is not None:
template += cls.TEMPLATE_USER
arg_list.append(user_id)
if command is not None:
template += cls.TEMPLATE_COMMAND
arg_list.append(command)
if target is not None:
template += cls.TEMPLATE_TARGET
arg_list.append(target)
arg_list.append(info)
template += "{}"
return template.format(*arg_list)
{
"run_sql": [], # 需要启动前运行的sql语句
"_shop_before_handle": {}, # 商品使用前函数
"_shop_after_handle": {}, # 商品使用后函数
}
def is_number(s: Union[int, str]) -> bool:
"""
说明:
检测 s 是否为数字
参数:
:param s: 文本
"""
if isinstance(s, int):
return True
try:
float(s)
return True
except ValueError:
pass
try:
import unicodedata
unicodedata.numeric(s)
return True
except (TypeError, ValueError):
pass
return False
def get_message_text(data: Union[str, Message]) -> str:
"""
说明:
获取消息中 纯文本 的信息
参数:
:param data: event.json()
"""
result = ""
if isinstance(data, str):
event = json.loads(data)
if data and (message := event.get("message")):
if isinstance(message, str):
return message.strip()
for msg in message:
if msg["type"] == "text":
result += msg["data"]["text"].strip() + " "
return result.strip()
else:
for seg in data["text"]:
result += seg.data["text"] + " "
return result.strip()
def change_global_task_status(cmd: str) -> str:
"""
说明:
修改全局被动任务状态
参数:
:param cmd: 功能名称
"""
global task_data
if not task_data:
task_data = group_manager.get_task_data()
status = cmd[:2]
_cmd = cmd[4:]
if "全部被动" in cmd:
for task in task_data:
if status == "开启":
group_manager.open_global_task(task)
else:
group_manager.close_global_task(task)
group_manager.save()
return f"已 {status} 全局全部被动技能！"
else:
modules = [x for x in task_data if task_data[x].lower() == _cmd.lower()]
if not modules:
return "未查询到该被动任务"
if status == "开启":
group_manager.open_global_task(modules[0])
else:
group_manager.close_global_task(modules[0])
group_manager.save()
return f"已 {status} 全局{_cmd}"
async def change_group_switch(cmd: str, group_id: str, is_super: bool = False) -> str:
"""
说明:
修改群功能状态
参数:
:param cmd: 功能名称
:param group_id: 群号
:param is_super: 是否为超级用户，超级用户用于私聊开关功能状态
"""
global task_data
if not task_data:
task_data = group_manager.get_task_data()
help_path = GROUP_HELP_PATH / f"{group_id}.png"
status = cmd[:2]
cmd = cmd[2:]
type_ = "plugin"
modules = plugins2settings_manager.get_plugin_module(cmd, True)
if cmd == "全部被动":
for task in task_data:
if status == "开启":
if not group_manager.check_group_task_status(group_id, task):
group_manager.open_group_task(group_id, task)
else:
if group_manager.check_group_task_status(group_id, task):
group_manager.close_group_task(group_id, task)
if help_path.exists():
help_path.unlink()
return f"已 {status} 全部被动技能！"
if cmd == "全部功能":
for f in plugins2settings_manager.get_data():
if status == "开启":
group_manager.unblock_plugin(f, group_id, False)
else:
group_manager.block_plugin(f, group_id, False)
group_manager.save()
if help_path.exists():
help_path.unlink()
return f"已 {status} 全部功能！"
if cmd.lower() in [task_data[x].lower() for x in task_data.keys()]:
type_ = "task"
modules = [x for x in task_data.keys() if task_data[x].lower() == cmd.lower()]
for module in modules:
if is_super:
module = f"{module}:super"
if status == "开启":
if type_ == "task":
if group_manager.check_group_task_status(group_id, module):
return f"被动 {task_data[module]} 正处于开启状态！不要重复开启."
group_manager.open_group_task(group_id, module)
else:
if group_manager.get_plugin_status(module, group_id):
return f"功能 {cmd} 正处于开启状态！不要重复开启."
group_manager.unblock_plugin(module, group_id)
else:
if type_ == "task":
if not group_manager.check_group_task_status(group_id, module):
return f"被动 {task_data[module]} 正处于关闭状态！不要重复关闭."
group_manager.close_group_task(group_id, module)
else:
if not group_manager.get_plugin_status(module, group_id):
return f"功能 {cmd} 正处于关闭状态！不要重复关闭."
group_manager.block_plugin(module, group_id)
if help_path.exists():
help_path.unlink()
if is_super:
for file in os.listdir(GROUP_HELP_PATH):
file = GROUP_HELP_PATH / file
file.unlink()
else:
if help_path.exists():
help_path.unlink()
return f"{status} {cmd} 功能！"
def set_plugin_status(cmd: str, block_type: BLOCK_TYPE = "all"):
"""
说明:
设置插件功能状态（超级用户使用）
参数:
:param cmd: 功能名称
:param block_type: 限制类型, 'all': 全局, 'private': 私聊, 'group': 群聊
"""
if block_type not in ["all", "private", "group"]:
raise TypeError("block_type类型错误, 可选值: ['all', 'private', 'group']")
status = cmd[:2]
cmd = cmd[2:]
module = plugins2settings_manager.get_plugin_module(cmd)
if status == "开启":
plugins_manager.unblock_plugin(module)
else:
plugins_manager.block_plugin(module, block_type=block_type)
for file in os.listdir(GROUP_HELP_PATH):
file = GROUP_HELP_PATH / file
file.unlink()
async def _(
bot: Bot,
event: MessageEvent,
):
msg = get_message_text(event.message).strip()
msg_split = msg.split()
_cmd = msg_split[0]
if isinstance(event, GroupMessageEvent):
await switch_rule_matcher.send(await change_group_switch(_cmd, event.group_id))
logger.info(f"使用群功能管理命令 {_cmd}", "功能管理", event.user_id, event.group_id)
else:
if str(event.user_id) in bot.config.superusers:
block_type = " ".join(msg_split[1:])
block_type = block_type if block_type else "a"
if ("关闭被动" in _cmd or "开启被动" in _cmd) and isinstance(
event, PrivateMessageEvent
):
await switch_rule_matcher.send(change_global_task_status(_cmd))
elif is_number(block_type):
if not int(block_type) in [
g["group_id"] for g in await bot.get_group_list()
]:
await switch_rule_matcher.finish(f"{NICKNAME}未加入群聊：{block_type}")
await change_group_switch(_cmd, int(block_type), True)
group_name = (await bot.get_group_info(group_id=int(block_type)))[
"group_name"
]
await switch_rule_matcher.send(
f"已{_cmd[:2]}群聊 {group_name}({block_type}) 的 {_cmd[2:]} 功能"
)
elif block_type in ["all", "private", "group", "a", "p", "g"]:
block_type = "all" if block_type == "a" else block_type
block_type = "private" if block_type == "p" else block_type
block_type = "group" if block_type == "g" else block_type
set_plugin_status(_cmd, block_type) # type: ignore
if block_type == "all":
await switch_rule_matcher.send(f"已{_cmd[:2]}功能：{_cmd[2:]}")
elif block_type == "private":
await switch_rule_matcher.send(f"已在私聊中{_cmd[:2]}功能：{_cmd[2:]}")
else:
await switch_rule_matcher.send(f"已在群聊中{_cmd[:2]}功能：{_cmd[2:]}")
else:
await switch_rule_matcher.finish("格式错误：关闭[功能] [group]/[p/g]")
logger.info(f"使用功能管理命令 {_cmd} | {block_type}", f"{_cmd}", event.user_id) | null |
188,115 | from typing import Any, Tuple
from nonebot import on_command, on_message, on_regex
from nonebot.adapters.onebot.v11 import (
GROUP,
Bot,
GroupMessageEvent,
Message,
MessageEvent,
PrivateMessageEvent,
)
from nonebot.params import CommandArg, RegexGroup
from nonebot.permission import SUPERUSER
from configs.config import NICKNAME, Config
from services.log import logger
from utils.message_builder import image
from utils.utils import get_message_text, is_number
from ._data_source import (
change_global_task_status,
change_group_switch,
get_plugin_status,
group_current_status,
set_group_bot_status,
set_plugin_status,
)
from .rule import switch_rule
plugins_status = on_command("功能状态", permission=SUPERUSER, priority=5, block=True)
async def get_plugin_status():
"""
说明:
获取功能状态
"""
return await asyncio.get_event_loop().run_in_executor(None, _get_plugin_status)
async def _():
await plugins_status.send(await get_plugin_status()) | null |
188,116 | from typing import Any, Tuple
from nonebot import on_command, on_message, on_regex
from nonebot.adapters.onebot.v11 import (
GROUP,
Bot,
GroupMessageEvent,
Message,
MessageEvent,
PrivateMessageEvent,
)
from nonebot.params import CommandArg, RegexGroup
from nonebot.permission import SUPERUSER
from configs.config import NICKNAME, Config
from services.log import logger
from utils.message_builder import image
from utils.utils import get_message_text, is_number
from ._data_source import (
change_global_task_status,
change_group_switch,
get_plugin_status,
group_current_status,
set_group_bot_status,
set_plugin_status,
)
from .rule import switch_rule
task_status = on_command("群被动状态", permission=GROUP, priority=5, block=True)
def image(
file: Optional[Union[str, Path, bytes, BuildImage, io.BytesIO, BuildMat]] = None,
b64: Optional[str] = None,
) -> MessageSegment:
"""
说明:
生成一个 MessageSegment.image 消息
生成顺序：绝对路径(abspath) > base64(b64) > img_name
参数:
:param file: 图片文件
:param b64: 图片base64（兼容旧方法）
"""
if b64:
file = b64 if b64.startswith("base64://") else ("base64://" + b64)
if isinstance(file, str):
if file.startswith(("http", "base64://")):
return MessageSegment.image(file)
else:
if (IMAGE_PATH / file).exists():
return MessageSegment.image(IMAGE_PATH / file)
logger.warning(f"图片 {(IMAGE_PATH / file).absolute()}缺失...")
return ""
if isinstance(file, Path):
if file.exists():
return MessageSegment.image(file)
logger.warning(f"图片 {file.absolute()}缺失...")
if isinstance(file, (bytes, io.BytesIO)):
return MessageSegment.image(file)
if isinstance(file, (BuildImage, BuildMat)):
return MessageSegment.image(file.pic2bs4())
return MessageSegment.image("")
async def group_current_status(group_id: str) -> str:
"""
说明:
获取当前群聊所有通知的开关
参数:
:param group_id: 群号
"""
_data = group_manager.get_task_data()
image_list = []
for i, task in enumerate(_data):
name = _data[task]
name_image = BuildImage(0, 0, plain_text=f"{i+1}.{name}", font_size=20)
bk = BuildImage(
name_image.w + 200, name_image.h + 20, color=(103, 177, 109), font_size=15
)
await bk.apaste(name_image, (10, 0), True, "by_height")
a_icon = BuildImage(40, 40, background=ICON_PATH / "btn_false.png")
if group_manager.check_group_task_status(group_id, task):
a_icon = BuildImage(40, 40, background=ICON_PATH / "btn_true.png")
b_icon = BuildImage(40, 40, background=ICON_PATH / "btn_false.png")
if group_manager.check_task_super_status(task):
b_icon = BuildImage(40, 40, background=ICON_PATH / "btn_true.png")
await bk.atext((name_image.w + 20, 10), "状态")
await bk.apaste(a_icon, (name_image.w + 50, 0), True)
await bk.atext((name_image.w + 100, 10), "全局")
await bk.apaste(b_icon, (name_image.w + 130, 0), True)
image_list.append(bk)
w = max([x.w for x in image_list])
h = sum([x.h + 10 for x in image_list])
A = BuildImage(w + 20, h + 70, font_size=30, color=(119, 97, 177))
await A.atext((15, 20), "群被动状态")
curr_h = 75
for img in image_list:
# await img.acircle_corner()
await A.apaste(img, (0, curr_h), True)
curr_h += img.h + 10
return A.pic2bs4()
async def _(event: GroupMessageEvent):
await group_task_status.send(image(b64=await group_current_status(str(event.group_id)))) | null |
188,117 | from typing import Any, Tuple
from nonebot import on_command, on_message, on_regex
from nonebot.adapters.onebot.v11 import (
GROUP,
Bot,
GroupMessageEvent,
Message,
MessageEvent,
PrivateMessageEvent,
)
from nonebot.params import CommandArg, RegexGroup
from nonebot.permission import SUPERUSER
from configs.config import NICKNAME, Config
from services.log import logger
from utils.message_builder import image
from utils.utils import get_message_text, is_number
from ._data_source import (
change_global_task_status,
change_group_switch,
get_plugin_status,
group_current_status,
set_group_bot_status,
set_plugin_status,
)
from .rule import switch_rule
atus = on_regex("^(休息吧|醒来)$", permission=GROUP, priority=5, block=True)
class logger:
TEMPLATE_A = "{}"
TEMPLATE_B = "[<u><c>{}</c></u>]: {}"
TEMPLATE_C = "用户[<u><e>{}</e></u>] 触发 [<u><c>{}</c></u>]: {}"
TEMPLATE_D = "群聊[<u><e>{}</e></u>] 用户[<u><e>{}</e></u>] 触发 [<u><c>{}</c></u>]: {}"
TEMPLATE_E = "群聊[<u><e>{}</e></u>] 用户[<u><e>{}</e></u>] 触发 [<u><c>{}</c></u>] [Target](<u><e>{}</e></u>): {}"
TEMPLATE_USER = "用户[<u><e>{}</e></u>] "
TEMPLATE_GROUP = "群聊[<u><e>{}</e></u>] "
TEMPLATE_COMMAND = "CMD[<u><c>{}</c></u>] "
TEMPLATE_TARGET = "[Target]([<u><e>{}</e></u>]) "
SUCCESS_TEMPLATE = "[<u><c>{}</c></u>]: {} | 参数[{}] 返回: [<y>{}</y>]"
WARNING_TEMPLATE = "[<u><y>{}</y></u>]: {}"
ERROR_TEMPLATE = "[<u><r>{}</r></u>]: {}"
def info(
cls,
info: str,
command: Optional[str] = None,
user_id: Optional[Union[int, str]] = None,
group_id: Optional[Union[int, str]] = None,
target: Optional[Any] = None,
):
template = cls.__parser_template(info, command, user_id, group_id, target)
logger_.opt(colors=True).info(template)
def success(
cls,
info: str,
command: str,
param: Optional[Dict[str, Any]] = None,
result: Optional[str] = "",
):
param_str = ""
if param:
param_str = ",".join([f"<m>{k}</m>:<g>{v}</g>" for k, v in param.items()])
logger_.opt(colors=True).success(
cls.SUCCESS_TEMPLATE.format(command, info, param_str, result)
)
def warning(
cls,
info: str,
command: Optional[str] = None,
user_id: Optional[Union[int, str]] = None,
group_id: Optional[Union[int, str]] = None,
target: Optional[Any] = None,
e: Optional[Exception] = None,
):
template = cls.__parser_template(info, command, user_id, group_id, target)
if e:
template += f" || 错误<r>{type(e)}: {e}</r>"
logger_.opt(colors=True).warning(template)
def error(
cls,
info: str,
command: Optional[str] = None,
user_id: Optional[Union[int, str]] = None,
group_id: Optional[Union[int, str]] = None,
target: Optional[Any] = None,
e: Optional[Exception] = None,
):
template = cls.__parser_template(info, command, user_id, group_id, target)
if e:
template += f" || 错误 <r>{type(e)}: {e}</r>"
logger_.opt(colors=True).error(template)
def debug(
cls,
info: str,
command: Optional[str] = None,
user_id: Optional[Union[int, str]] = None,
group_id: Optional[Union[int, str]] = None,
target: Optional[Any] = None,
e: Optional[Exception] = None,
):
template = cls.__parser_template(info, command, user_id, group_id, target)
if e:
template += f" || 错误 <r>{type(e)}: {e}</r>"
logger_.opt(colors=True).debug(template)
def __parser_template(
cls,
info: str,
command: Optional[str] = None,
user_id: Optional[Union[int, str]] = None,
group_id: Optional[Union[int, str]] = None,
target: Optional[Any] = None,
) -> str:
arg_list = []
template = ""
if group_id is not None:
template += cls.TEMPLATE_GROUP
arg_list.append(group_id)
if user_id is not None:
template += cls.TEMPLATE_USER
arg_list.append(user_id)
if command is not None:
template += cls.TEMPLATE_COMMAND
arg_list.append(command)
if target is not None:
template += cls.TEMPLATE_TARGET
arg_list.append(target)
arg_list.append(info)
template += "{}"
return template.format(*arg_list)
def set_group_bot_status(group_id: str, status: bool) -> str:
"""
说明:
设置群聊bot开关状态
参数:
:param group_id: 群号
:param status: 状态
"""
if status:
if group_manager.check_group_bot_status(group_id):
return "我还醒着呢！"
group_manager.turn_on_group_bot_status(group_id)
return "呜..醒来了..."
else:
group_manager.shutdown_group_bot_status(group_id)
return "那我先睡觉了..."
async def _(event: GroupMessageEvent, reg_group: Tuple[Any, ...] = RegexGroup()):
cmd = reg_group[0]
if cmd == "休息吧":
msg = set_group_bot_status(str(event.group_id), False)
else:
msg = set_group_bot_status(str(event.group_id), True)
await group_status.send(msg)
logger.info(f"使用总开关命令: {cmd}", cmd, event.user_id, event.group_id) | null |
188,118 | from nonebot import on_notice
from nonebot.adapters.onebot.v11 import GroupAdminNoticeEvent
from configs.config import Config
from models.group_member_info import GroupInfoUser
from models.level_user import LevelUser
from services.log import logger
class GroupInfoUser(Model):
id = fields.IntField(pk=True, generated=True, auto_increment=True)
"""自增id"""
user_id = fields.CharField(255)
"""用户id"""
user_name = fields.CharField(255, default="")
"""用户昵称"""
group_id = fields.CharField(255)
"""群聊id"""
user_join_time: datetime = fields.DatetimeField(null=True)
"""用户入群时间"""
nickname = fields.CharField(255, null=True)
"""群聊昵称"""
uid = fields.BigIntField(null=True)
"""用户uid"""
class Meta:
table = "group_info_users"
table_description = "群员信息数据表"
unique_together = ("user_id", "group_id")
async def get_group_member_id_list(cls, group_id: Union[int, str]) -> Set[int]:
"""
说明:
获取该群所有用户id
参数:
:param group_id: 群号
"""
return set(
await cls.filter(group_id=str(group_id)).values_list("user_id", flat=True)
) # type: ignore
async def set_user_nickname(cls, user_id: Union[int, str], group_id: Union[int, str], nickname: str):
"""
说明:
设置群员在该群内的昵称
参数:
:param user_id: 用户id
:param group_id: 群号
:param nickname: 昵称
"""
await cls.update_or_create(
user_id=str(user_id),
group_id=str(group_id),
defaults={"nickname": nickname},
)
async def get_user_all_group(cls, user_id: Union[int, str]) -> List[int]:
"""
说明:
获取该用户所在的所有群聊
参数:
:param user_id: 用户id
"""
return list(
await cls.filter(user_id=str(user_id)).values_list("group_id", flat=True)
) # type: ignore
async def get_user_nickname(cls, user_id: Union[int, str], group_id: Union[int, str]) -> str:
"""
说明:
获取用户在该群的昵称
参数:
:param user_id: 用户id
:param group_id: 群号
"""
if user := await cls.get_or_none(user_id=str(user_id), group_id=str(group_id)):
if user.nickname:
nickname = ""
if black_word := Config.get_config("nickname", "BLACK_WORD"):
for x in user.nickname:
nickname += "*" if x in black_word else x
return nickname
return user.nickname
return ""
async def get_group_member_uid(cls, user_id: Union[int, str], group_id: Union[int, str]) -> Optional[int]:
logger.debug(
f"GroupInfoUser 尝试获取 用户[<u><e>{user_id}</e></u>] 群聊[<u><e>{group_id}</e></u>] UID"
)
user, _ = await cls.get_or_create(user_id=str(user_id), group_id=str(group_id))
_max_uid_user, _ = await cls.get_or_create(user_id="114514", group_id="114514")
_max_uid = _max_uid_user.uid
if not user.uid:
all_user = await cls.filter(user_id=str(user_id)).all()
for x in all_user:
if x.uid:
return x.uid
user.uid = _max_uid + 1
_max_uid_user.uid = _max_uid + 1
await cls.bulk_update([user, _max_uid_user], ["uid"])
logger.debug(
f"GroupInfoUser 获取 用户[<u><e>{user_id}</e></u>] 群聊[<u><e>{group_id}</e></u>] UID: {user.uid}"
)
return user.uid
async def _run_script(cls):
return [
"alter table group_info_users alter user_join_time drop not null;", # 允许 user_join_time 为空
"ALTER TABLE group_info_users ALTER COLUMN user_join_time TYPE timestamp with time zone USING user_join_time::timestamp with time zone;",
"ALTER TABLE group_info_users RENAME COLUMN user_qq TO user_id;", # 将user_id改为user_id
"ALTER TABLE group_info_users ALTER COLUMN user_id TYPE character varying(255);",
# 将user_id字段类型改为character varying(255)
"ALTER TABLE group_info_users ALTER COLUMN group_id TYPE character varying(255);"
]
class LevelUser(Model):
id = fields.IntField(pk=True, generated=True, auto_increment=True)
"""自增id"""
user_id = fields.CharField(255)
"""用户id"""
group_id = fields.CharField(255)
"""群聊id"""
user_level = fields.BigIntField()
"""用户权限等级"""
group_flag = fields.IntField(default=0)
"""特殊标记，是否随群管理员变更而设置权限"""
class Meta:
table = "level_users"
table_description = "用户权限数据库"
unique_together = ("user_id", "group_id")
async def get_user_level(cls, user_id: Union[int, str], group_id: Union[int, str]) -> int:
"""
说明:
获取用户在群内的等级
参数:
:param user_id: 用户id
:param group_id: 群组id
"""
if user := await cls.get_or_none(user_id=str(user_id), group_id=str(group_id)):
return user.user_level
return -1
async def set_level(
cls, user_id: Union[int, str], group_id: Union[int, str], level: int, group_flag: int = 0
):
"""
说明:
设置用户在群内的权限
参数:
:param user_id: 用户id
:param group_id: 群组id
:param level: 权限等级
:param group_flag: 是否被自动更新刷新权限 0：是，1：否
"""
await cls.update_or_create(
user_id=str(user_id),
group_id=str(group_id),
defaults={"user_level": level, "group_flag": group_flag},
)
async def delete_level(cls, user_id: Union[int, str], group_id: Union[int, str]) -> bool:
"""
说明:
删除用户权限
参数:
:param user_id: 用户id
:param group_id: 群组id
"""
if user := await cls.get_or_none(user_id=str(user_id), group_id=str(group_id)):
await user.delete()
return True
return False
async def check_level(cls, user_id: Union[int, str], group_id: Union[int, str], level: int) -> bool:
"""
说明:
检查用户权限等级是否大于 level
参数:
:param user_id: 用户id
:param group_id: 群组id
:param level: 权限等级
"""
if group_id:
if user := await cls.get_or_none(user_id=str(user_id), group_id=str(group_id)):
return user.user_level >= level
else:
user_list = await cls.filter(user_id=str(user_id)).all()
user = max(user_list, key=lambda x: x.user_level)
return user.user_level >= level
return False
async def is_group_flag(cls, user_id: Union[int, str], group_id: Union[int, str]) -> bool:
"""
说明:
检测是否会被自动更新刷新权限
参数:
:param user_id: 用户id
:param group_id: 群组id
"""
if user := await cls.get_or_none(user_id=str(user_id), group_id=str(group_id)):
return user.group_flag == 1
return False
async def _run_script(cls):
return ["ALTER TABLE level_users RENAME COLUMN user_qq TO user_id;", # 将user_id改为user_id
"ALTER TABLE level_users ALTER COLUMN user_id TYPE character varying(255);",
# 将user_id字段类型改为character varying(255)
"ALTER TABLE level_users ALTER COLUMN group_id TYPE character varying(255);"
]
class logger:
TEMPLATE_A = "{}"
TEMPLATE_B = "[<u><c>{}</c></u>]: {}"
TEMPLATE_C = "用户[<u><e>{}</e></u>] 触发 [<u><c>{}</c></u>]: {}"
TEMPLATE_D = "群聊[<u><e>{}</e></u>] 用户[<u><e>{}</e></u>] 触发 [<u><c>{}</c></u>]: {}"
TEMPLATE_E = "群聊[<u><e>{}</e></u>] 用户[<u><e>{}</e></u>] 触发 [<u><c>{}</c></u>] [Target](<u><e>{}</e></u>): {}"
TEMPLATE_USER = "用户[<u><e>{}</e></u>] "
TEMPLATE_GROUP = "群聊[<u><e>{}</e></u>] "
TEMPLATE_COMMAND = "CMD[<u><c>{}</c></u>] "
TEMPLATE_TARGET = "[Target]([<u><e>{}</e></u>]) "
SUCCESS_TEMPLATE = "[<u><c>{}</c></u>]: {} | 参数[{}] 返回: [<y>{}</y>]"
WARNING_TEMPLATE = "[<u><y>{}</y></u>]: {}"
ERROR_TEMPLATE = "[<u><r>{}</r></u>]: {}"
def info(
cls,
info: str,
command: Optional[str] = None,
user_id: Optional[Union[int, str]] = None,
group_id: Optional[Union[int, str]] = None,
target: Optional[Any] = None,
):
template = cls.__parser_template(info, command, user_id, group_id, target)
logger_.opt(colors=True).info(template)
def success(
cls,
info: str,
command: str,
param: Optional[Dict[str, Any]] = None,
result: Optional[str] = "",
):
param_str = ""
if param:
param_str = ",".join([f"<m>{k}</m>:<g>{v}</g>" for k, v in param.items()])
logger_.opt(colors=True).success(
cls.SUCCESS_TEMPLATE.format(command, info, param_str, result)
)
def warning(
cls,
info: str,
command: Optional[str] = None,
user_id: Optional[Union[int, str]] = None,
group_id: Optional[Union[int, str]] = None,
target: Optional[Any] = None,
e: Optional[Exception] = None,
):
template = cls.__parser_template(info, command, user_id, group_id, target)
if e:
template += f" || 错误<r>{type(e)}: {e}</r>"
logger_.opt(colors=True).warning(template)
def error(
cls,
info: str,
command: Optional[str] = None,
user_id: Optional[Union[int, str]] = None,
group_id: Optional[Union[int, str]] = None,
target: Optional[Any] = None,
e: Optional[Exception] = None,
):
template = cls.__parser_template(info, command, user_id, group_id, target)
if e:
template += f" || 错误 <r>{type(e)}: {e}</r>"
logger_.opt(colors=True).error(template)
def debug(
cls,
info: str,
command: Optional[str] = None,
user_id: Optional[Union[int, str]] = None,
group_id: Optional[Union[int, str]] = None,
target: Optional[Any] = None,
e: Optional[Exception] = None,
):
template = cls.__parser_template(info, command, user_id, group_id, target)
if e:
template += f" || 错误 <r>{type(e)}: {e}</r>"
logger_.opt(colors=True).debug(template)
def __parser_template(
cls,
info: str,
command: Optional[str] = None,
user_id: Optional[Union[int, str]] = None,
group_id: Optional[Union[int, str]] = None,
target: Optional[Any] = None,
) -> str:
arg_list = []
template = ""
if group_id is not None:
template += cls.TEMPLATE_GROUP
arg_list.append(group_id)
if user_id is not None:
template += cls.TEMPLATE_USER
arg_list.append(user_id)
if command is not None:
template += cls.TEMPLATE_COMMAND
arg_list.append(command)
if target is not None:
template += cls.TEMPLATE_TARGET
arg_list.append(target)
arg_list.append(info)
template += "{}"
return template.format(*arg_list)
async def _(event: GroupAdminNoticeEvent):
if user := await GroupInfoUser.get_or_none(
user_id=str(event.user_id), group_id=str(event.group_id)
):
nickname = user.user_name
else:
nickname = event.user_id
if event.sub_type == "set":
admin_default_auth = Config.get_config("admin_bot_manage", "ADMIN_DEFAULT_AUTH")
if admin_default_auth is not None:
await LevelUser.set_level(
event.user_id,
event.group_id,
admin_default_auth,
)
logger.info(
f"成为管理员，添加权限: {admin_default_auth}",
"群管理员变动监测",
event.user_id,
event.group_id,
)
else:
logger.warning(
f"配置项 MODULE: [<u><y>admin_bot_manage</y></u>] | KEY: [<u><y>ADMIN_DEFAULT_AUTH</y></u>] 为空"
)
elif event.sub_type == "unset":
await LevelUser.delete_level(event.user_id, event.group_id)
logger.info("撤销管理员,，取消权限等级", "群管理员变动监测", event.user_id, event.group_id) | null |
188,119 | from nonebot import get_bots
from services.log import logger
from utils.utils import scheduler
from ._data_source import update_member_info
class logger:
TEMPLATE_A = "{}"
TEMPLATE_B = "[<u><c>{}</c></u>]: {}"
TEMPLATE_C = "用户[<u><e>{}</e></u>] 触发 [<u><c>{}</c></u>]: {}"
TEMPLATE_D = "群聊[<u><e>{}</e></u>] 用户[<u><e>{}</e></u>] 触发 [<u><c>{}</c></u>]: {}"
TEMPLATE_E = "群聊[<u><e>{}</e></u>] 用户[<u><e>{}</e></u>] 触发 [<u><c>{}</c></u>] [Target](<u><e>{}</e></u>): {}"
TEMPLATE_USER = "用户[<u><e>{}</e></u>] "
TEMPLATE_GROUP = "群聊[<u><e>{}</e></u>] "
TEMPLATE_COMMAND = "CMD[<u><c>{}</c></u>] "
TEMPLATE_TARGET = "[Target]([<u><e>{}</e></u>]) "
SUCCESS_TEMPLATE = "[<u><c>{}</c></u>]: {} | 参数[{}] 返回: [<y>{}</y>]"
WARNING_TEMPLATE = "[<u><y>{}</y></u>]: {}"
ERROR_TEMPLATE = "[<u><r>{}</r></u>]: {}"
def info(
cls,
info: str,
command: Optional[str] = None,
user_id: Optional[Union[int, str]] = None,
group_id: Optional[Union[int, str]] = None,
target: Optional[Any] = None,
):
template = cls.__parser_template(info, command, user_id, group_id, target)
logger_.opt(colors=True).info(template)
def success(
cls,
info: str,
command: str,
param: Optional[Dict[str, Any]] = None,
result: Optional[str] = "",
):
param_str = ""
if param:
param_str = ",".join([f"<m>{k}</m>:<g>{v}</g>" for k, v in param.items()])
logger_.opt(colors=True).success(
cls.SUCCESS_TEMPLATE.format(command, info, param_str, result)
)
def warning(
cls,
info: str,
command: Optional[str] = None,
user_id: Optional[Union[int, str]] = None,
group_id: Optional[Union[int, str]] = None,
target: Optional[Any] = None,
e: Optional[Exception] = None,
):
template = cls.__parser_template(info, command, user_id, group_id, target)
if e:
template += f" || 错误<r>{type(e)}: {e}</r>"
logger_.opt(colors=True).warning(template)
def error(
cls,
info: str,
command: Optional[str] = None,
user_id: Optional[Union[int, str]] = None,
group_id: Optional[Union[int, str]] = None,
target: Optional[Any] = None,
e: Optional[Exception] = None,
):
template = cls.__parser_template(info, command, user_id, group_id, target)
if e:
template += f" || 错误 <r>{type(e)}: {e}</r>"
logger_.opt(colors=True).error(template)
def debug(
cls,
info: str,
command: Optional[str] = None,
user_id: Optional[Union[int, str]] = None,
group_id: Optional[Union[int, str]] = None,
target: Optional[Any] = None,
e: Optional[Exception] = None,
):
template = cls.__parser_template(info, command, user_id, group_id, target)
if e:
template += f" || 错误 <r>{type(e)}: {e}</r>"
logger_.opt(colors=True).debug(template)
def __parser_template(
cls,
info: str,
command: Optional[str] = None,
user_id: Optional[Union[int, str]] = None,
group_id: Optional[Union[int, str]] = None,
target: Optional[Any] = None,
) -> str:
arg_list = []
template = ""
if group_id is not None:
template += cls.TEMPLATE_GROUP
arg_list.append(group_id)
if user_id is not None:
template += cls.TEMPLATE_USER
arg_list.append(user_id)
if command is not None:
template += cls.TEMPLATE_COMMAND
arg_list.append(command)
if target is not None:
template += cls.TEMPLATE_TARGET
arg_list.append(target)
arg_list.append(info)
template += "{}"
return template.format(*arg_list)
async def update_member_info(
bot: Bot, group_id: int, remind_superuser: bool = False
) -> bool:
"""
说明:
更新群成员信息
参数:
:param group_id: 群号
:param remind_superuser: 失败信息提醒超级用户
"""
_group_user_list = await bot.get_group_member_list(group_id=group_id)
_error_member_list = []
_exist_member_list = []
# try:
admin_default_auth = Config.get_config("admin_bot_manage", "ADMIN_DEFAULT_AUTH")
if admin_default_auth is not None:
for user_info in _group_user_list:
nickname = user_info["card"] or user_info["nickname"]
# 更新权限
if user_info["role"] in [
"owner",
"admin",
] and not await LevelUser.is_group_flag(
user_info["user_id"], str(group_id)
):
await LevelUser.set_level(
user_info["user_id"],
user_info["group_id"],
admin_default_auth,
)
if str(user_info["user_id"]) in bot.config.superusers:
await LevelUser.set_level(
user_info["user_id"], user_info["group_id"], 9
)
user = await GroupInfoUser.get_or_none(
user_id=str(user_info["user_id"]), group_id=str(user_info["group_id"])
)
if user:
if user.user_name != nickname:
user.user_name = nickname
await user.save(update_fields=["user_name"])
logger.debug(
f"更新群昵称成功",
"更新群组成员信息",
user_info["user_id"],
user_info["group_id"],
)
_exist_member_list.append(str(user_info["user_id"]))
continue
join_time = datetime.strptime(
time.strftime(
"%Y-%m-%d %H:%M:%S", time.localtime(user_info["join_time"])
),
"%Y-%m-%d %H:%M:%S",
)
await GroupInfoUser.update_or_create(
user_id=str(user_info["user_id"]),
group_id=str(user_info["group_id"]),
defaults={
"user_name": nickname,
"user_join_time": join_time.replace(
tzinfo=timezone(timedelta(hours=8))
),
},
)
_exist_member_list.append(str(user_info["user_id"]))
logger.debug("更新成功", "更新成员信息", user_info["user_id"], user_info["group_id"])
_del_member_list = list(
set(_exist_member_list).difference(
set(await GroupInfoUser.get_group_member_id_list(group_id))
)
)
if _del_member_list:
for del_user in _del_member_list:
await GroupInfoUser.filter(
user_id=str(del_user), group_id=str(group_id)
).delete()
logger.info(f"删除已退群用户", "更新群组成员信息", del_user, group_id)
if _error_member_list and remind_superuser:
result = ""
for error_user in _error_member_list:
result += error_user
await bot.send_private_msg(
user_id=int(list(bot.config.superusers)[0]), message=result[:-1]
)
return True
async def update():
bot_list = get_bots()
if bot_list:
used_group = []
for key in bot_list:
bot = bot_list[key]
gl = await bot.get_group_list()
gl = [g["group_id"] for g in gl if g["group_id"] not in used_group]
for g in gl:
used_group.append(g)
try:
await update_member_info(bot, g) # type: ignore
logger.debug(f"更新群组成员信息成功", "自动更新群组成员信息", group_id=g)
except Exception as e:
logger.error(f"更新群组成员信息错误", "自动更新群组成员信息", group_id=g, e=e) | null |
188,120 | from nonebot import on_command, on_notice
from nonebot.adapters.onebot.v11 import (
GROUP,
Bot,
GroupIncreaseNoticeEvent,
GroupMessageEvent,
)
from services.log import logger
from ._data_source import update_member_info
refresh_member_group = on_command(
"更新群组成员列表", aliases={"更新群组成员信息"}, permission=GROUP, priority=5, block=True
)
class logger:
TEMPLATE_A = "{}"
TEMPLATE_B = "[<u><c>{}</c></u>]: {}"
TEMPLATE_C = "用户[<u><e>{}</e></u>] 触发 [<u><c>{}</c></u>]: {}"
TEMPLATE_D = "群聊[<u><e>{}</e></u>] 用户[<u><e>{}</e></u>] 触发 [<u><c>{}</c></u>]: {}"
TEMPLATE_E = "群聊[<u><e>{}</e></u>] 用户[<u><e>{}</e></u>] 触发 [<u><c>{}</c></u>] [Target](<u><e>{}</e></u>): {}"
TEMPLATE_USER = "用户[<u><e>{}</e></u>] "
TEMPLATE_GROUP = "群聊[<u><e>{}</e></u>] "
TEMPLATE_COMMAND = "CMD[<u><c>{}</c></u>] "
TEMPLATE_TARGET = "[Target]([<u><e>{}</e></u>]) "
SUCCESS_TEMPLATE = "[<u><c>{}</c></u>]: {} | 参数[{}] 返回: [<y>{}</y>]"
WARNING_TEMPLATE = "[<u><y>{}</y></u>]: {}"
ERROR_TEMPLATE = "[<u><r>{}</r></u>]: {}"
def info(
cls,
info: str,
command: Optional[str] = None,
user_id: Optional[Union[int, str]] = None,
group_id: Optional[Union[int, str]] = None,
target: Optional[Any] = None,
):
template = cls.__parser_template(info, command, user_id, group_id, target)
logger_.opt(colors=True).info(template)
def success(
cls,
info: str,
command: str,
param: Optional[Dict[str, Any]] = None,
result: Optional[str] = "",
):
param_str = ""
if param:
param_str = ",".join([f"<m>{k}</m>:<g>{v}</g>" for k, v in param.items()])
logger_.opt(colors=True).success(
cls.SUCCESS_TEMPLATE.format(command, info, param_str, result)
)
def warning(
cls,
info: str,
command: Optional[str] = None,
user_id: Optional[Union[int, str]] = None,
group_id: Optional[Union[int, str]] = None,
target: Optional[Any] = None,
e: Optional[Exception] = None,
):
template = cls.__parser_template(info, command, user_id, group_id, target)
if e:
template += f" || 错误<r>{type(e)}: {e}</r>"
logger_.opt(colors=True).warning(template)
def error(
cls,
info: str,
command: Optional[str] = None,
user_id: Optional[Union[int, str]] = None,
group_id: Optional[Union[int, str]] = None,
target: Optional[Any] = None,
e: Optional[Exception] = None,
):
template = cls.__parser_template(info, command, user_id, group_id, target)
if e:
template += f" || 错误 <r>{type(e)}: {e}</r>"
logger_.opt(colors=True).error(template)
def debug(
cls,
info: str,
command: Optional[str] = None,
user_id: Optional[Union[int, str]] = None,
group_id: Optional[Union[int, str]] = None,
target: Optional[Any] = None,
e: Optional[Exception] = None,
):
template = cls.__parser_template(info, command, user_id, group_id, target)
if e:
template += f" || 错误 <r>{type(e)}: {e}</r>"
logger_.opt(colors=True).debug(template)
def __parser_template(
cls,
info: str,
command: Optional[str] = None,
user_id: Optional[Union[int, str]] = None,
group_id: Optional[Union[int, str]] = None,
target: Optional[Any] = None,
) -> str:
arg_list = []
template = ""
if group_id is not None:
template += cls.TEMPLATE_GROUP
arg_list.append(group_id)
if user_id is not None:
template += cls.TEMPLATE_USER
arg_list.append(user_id)
if command is not None:
template += cls.TEMPLATE_COMMAND
arg_list.append(command)
if target is not None:
template += cls.TEMPLATE_TARGET
arg_list.append(target)
arg_list.append(info)
template += "{}"
return template.format(*arg_list)
async def update_member_info(
bot: Bot, group_id: int, remind_superuser: bool = False
) -> bool:
"""
说明:
更新群成员信息
参数:
:param group_id: 群号
:param remind_superuser: 失败信息提醒超级用户
"""
_group_user_list = await bot.get_group_member_list(group_id=group_id)
_error_member_list = []
_exist_member_list = []
# try:
admin_default_auth = Config.get_config("admin_bot_manage", "ADMIN_DEFAULT_AUTH")
if admin_default_auth is not None:
for user_info in _group_user_list:
nickname = user_info["card"] or user_info["nickname"]
# 更新权限
if user_info["role"] in [
"owner",
"admin",
] and not await LevelUser.is_group_flag(
user_info["user_id"], str(group_id)
):
await LevelUser.set_level(
user_info["user_id"],
user_info["group_id"],
admin_default_auth,
)
if str(user_info["user_id"]) in bot.config.superusers:
await LevelUser.set_level(
user_info["user_id"], user_info["group_id"], 9
)
user = await GroupInfoUser.get_or_none(
user_id=str(user_info["user_id"]), group_id=str(user_info["group_id"])
)
if user:
if user.user_name != nickname:
user.user_name = nickname
await user.save(update_fields=["user_name"])
logger.debug(
f"更新群昵称成功",
"更新群组成员信息",
user_info["user_id"],
user_info["group_id"],
)
_exist_member_list.append(str(user_info["user_id"]))
continue
join_time = datetime.strptime(
time.strftime(
"%Y-%m-%d %H:%M:%S", time.localtime(user_info["join_time"])
),
"%Y-%m-%d %H:%M:%S",
)
await GroupInfoUser.update_or_create(
user_id=str(user_info["user_id"]),
group_id=str(user_info["group_id"]),
defaults={
"user_name": nickname,
"user_join_time": join_time.replace(
tzinfo=timezone(timedelta(hours=8))
),
},
)
_exist_member_list.append(str(user_info["user_id"]))
logger.debug("更新成功", "更新成员信息", user_info["user_id"], user_info["group_id"])
_del_member_list = list(
set(_exist_member_list).difference(
set(await GroupInfoUser.get_group_member_id_list(group_id))
)
)
if _del_member_list:
for del_user in _del_member_list:
await GroupInfoUser.filter(
user_id=str(del_user), group_id=str(group_id)
).delete()
logger.info(f"删除已退群用户", "更新群组成员信息", del_user, group_id)
if _error_member_list and remind_superuser:
result = ""
for error_user in _error_member_list:
result += error_user
await bot.send_private_msg(
user_id=int(list(bot.config.superusers)[0]), message=result[:-1]
)
return True
async def _(bot: Bot, event: GroupMessageEvent):
if await update_member_info(bot, event.group_id):
await refresh_member_group.send("更新群员信息成功！", at_sender=True)
logger.info("更新群员信息成功！", "更新群组成员列表", event.user_id, event.group_id)
else:
await refresh_member_group.send("更新群员信息失败！", at_sender=True)
logger.info("更新群员信息失败！", "更新群组成员列表", event.user_id, event.group_id) | null |
188,121 | from nonebot import on_command, on_notice
from nonebot.adapters.onebot.v11 import (
GROUP,
Bot,
GroupIncreaseNoticeEvent,
GroupMessageEvent,
)
from services.log import logger
from ._data_source import update_member_info
class logger:
def info(
cls,
info: str,
command: Optional[str] = None,
user_id: Optional[Union[int, str]] = None,
group_id: Optional[Union[int, str]] = None,
target: Optional[Any] = None,
):
def success(
cls,
info: str,
command: str,
param: Optional[Dict[str, Any]] = None,
result: Optional[str] = "",
):
def warning(
cls,
info: str,
command: Optional[str] = None,
user_id: Optional[Union[int, str]] = None,
group_id: Optional[Union[int, str]] = None,
target: Optional[Any] = None,
e: Optional[Exception] = None,
):
def error(
cls,
info: str,
command: Optional[str] = None,
user_id: Optional[Union[int, str]] = None,
group_id: Optional[Union[int, str]] = None,
target: Optional[Any] = None,
e: Optional[Exception] = None,
):
def debug(
cls,
info: str,
command: Optional[str] = None,
user_id: Optional[Union[int, str]] = None,
group_id: Optional[Union[int, str]] = None,
target: Optional[Any] = None,
e: Optional[Exception] = None,
):
def __parser_template(
cls,
info: str,
command: Optional[str] = None,
user_id: Optional[Union[int, str]] = None,
group_id: Optional[Union[int, str]] = None,
target: Optional[Any] = None,
) -> str:
async def update_member_info(
bot: Bot, group_id: int, remind_superuser: bool = False
) -> bool:
async def _(bot: Bot, event: GroupIncreaseNoticeEvent):
if str(event.user_id) == bot.self_id:
await update_member_info(bot, event.group_id)
logger.info("{NICKNAME}加入群聊更新群组信息", "更新群组成员列表", event.user_id, event.group_id) | null |
188,122 | import random
from typing import Any, List, Tuple
from nonebot import on_command, on_regex
from nonebot.adapters.onebot.v11 import Bot, GroupMessageEvent, Message, MessageEvent
from nonebot.internal.matcher import Matcher
from nonebot.internal.params import Depends
from nonebot.params import CommandArg, RegexGroup
from nonebot.rule import to_me
from configs.config import NICKNAME
from models.ban_user import BanUser
from models.friend_user import FriendUser
from models.group_member_info import GroupInfoUser
from services.log import logger
from utils.depends import GetConfig
nickname = on_regex(
"(?:以后)?(?:叫我|请叫我|称呼我)(.*)",
rule=to_me(),
priority=5,
block=True,
)
class logger:
TEMPLATE_A = "{}"
TEMPLATE_B = "[<u><c>{}</c></u>]: {}"
TEMPLATE_C = "用户[<u><e>{}</e></u>] 触发 [<u><c>{}</c></u>]: {}"
TEMPLATE_D = "群聊[<u><e>{}</e></u>] 用户[<u><e>{}</e></u>] 触发 [<u><c>{}</c></u>]: {}"
TEMPLATE_E = "群聊[<u><e>{}</e></u>] 用户[<u><e>{}</e></u>] 触发 [<u><c>{}</c></u>] [Target](<u><e>{}</e></u>): {}"
TEMPLATE_USER = "用户[<u><e>{}</e></u>] "
TEMPLATE_GROUP = "群聊[<u><e>{}</e></u>] "
TEMPLATE_COMMAND = "CMD[<u><c>{}</c></u>] "
TEMPLATE_TARGET = "[Target]([<u><e>{}</e></u>]) "
SUCCESS_TEMPLATE = "[<u><c>{}</c></u>]: {} | 参数[{}] 返回: [<y>{}</y>]"
WARNING_TEMPLATE = "[<u><y>{}</y></u>]: {}"
ERROR_TEMPLATE = "[<u><r>{}</r></u>]: {}"
def info(
cls,
info: str,
command: Optional[str] = None,
user_id: Optional[Union[int, str]] = None,
group_id: Optional[Union[int, str]] = None,
target: Optional[Any] = None,
):
template = cls.__parser_template(info, command, user_id, group_id, target)
logger_.opt(colors=True).info(template)
def success(
cls,
info: str,
command: str,
param: Optional[Dict[str, Any]] = None,
result: Optional[str] = "",
):
param_str = ""
if param:
param_str = ",".join([f"<m>{k}</m>:<g>{v}</g>" for k, v in param.items()])
logger_.opt(colors=True).success(
cls.SUCCESS_TEMPLATE.format(command, info, param_str, result)
)
def warning(
cls,
info: str,
command: Optional[str] = None,
user_id: Optional[Union[int, str]] = None,
group_id: Optional[Union[int, str]] = None,
target: Optional[Any] = None,
e: Optional[Exception] = None,
):
template = cls.__parser_template(info, command, user_id, group_id, target)
if e:
template += f" || 错误<r>{type(e)}: {e}</r>"
logger_.opt(colors=True).warning(template)
def error(
cls,
info: str,
command: Optional[str] = None,
user_id: Optional[Union[int, str]] = None,
group_id: Optional[Union[int, str]] = None,
target: Optional[Any] = None,
e: Optional[Exception] = None,
):
template = cls.__parser_template(info, command, user_id, group_id, target)
if e:
template += f" || 错误 <r>{type(e)}: {e}</r>"
logger_.opt(colors=True).error(template)
def debug(
cls,
info: str,
command: Optional[str] = None,
user_id: Optional[Union[int, str]] = None,
group_id: Optional[Union[int, str]] = None,
target: Optional[Any] = None,
e: Optional[Exception] = None,
):
template = cls.__parser_template(info, command, user_id, group_id, target)
if e:
template += f" || 错误 <r>{type(e)}: {e}</r>"
logger_.opt(colors=True).debug(template)
def __parser_template(
cls,
info: str,
command: Optional[str] = None,
user_id: Optional[Union[int, str]] = None,
group_id: Optional[Union[int, str]] = None,
target: Optional[Any] = None,
) -> str:
arg_list = []
template = ""
if group_id is not None:
template += cls.TEMPLATE_GROUP
arg_list.append(group_id)
if user_id is not None:
template += cls.TEMPLATE_USER
arg_list.append(user_id)
if command is not None:
template += cls.TEMPLATE_COMMAND
arg_list.append(command)
if target is not None:
template += cls.TEMPLATE_TARGET
arg_list.append(target)
arg_list.append(info)
template += "{}"
return template.format(*arg_list)
def GetConfig(
module: Optional[str] = None,
config: str = "",
default_value: Any = None,
prompt: Optional[str] = None,
):
"""
说明:
获取配置项
参数:
:param module: 模块名，为空时默认使用当前插件模块名
:param config: 配置项名称
:param default_value: 默认值
:param prompt: 为空时提示
"""
async def dependency(matcher: Matcher):
module_ = module or matcher.plugin_name
if module_:
value = Config.get_config(module_, config, default_value)
if value is None and prompt:
# await matcher.finish(prompt or f"配置项 {config} 未填写！")
await matcher.finish(prompt)
return value
return Depends(dependency)
The provided code snippet includes necessary dependencies for implementing the `CheckNickname` function. Write a Python function `def CheckNickname()` to solve the following problem:
说明: 检查名称是否合法
Here is the function:
def CheckNickname():
"""
说明:
检查名称是否合法
"""
async def dependency(
bot: Bot,
matcher: Matcher,
event: MessageEvent,
reg_group: Tuple[Any, ...] = RegexGroup(),
black_word: Any = GetConfig(config="BLACK_WORD"),
):
(msg,) = reg_group
logger.debug(f"昵称检查: {msg}", "昵称设置", event.user_id)
if not msg:
await matcher.finish("叫你空白？叫你虚空？叫你无名？？", at_sender=True)
if str(event.user_id) in bot.config.superusers:
logger.debug(f"超级用户设置昵称, 跳过合法检测: {msg}", "昵称设置", event.user_id)
return
if len(msg) > 20:
await nickname.finish("昵称可不能超过20个字！", at_sender=True)
if msg in bot.config.nickname:
await nickname.finish("笨蛋！休想占用我的名字！#", at_sender=True)
if black_word:
for x in msg:
if x in black_word:
logger.debug("昵称设置禁止字符: [{x}]", "昵称设置", event.user_id)
await nickname.finish(f"字符 [{x}] 为禁止字符！", at_sender=True)
for word in black_word:
if word in msg:
logger.debug("昵称设置禁止字符: [{word}]", "昵称设置", event.user_id)
await nickname.finish(f"字符 [{word}] 为禁止字符！", at_sender=True)
return Depends(dependency) | 说明: 检查名称是否合法 |
188,123 | import random
from typing import Any, List, Tuple
from nonebot import on_command, on_regex
from nonebot.adapters.onebot.v11 import Bot, GroupMessageEvent, Message, MessageEvent
from nonebot.internal.matcher import Matcher
from nonebot.internal.params import Depends
from nonebot.params import CommandArg, RegexGroup
from nonebot.rule import to_me
from configs.config import NICKNAME
from models.ban_user import BanUser
from models.friend_user import FriendUser
from models.group_member_info import GroupInfoUser
from services.log import logger
from utils.depends import GetConfig
nickname = on_regex(
"(?:以后)?(?:叫我|请叫我|称呼我)(.*)",
rule=to_me(),
priority=5,
block=True,
)
global_nickname = on_regex("设置全局昵称(.*)", rule=to_me(), priority=5, block=True)
class FriendUser(Model):
id = fields.IntField(pk=True, generated=True, auto_increment=True)
"""自增id"""
user_id = fields.CharField(255, unique=True)
"""用户id"""
user_name = fields.CharField(max_length=255, default="")
"""用户名称"""
nickname = fields.CharField(max_length=255, null=True)
"""私聊下自定义昵称"""
class Meta:
table = "friend_users"
table_description = "好友信息数据表"
async def get_user_name(cls, user_id: Union[int, str]) -> str:
"""
说明:
获取好友用户名称
参数:
:param user_id: 用户id
"""
if user := await cls.get_or_none(user_id=str(user_id)):
return user.user_name
return ""
async def get_user_nickname(cls, user_id: Union[int, str]) -> str:
"""
说明:
获取用户昵称
参数:
:param user_id: 用户id
"""
if user := await cls.get_or_none(user_id=str(user_id)):
if user.nickname:
_tmp = ""
if black_word := Config.get_config("nickname", "BLACK_WORD"):
for x in user.nickname:
_tmp += "*" if x in black_word else x
return _tmp
return ""
async def set_user_nickname(cls, user_id: Union[int, str], nickname: str):
"""
说明:
设置用户昵称
参数:
:param user_id: 用户id
:param nickname: 昵称
"""
await cls.update_or_create(user_id=str(user_id), defaults={"nickname": nickname})
async def _run_script(cls):
await cls.raw("ALTER TABLE friend_users ALTER COLUMN user_id TYPE character varying(255);")
# 将user_id字段类型改为character varying(255))
class GroupInfoUser(Model):
id = fields.IntField(pk=True, generated=True, auto_increment=True)
"""自增id"""
user_id = fields.CharField(255)
"""用户id"""
user_name = fields.CharField(255, default="")
"""用户昵称"""
group_id = fields.CharField(255)
"""群聊id"""
user_join_time: datetime = fields.DatetimeField(null=True)
"""用户入群时间"""
nickname = fields.CharField(255, null=True)
"""群聊昵称"""
uid = fields.BigIntField(null=True)
"""用户uid"""
class Meta:
table = "group_info_users"
table_description = "群员信息数据表"
unique_together = ("user_id", "group_id")
async def get_group_member_id_list(cls, group_id: Union[int, str]) -> Set[int]:
"""
说明:
获取该群所有用户id
参数:
:param group_id: 群号
"""
return set(
await cls.filter(group_id=str(group_id)).values_list("user_id", flat=True)
) # type: ignore
async def set_user_nickname(cls, user_id: Union[int, str], group_id: Union[int, str], nickname: str):
"""
说明:
设置群员在该群内的昵称
参数:
:param user_id: 用户id
:param group_id: 群号
:param nickname: 昵称
"""
await cls.update_or_create(
user_id=str(user_id),
group_id=str(group_id),
defaults={"nickname": nickname},
)
async def get_user_all_group(cls, user_id: Union[int, str]) -> List[int]:
"""
说明:
获取该用户所在的所有群聊
参数:
:param user_id: 用户id
"""
return list(
await cls.filter(user_id=str(user_id)).values_list("group_id", flat=True)
) # type: ignore
async def get_user_nickname(cls, user_id: Union[int, str], group_id: Union[int, str]) -> str:
"""
说明:
获取用户在该群的昵称
参数:
:param user_id: 用户id
:param group_id: 群号
"""
if user := await cls.get_or_none(user_id=str(user_id), group_id=str(group_id)):
if user.nickname:
nickname = ""
if black_word := Config.get_config("nickname", "BLACK_WORD"):
for x in user.nickname:
nickname += "*" if x in black_word else x
return nickname
return user.nickname
return ""
async def get_group_member_uid(cls, user_id: Union[int, str], group_id: Union[int, str]) -> Optional[int]:
logger.debug(
f"GroupInfoUser 尝试获取 用户[<u><e>{user_id}</e></u>] 群聊[<u><e>{group_id}</e></u>] UID"
)
user, _ = await cls.get_or_create(user_id=str(user_id), group_id=str(group_id))
_max_uid_user, _ = await cls.get_or_create(user_id="114514", group_id="114514")
_max_uid = _max_uid_user.uid
if not user.uid:
all_user = await cls.filter(user_id=str(user_id)).all()
for x in all_user:
if x.uid:
return x.uid
user.uid = _max_uid + 1
_max_uid_user.uid = _max_uid + 1
await cls.bulk_update([user, _max_uid_user], ["uid"])
logger.debug(
f"GroupInfoUser 获取 用户[<u><e>{user_id}</e></u>] 群聊[<u><e>{group_id}</e></u>] UID: {user.uid}"
)
return user.uid
async def _run_script(cls):
return [
"alter table group_info_users alter user_join_time drop not null;", # 允许 user_join_time 为空
"ALTER TABLE group_info_users ALTER COLUMN user_join_time TYPE timestamp with time zone USING user_join_time::timestamp with time zone;",
"ALTER TABLE group_info_users RENAME COLUMN user_qq TO user_id;", # 将user_id改为user_id
"ALTER TABLE group_info_users ALTER COLUMN user_id TYPE character varying(255);",
# 将user_id字段类型改为character varying(255)
"ALTER TABLE group_info_users ALTER COLUMN group_id TYPE character varying(255);"
]
class logger:
TEMPLATE_A = "{}"
TEMPLATE_B = "[<u><c>{}</c></u>]: {}"
TEMPLATE_C = "用户[<u><e>{}</e></u>] 触发 [<u><c>{}</c></u>]: {}"
TEMPLATE_D = "群聊[<u><e>{}</e></u>] 用户[<u><e>{}</e></u>] 触发 [<u><c>{}</c></u>]: {}"
TEMPLATE_E = "群聊[<u><e>{}</e></u>] 用户[<u><e>{}</e></u>] 触发 [<u><c>{}</c></u>] [Target](<u><e>{}</e></u>): {}"
TEMPLATE_USER = "用户[<u><e>{}</e></u>] "
TEMPLATE_GROUP = "群聊[<u><e>{}</e></u>] "
TEMPLATE_COMMAND = "CMD[<u><c>{}</c></u>] "
TEMPLATE_TARGET = "[Target]([<u><e>{}</e></u>]) "
SUCCESS_TEMPLATE = "[<u><c>{}</c></u>]: {} | 参数[{}] 返回: [<y>{}</y>]"
WARNING_TEMPLATE = "[<u><y>{}</y></u>]: {}"
ERROR_TEMPLATE = "[<u><r>{}</r></u>]: {}"
def info(
cls,
info: str,
command: Optional[str] = None,
user_id: Optional[Union[int, str]] = None,
group_id: Optional[Union[int, str]] = None,
target: Optional[Any] = None,
):
template = cls.__parser_template(info, command, user_id, group_id, target)
logger_.opt(colors=True).info(template)
def success(
cls,
info: str,
command: str,
param: Optional[Dict[str, Any]] = None,
result: Optional[str] = "",
):
param_str = ""
if param:
param_str = ",".join([f"<m>{k}</m>:<g>{v}</g>" for k, v in param.items()])
logger_.opt(colors=True).success(
cls.SUCCESS_TEMPLATE.format(command, info, param_str, result)
)
def warning(
cls,
info: str,
command: Optional[str] = None,
user_id: Optional[Union[int, str]] = None,
group_id: Optional[Union[int, str]] = None,
target: Optional[Any] = None,
e: Optional[Exception] = None,
):
template = cls.__parser_template(info, command, user_id, group_id, target)
if e:
template += f" || 错误<r>{type(e)}: {e}</r>"
logger_.opt(colors=True).warning(template)
def error(
cls,
info: str,
command: Optional[str] = None,
user_id: Optional[Union[int, str]] = None,
group_id: Optional[Union[int, str]] = None,
target: Optional[Any] = None,
e: Optional[Exception] = None,
):
template = cls.__parser_template(info, command, user_id, group_id, target)
if e:
template += f" || 错误 <r>{type(e)}: {e}</r>"
logger_.opt(colors=True).error(template)
def debug(
cls,
info: str,
command: Optional[str] = None,
user_id: Optional[Union[int, str]] = None,
group_id: Optional[Union[int, str]] = None,
target: Optional[Any] = None,
e: Optional[Exception] = None,
):
template = cls.__parser_template(info, command, user_id, group_id, target)
if e:
template += f" || 错误 <r>{type(e)}: {e}</r>"
logger_.opt(colors=True).debug(template)
def __parser_template(
cls,
info: str,
command: Optional[str] = None,
user_id: Optional[Union[int, str]] = None,
group_id: Optional[Union[int, str]] = None,
target: Optional[Any] = None,
) -> str:
arg_list = []
template = ""
if group_id is not None:
template += cls.TEMPLATE_GROUP
arg_list.append(group_id)
if user_id is not None:
template += cls.TEMPLATE_USER
arg_list.append(user_id)
if command is not None:
template += cls.TEMPLATE_COMMAND
arg_list.append(command)
if target is not None:
template += cls.TEMPLATE_TARGET
arg_list.append(target)
arg_list.append(info)
template += "{}"
return template.format(*arg_list)
async def _(
event: MessageEvent,
reg_group: Tuple[Any, ...] = RegexGroup(),
):
(msg,) = reg_group
await FriendUser.set_user_nickname(event.user_id, msg)
await GroupInfoUser.filter(user_id=str(event.user_id)).update(nickname=msg)
logger.info(f"设置全局昵称成功: {msg}", "设置全局昵称", event.user_id)
await global_nickname.send(f"设置全局昵称成功！亲爱的{msg}") | null |
188,124 | import random
from typing import Any, List, Tuple
from nonebot import on_command, on_regex
from nonebot.adapters.onebot.v11 import Bot, GroupMessageEvent, Message, MessageEvent
from nonebot.internal.matcher import Matcher
from nonebot.internal.params import Depends
from nonebot.params import CommandArg, RegexGroup
from nonebot.rule import to_me
from configs.config import NICKNAME
from models.ban_user import BanUser
from models.friend_user import FriendUser
from models.group_member_info import GroupInfoUser
from services.log import logger
from utils.depends import GetConfig
nickname = on_regex(
"(?:以后)?(?:叫我|请叫我|称呼我)(.*)",
rule=to_me(),
priority=5,
block=True,
)
class FriendUser(Model):
id = fields.IntField(pk=True, generated=True, auto_increment=True)
"""自增id"""
user_id = fields.CharField(255, unique=True)
"""用户id"""
user_name = fields.CharField(max_length=255, default="")
"""用户名称"""
nickname = fields.CharField(max_length=255, null=True)
"""私聊下自定义昵称"""
class Meta:
table = "friend_users"
table_description = "好友信息数据表"
async def get_user_name(cls, user_id: Union[int, str]) -> str:
"""
说明:
获取好友用户名称
参数:
:param user_id: 用户id
"""
if user := await cls.get_or_none(user_id=str(user_id)):
return user.user_name
return ""
async def get_user_nickname(cls, user_id: Union[int, str]) -> str:
"""
说明:
获取用户昵称
参数:
:param user_id: 用户id
"""
if user := await cls.get_or_none(user_id=str(user_id)):
if user.nickname:
_tmp = ""
if black_word := Config.get_config("nickname", "BLACK_WORD"):
for x in user.nickname:
_tmp += "*" if x in black_word else x
return _tmp
return ""
async def set_user_nickname(cls, user_id: Union[int, str], nickname: str):
"""
说明:
设置用户昵称
参数:
:param user_id: 用户id
:param nickname: 昵称
"""
await cls.update_or_create(user_id=str(user_id), defaults={"nickname": nickname})
async def _run_script(cls):
await cls.raw("ALTER TABLE friend_users ALTER COLUMN user_id TYPE character varying(255);")
# 将user_id字段类型改为character varying(255))
class GroupInfoUser(Model):
id = fields.IntField(pk=True, generated=True, auto_increment=True)
"""自增id"""
user_id = fields.CharField(255)
"""用户id"""
user_name = fields.CharField(255, default="")
"""用户昵称"""
group_id = fields.CharField(255)
"""群聊id"""
user_join_time: datetime = fields.DatetimeField(null=True)
"""用户入群时间"""
nickname = fields.CharField(255, null=True)
"""群聊昵称"""
uid = fields.BigIntField(null=True)
"""用户uid"""
class Meta:
table = "group_info_users"
table_description = "群员信息数据表"
unique_together = ("user_id", "group_id")
async def get_group_member_id_list(cls, group_id: Union[int, str]) -> Set[int]:
"""
说明:
获取该群所有用户id
参数:
:param group_id: 群号
"""
return set(
await cls.filter(group_id=str(group_id)).values_list("user_id", flat=True)
) # type: ignore
async def set_user_nickname(cls, user_id: Union[int, str], group_id: Union[int, str], nickname: str):
"""
说明:
设置群员在该群内的昵称
参数:
:param user_id: 用户id
:param group_id: 群号
:param nickname: 昵称
"""
await cls.update_or_create(
user_id=str(user_id),
group_id=str(group_id),
defaults={"nickname": nickname},
)
async def get_user_all_group(cls, user_id: Union[int, str]) -> List[int]:
"""
说明:
获取该用户所在的所有群聊
参数:
:param user_id: 用户id
"""
return list(
await cls.filter(user_id=str(user_id)).values_list("group_id", flat=True)
) # type: ignore
async def get_user_nickname(cls, user_id: Union[int, str], group_id: Union[int, str]) -> str:
"""
说明:
获取用户在该群的昵称
参数:
:param user_id: 用户id
:param group_id: 群号
"""
if user := await cls.get_or_none(user_id=str(user_id), group_id=str(group_id)):
if user.nickname:
nickname = ""
if black_word := Config.get_config("nickname", "BLACK_WORD"):
for x in user.nickname:
nickname += "*" if x in black_word else x
return nickname
return user.nickname
return ""
async def get_group_member_uid(cls, user_id: Union[int, str], group_id: Union[int, str]) -> Optional[int]:
logger.debug(
f"GroupInfoUser 尝试获取 用户[<u><e>{user_id}</e></u>] 群聊[<u><e>{group_id}</e></u>] UID"
)
user, _ = await cls.get_or_create(user_id=str(user_id), group_id=str(group_id))
_max_uid_user, _ = await cls.get_or_create(user_id="114514", group_id="114514")
_max_uid = _max_uid_user.uid
if not user.uid:
all_user = await cls.filter(user_id=str(user_id)).all()
for x in all_user:
if x.uid:
return x.uid
user.uid = _max_uid + 1
_max_uid_user.uid = _max_uid + 1
await cls.bulk_update([user, _max_uid_user], ["uid"])
logger.debug(
f"GroupInfoUser 获取 用户[<u><e>{user_id}</e></u>] 群聊[<u><e>{group_id}</e></u>] UID: {user.uid}"
)
return user.uid
async def _run_script(cls):
return [
"alter table group_info_users alter user_join_time drop not null;", # 允许 user_join_time 为空
"ALTER TABLE group_info_users ALTER COLUMN user_join_time TYPE timestamp with time zone USING user_join_time::timestamp with time zone;",
"ALTER TABLE group_info_users RENAME COLUMN user_qq TO user_id;", # 将user_id改为user_id
"ALTER TABLE group_info_users ALTER COLUMN user_id TYPE character varying(255);",
# 将user_id字段类型改为character varying(255)
"ALTER TABLE group_info_users ALTER COLUMN group_id TYPE character varying(255);"
]
class logger:
TEMPLATE_A = "{}"
TEMPLATE_B = "[<u><c>{}</c></u>]: {}"
TEMPLATE_C = "用户[<u><e>{}</e></u>] 触发 [<u><c>{}</c></u>]: {}"
TEMPLATE_D = "群聊[<u><e>{}</e></u>] 用户[<u><e>{}</e></u>] 触发 [<u><c>{}</c></u>]: {}"
TEMPLATE_E = "群聊[<u><e>{}</e></u>] 用户[<u><e>{}</e></u>] 触发 [<u><c>{}</c></u>] [Target](<u><e>{}</e></u>): {}"
TEMPLATE_USER = "用户[<u><e>{}</e></u>] "
TEMPLATE_GROUP = "群聊[<u><e>{}</e></u>] "
TEMPLATE_COMMAND = "CMD[<u><c>{}</c></u>] "
TEMPLATE_TARGET = "[Target]([<u><e>{}</e></u>]) "
SUCCESS_TEMPLATE = "[<u><c>{}</c></u>]: {} | 参数[{}] 返回: [<y>{}</y>]"
WARNING_TEMPLATE = "[<u><y>{}</y></u>]: {}"
ERROR_TEMPLATE = "[<u><r>{}</r></u>]: {}"
def info(
cls,
info: str,
command: Optional[str] = None,
user_id: Optional[Union[int, str]] = None,
group_id: Optional[Union[int, str]] = None,
target: Optional[Any] = None,
):
template = cls.__parser_template(info, command, user_id, group_id, target)
logger_.opt(colors=True).info(template)
def success(
cls,
info: str,
command: str,
param: Optional[Dict[str, Any]] = None,
result: Optional[str] = "",
):
param_str = ""
if param:
param_str = ",".join([f"<m>{k}</m>:<g>{v}</g>" for k, v in param.items()])
logger_.opt(colors=True).success(
cls.SUCCESS_TEMPLATE.format(command, info, param_str, result)
)
def warning(
cls,
info: str,
command: Optional[str] = None,
user_id: Optional[Union[int, str]] = None,
group_id: Optional[Union[int, str]] = None,
target: Optional[Any] = None,
e: Optional[Exception] = None,
):
template = cls.__parser_template(info, command, user_id, group_id, target)
if e:
template += f" || 错误<r>{type(e)}: {e}</r>"
logger_.opt(colors=True).warning(template)
def error(
cls,
info: str,
command: Optional[str] = None,
user_id: Optional[Union[int, str]] = None,
group_id: Optional[Union[int, str]] = None,
target: Optional[Any] = None,
e: Optional[Exception] = None,
):
template = cls.__parser_template(info, command, user_id, group_id, target)
if e:
template += f" || 错误 <r>{type(e)}: {e}</r>"
logger_.opt(colors=True).error(template)
def debug(
cls,
info: str,
command: Optional[str] = None,
user_id: Optional[Union[int, str]] = None,
group_id: Optional[Union[int, str]] = None,
target: Optional[Any] = None,
e: Optional[Exception] = None,
):
template = cls.__parser_template(info, command, user_id, group_id, target)
if e:
template += f" || 错误 <r>{type(e)}: {e}</r>"
logger_.opt(colors=True).debug(template)
def __parser_template(
cls,
info: str,
command: Optional[str] = None,
user_id: Optional[Union[int, str]] = None,
group_id: Optional[Union[int, str]] = None,
target: Optional[Any] = None,
) -> str:
arg_list = []
template = ""
if group_id is not None:
template += cls.TEMPLATE_GROUP
arg_list.append(group_id)
if user_id is not None:
template += cls.TEMPLATE_USER
arg_list.append(user_id)
if command is not None:
template += cls.TEMPLATE_COMMAND
arg_list.append(command)
if target is not None:
template += cls.TEMPLATE_TARGET
arg_list.append(target)
arg_list.append(info)
template += "{}"
return template.format(*arg_list)
async def _(
event: MessageEvent,
reg_group: Tuple[Any, ...] = RegexGroup(),
):
(msg,) = reg_group
if isinstance(event, GroupMessageEvent):
await GroupInfoUser.set_user_nickname(event.user_id, event.group_id, msg)
if len(msg) < 5:
if random.random() < 0.3:
msg = "~".join(msg)
await nickname.send(
random.choice(
[
f"好啦好啦，我知道啦，{msg}，以后就这么叫你吧",
f"嗯嗯，{NICKNAME}记住你的昵称了哦，{msg}",
f"好突然，突然要叫你昵称什么的...{msg}..",
f"{NICKNAME}会好好记住{msg}的，放心吧",
f"好..好.，那窝以后就叫你{msg}了.",
]
)
)
logger.info(f"设置群昵称成功: {msg}", "昵称设置", event.user_id, event.group_id)
else:
await FriendUser.set_user_nickname(event.user_id, msg)
await nickname.send(
random.choice(
[
f"好啦好啦，我知道啦，{msg}，以后就这么叫你吧",
f"嗯嗯，{NICKNAME}记住你的昵称了哦，{msg}",
f"好突然，突然要叫你昵称什么的...{msg}..",
f"{NICKNAME}会好好记住{msg}的，放心吧",
f"好..好.，那窝以后就叫你{msg}了.",
]
)
)
logger.info(f"设置私聊昵称成功: {msg}", "昵称设置", event.user_id) | null |
188,125 | import random
from typing import Any, List, Tuple
from nonebot import on_command, on_regex
from nonebot.adapters.onebot.v11 import Bot, GroupMessageEvent, Message, MessageEvent
from nonebot.internal.matcher import Matcher
from nonebot.internal.params import Depends
from nonebot.params import CommandArg, RegexGroup
from nonebot.rule import to_me
from configs.config import NICKNAME
from models.ban_user import BanUser
from models.friend_user import FriendUser
from models.group_member_info import GroupInfoUser
from services.log import logger
from utils.depends import GetConfig
nickname = on_regex(
"(?:以后)?(?:叫我|请叫我|称呼我)(.*)",
rule=to_me(),
priority=5,
block=True,
)
my_nickname = on_command(
"我叫什么", aliases={"我是谁", "我的名字"}, rule=to_me(), priority=5, block=True
)
class FriendUser(Model):
async def get_user_name(cls, user_id: Union[int, str]) -> str:
async def get_user_nickname(cls, user_id: Union[int, str]) -> str:
async def set_user_nickname(cls, user_id: Union[int, str], nickname: str):
async def _run_script(cls):
class GroupInfoUser(Model):
async def get_group_member_id_list(cls, group_id: Union[int, str]) -> Set[int]:
async def set_user_nickname(cls, user_id: Union[int, str], group_id: Union[int, str], nickname: str):
async def get_user_all_group(cls, user_id: Union[int, str]) -> List[int]:
async def get_user_nickname(cls, user_id: Union[int, str], group_id: Union[int, str]) -> str:
async def get_group_member_uid(cls, user_id: Union[int, str], group_id: Union[int, str]) -> Optional[int]:
async def _run_script(cls):
async def _(event: MessageEvent):
nickname_ = None
card = None
if isinstance(event, GroupMessageEvent):
nickname_ = await GroupInfoUser.get_user_nickname(event.user_id, event.group_id)
card = event.sender.card or event.sender.nickname
else:
nickname_ = await FriendUser.get_user_nickname(event.user_id)
card = event.sender.nickname
if nickname_:
await my_nickname.send(
random.choice(
[
f"我肯定记得你啊，你是{nickname_}啊",
f"我不会忘记你的，你也不要忘记我！{nickname_}",
f"哼哼，{NICKNAME}记忆力可是很好的，{nickname_}",
f"嗯？你是失忆了嘛...{nickname_}..",
f"不要小看{NICKNAME}的记忆力啊！笨蛋{nickname_}！QAQ",
f"哎？{nickname_}..怎么了吗..突然这样问..",
]
)
)
else:
await my_nickname.send(
random.choice(
["没..没有昵称嘛，{}", "啊，你是{}啊，我想叫你的昵称！", "是{}啊，有什么事吗？", "你是{}？"]
).format(card)
) | null |
188,126 | import random
from typing import Any, List, Tuple
from nonebot import on_command, on_regex
from nonebot.adapters.onebot.v11 import Bot, GroupMessageEvent, Message, MessageEvent
from nonebot.internal.matcher import Matcher
from nonebot.internal.params import Depends
from nonebot.params import CommandArg, RegexGroup
from nonebot.rule import to_me
from configs.config import NICKNAME
from models.ban_user import BanUser
from models.friend_user import FriendUser
from models.group_member_info import GroupInfoUser
from services.log import logger
from utils.depends import GetConfig
ckname = on_command("取消昵称", rule=to_me(), priority=5, block=True)
class BanUser(Model):
async def check_ban_level(cls, user_id: Union[int, str], level: int) -> bool:
async def check_ban_time(cls, user_id: Union[int, str]) -> Union[str, int]:
async def is_ban(cls, user_id: Union[int, str]) -> bool:
async def is_super_ban(cls, user_id: Union[int, str]) -> bool:
async def ban(cls, user_id: Union[int, str], ban_level: int, duration: int):
async def unban(cls, user_id: Union[int, str]) -> bool:
async def _run_script(cls):
class FriendUser(Model):
async def get_user_name(cls, user_id: Union[int, str]) -> str:
async def get_user_nickname(cls, user_id: Union[int, str]) -> str:
async def set_user_nickname(cls, user_id: Union[int, str], nickname: str):
async def _run_script(cls):
class GroupInfoUser(Model):
async def get_group_member_id_list(cls, group_id: Union[int, str]) -> Set[int]:
async def set_user_nickname(cls, user_id: Union[int, str], group_id: Union[int, str], nickname: str):
async def get_user_all_group(cls, user_id: Union[int, str]) -> List[int]:
async def get_user_nickname(cls, user_id: Union[int, str], group_id: Union[int, str]) -> str:
async def get_group_member_uid(cls, user_id: Union[int, str], group_id: Union[int, str]) -> Optional[int]:
async def _run_script(cls):
async def _(event: MessageEvent):
nickname_ = None
if isinstance(event, GroupMessageEvent):
nickname_ = await GroupInfoUser.get_user_nickname(event.user_id, event.group_id)
else:
nickname_ = await FriendUser.get_user_nickname(event.user_id)
if nickname_:
await cancel_nickname.send(
random.choice(
[
f"呜..{NICKNAME}睡一觉就会忘记的..和梦一样..{nickname_}",
f"窝知道了..{nickname_}..",
f"是{NICKNAME}哪里做的不好嘛..好吧..晚安{nickname_}",
f"呃，{nickname_}，下次我绝对绝对绝对不会再忘记你！",
f"可..可恶！{nickname_}！太可恶了！呜",
]
)
)
if isinstance(event, GroupMessageEvent):
await GroupInfoUser.set_user_nickname(event.user_id, event.group_id, "")
else:
await FriendUser.set_user_nickname(event.user_id, "")
await BanUser.ban(event.user_id, 9, 60)
else:
await cancel_nickname.send("你在做梦吗？你没有昵称啊", at_sender=True) | null |
188,127 | import time
from nonebot.adapters.onebot.v11 import (
Bot,
Event,
GroupMessageEvent,
Message,
MessageEvent,
PokeNotifyEvent,
PrivateMessageEvent,
)
from nonebot.exception import ActionFailed, IgnoredException
from nonebot.internal.matcher import Matcher
from configs.config import Config
from models.bag_user import BagUser
from models.ban_user import BanUser
from models.friend_user import FriendUser
from models.group_member_info import GroupInfoUser
from models.level_user import LevelUser
from models.user_shop_gold_log import UserShopGoldLog
from services.log import logger
from utils.decorator import Singleton
from utils.manager import (
StaticData,
admin_manager,
group_manager,
plugin_data_manager,
plugins2block_manager,
plugins2cd_manager,
plugins2count_manager,
plugins2settings_manager,
plugins_manager,
)
from utils.manager.models import PluginType
from utils.message_builder import at
from utils.utils import FreqLimiter
status_message_manager = StatusMessageManager()
class FriendUser(Model):
id = fields.IntField(pk=True, generated=True, auto_increment=True)
"""自增id"""
user_id = fields.CharField(255, unique=True)
"""用户id"""
user_name = fields.CharField(max_length=255, default="")
"""用户名称"""
nickname = fields.CharField(max_length=255, null=True)
"""私聊下自定义昵称"""
class Meta:
table = "friend_users"
table_description = "好友信息数据表"
async def get_user_name(cls, user_id: Union[int, str]) -> str:
"""
说明:
获取好友用户名称
参数:
:param user_id: 用户id
"""
if user := await cls.get_or_none(user_id=str(user_id)):
return user.user_name
return ""
async def get_user_nickname(cls, user_id: Union[int, str]) -> str:
"""
说明:
获取用户昵称
参数:
:param user_id: 用户id
"""
if user := await cls.get_or_none(user_id=str(user_id)):
if user.nickname:
_tmp = ""
if black_word := Config.get_config("nickname", "BLACK_WORD"):
for x in user.nickname:
_tmp += "*" if x in black_word else x
return _tmp
return ""
async def set_user_nickname(cls, user_id: Union[int, str], nickname: str):
"""
说明:
设置用户昵称
参数:
:param user_id: 用户id
:param nickname: 昵称
"""
await cls.update_or_create(user_id=str(user_id), defaults={"nickname": nickname})
async def _run_script(cls):
await cls.raw("ALTER TABLE friend_users ALTER COLUMN user_id TYPE character varying(255);")
# 将user_id字段类型改为character varying(255))
class GroupInfoUser(Model):
id = fields.IntField(pk=True, generated=True, auto_increment=True)
"""自增id"""
user_id = fields.CharField(255)
"""用户id"""
user_name = fields.CharField(255, default="")
"""用户昵称"""
group_id = fields.CharField(255)
"""群聊id"""
user_join_time: datetime = fields.DatetimeField(null=True)
"""用户入群时间"""
nickname = fields.CharField(255, null=True)
"""群聊昵称"""
uid = fields.BigIntField(null=True)
"""用户uid"""
class Meta:
table = "group_info_users"
table_description = "群员信息数据表"
unique_together = ("user_id", "group_id")
async def get_group_member_id_list(cls, group_id: Union[int, str]) -> Set[int]:
"""
说明:
获取该群所有用户id
参数:
:param group_id: 群号
"""
return set(
await cls.filter(group_id=str(group_id)).values_list("user_id", flat=True)
) # type: ignore
async def set_user_nickname(cls, user_id: Union[int, str], group_id: Union[int, str], nickname: str):
"""
说明:
设置群员在该群内的昵称
参数:
:param user_id: 用户id
:param group_id: 群号
:param nickname: 昵称
"""
await cls.update_or_create(
user_id=str(user_id),
group_id=str(group_id),
defaults={"nickname": nickname},
)
async def get_user_all_group(cls, user_id: Union[int, str]) -> List[int]:
"""
说明:
获取该用户所在的所有群聊
参数:
:param user_id: 用户id
"""
return list(
await cls.filter(user_id=str(user_id)).values_list("group_id", flat=True)
) # type: ignore
async def get_user_nickname(cls, user_id: Union[int, str], group_id: Union[int, str]) -> str:
"""
说明:
获取用户在该群的昵称
参数:
:param user_id: 用户id
:param group_id: 群号
"""
if user := await cls.get_or_none(user_id=str(user_id), group_id=str(group_id)):
if user.nickname:
nickname = ""
if black_word := Config.get_config("nickname", "BLACK_WORD"):
for x in user.nickname:
nickname += "*" if x in black_word else x
return nickname
return user.nickname
return ""
async def get_group_member_uid(cls, user_id: Union[int, str], group_id: Union[int, str]) -> Optional[int]:
logger.debug(
f"GroupInfoUser 尝试获取 用户[<u><e>{user_id}</e></u>] 群聊[<u><e>{group_id}</e></u>] UID"
)
user, _ = await cls.get_or_create(user_id=str(user_id), group_id=str(group_id))
_max_uid_user, _ = await cls.get_or_create(user_id="114514", group_id="114514")
_max_uid = _max_uid_user.uid
if not user.uid:
all_user = await cls.filter(user_id=str(user_id)).all()
for x in all_user:
if x.uid:
return x.uid
user.uid = _max_uid + 1
_max_uid_user.uid = _max_uid + 1
await cls.bulk_update([user, _max_uid_user], ["uid"])
logger.debug(
f"GroupInfoUser 获取 用户[<u><e>{user_id}</e></u>] 群聊[<u><e>{group_id}</e></u>] UID: {user.uid}"
)
return user.uid
async def _run_script(cls):
return [
"alter table group_info_users alter user_join_time drop not null;", # 允许 user_join_time 为空
"ALTER TABLE group_info_users ALTER COLUMN user_join_time TYPE timestamp with time zone USING user_join_time::timestamp with time zone;",
"ALTER TABLE group_info_users RENAME COLUMN user_qq TO user_id;", # 将user_id改为user_id
"ALTER TABLE group_info_users ALTER COLUMN user_id TYPE character varying(255);",
# 将user_id字段类型改为character varying(255)
"ALTER TABLE group_info_users ALTER COLUMN group_id TYPE character varying(255);"
]
def at(qq: Union[int, str]) -> MessageSegment:
"""
说明:
生成一个 MessageSegment.at 消息
参数:
:param qq: qq号
"""
return MessageSegment.at(qq)
The provided code snippet includes necessary dependencies for implementing the `send_msg` function. Write a Python function `async def send_msg(msg: str, bot: Bot, event: MessageEvent)` to solve the following problem:
说明: 发送信息 参数: :param msg: pass :param bot: pass :param event: pass
Here is the function:
async def send_msg(msg: str, bot: Bot, event: MessageEvent):
"""
说明:
发送信息
参数:
:param msg: pass
:param bot: pass
:param event: pass
"""
if "[uname]" in msg:
uname = event.sender.card or event.sender.nickname or ""
msg = msg.replace("[uname]", uname)
if "[nickname]" in msg:
if isinstance(event, GroupMessageEvent):
nickname = await GroupInfoUser.get_user_nickname(
event.user_id, event.group_id
)
else:
nickname = await FriendUser.get_user_nickname(event.user_id)
msg = msg.replace("[nickname]", nickname)
if "[at]" in msg and isinstance(event, GroupMessageEvent):
msg = msg.replace("[at]", str(at(event.user_id)))
try:
if isinstance(event, GroupMessageEvent):
status_message_manager.add(event.group_id)
await bot.send_group_msg(group_id=event.group_id, message=Message(msg))
else:
status_message_manager.add(event.user_id)
await bot.send_private_msg(user_id=event.user_id, message=Message(msg))
except ActionFailed:
pass | 说明: 发送信息 参数: :param msg: pass :param bot: pass :param event: pass |
188,128 | import asyncio
from typing import Optional
from nonebot.adapters.onebot.v11 import Bot, Event
from nonebot.matcher import Matcher
from nonebot.message import run_postprocessor
from nonebot.typing import T_State
from services.log import logger
from utils.manager import withdraw_message_manager
async def _withdraw_message(bot: Bot, id_: int, time: int):
await asyncio.sleep(time)
logger.debug(f"撤回消息ID: {id_}", "HOOK")
await bot.delete_msg(message_id=id_)
async def _(
matcher: Matcher,
exception: Optional[Exception],
bot: Bot,
event: Event,
state: T_State,
):
tasks = []
for id_, time in withdraw_message_manager.data:
tasks.append(asyncio.ensure_future(_withdraw_message(bot, id_, time)))
withdraw_message_manager.remove((id_, time))
await asyncio.gather(*tasks) | null |
188,129 | from nonebot.matcher import Matcher
from nonebot.message import run_preprocessor, IgnoredException
from nonebot.typing import T_State
from ._utils import status_message_manager
from nonebot.adapters.onebot.v11 import (
Bot,
MessageEvent,
PrivateMessageEvent,
GroupMessageEvent,
)
async def _(matcher: Matcher, bot: Bot, event: PrivateMessageEvent, state: T_State):
if not isinstance(event, MessageEvent):
return
if event.user_id == int(bot.self_id):
raise IgnoredException("为什么AI会自己和自己聊天") | null |
188,130 | from nonebot.matcher import Matcher
from nonebot.message import run_preprocessor, IgnoredException
from nonebot.typing import T_State
from ._utils import status_message_manager
from nonebot.adapters.onebot.v11 import (
Bot,
MessageEvent,
PrivateMessageEvent,
GroupMessageEvent,
)
status_message_manager = StatusMessageManager()
async def _(matcher: Matcher, bot: Bot, event: MessageEvent, state: T_State):
if not isinstance(event, MessageEvent):
return
if matcher.type == "message" and matcher.plugin_name == "ai":
if (
isinstance(event, GroupMessageEvent)
and not status_message_manager.check(event.group_id)
):
status_message_manager.delete(event.group_id)
raise IgnoredException("有命令就别说话了")
elif (
isinstance(event, PrivateMessageEvent)
and not status_message_manager.check(event.user_id)
):
status_message_manager.delete(event.user_id)
raise IgnoredException("有命令就别说话了") | null |
Subsets and Splits