def main():
bot = Bot(cache_path=True, console_qr=2)
bot.enable_puid('wxpy_puid.pkl')
# 在 Web 微信中把自己加为好友
# bot.self.add()
# bot.self.accept()
mygroup = bot.groups().search(group_name)[0]
myfriend = bot.friends().search(u'明月')[0]
@bot.register(mygroup)
def print_group(msg):
# msg.forward(myfriend)
if msg.type == TEXT:
# print msg
username = msg.member.name
en_from = msg.text.encode('utf-8')
print '收到消息:', en_from
if not isCN(en_from):
cn_from = bd_translate(en_from, 'en', 'zh')
cn_chatbot = xiaoi_chatbot(cn_from, username)
cn_chatbot = cn_chatbot.replace('\n', ' ')
en_chatbot = bd_translate(cn_chatbot, 'zh', 'en')
# print '翻译结果:', en_chatbot
save_record(username, en_from, cn_from, cn_chatbot, en_chatbot)
return en_chatbot + '\n' + '(翻译:' + cn_chatbot + ')'
bot.join()
class MyThread(QtCore.QThread):
_signal_1 = QtCore.pyqtSignal(bool, str,
int) # 定义信号，用于记录聊天信息，含：是否群聊，消息内容，消息时间
_signal_2 = QtCore.pyqtSignal(str) # 定义信号，仅用于传出用户名
_signal_3 = QtCore.pyqtSignal(str) # 定义信号，用于记录远控信息
_signal_4 = QtCore.pyqtSignal(list) # 定义信号，用于记录好友列表
_signal_5 = QtCore.pyqtSignal(list) # 定义信号，用于记录群聊列表
_signal_6 = QtCore.pyqtSignal(str) # 定义信号，用于截图
def __int__(self, parent=None):
super(MyThread, self).__init__()
def run(self):
self.bot = Bot(cache_path=True)
self.myself = self.bot.self
self._signal_2.emit(self.myself.name)
self.get_friendslist()
self.get_chatroomslist()
############################
# 处理接收到的微信消息
############################
# @self.bot.register(msg_types=TEXT,except_self=False)
# def just_print(msg):
# print(msg)
# 私聊信息，文字
@self.bot.register(msg_types=TEXT, except_self=False)
def get_msg(msg):
fromChatroom = False
#print(msg)
if msg.sender.name == self.myself.name:
# 这是我发出的消息
from_Name = '我'
if msg.receiver.name == '文件传输助手':
to_Name = '助手'
if '#' in msg.text and myshow.remote_pc == True: # 执行命令条件：1发给助手 2命令中带井号 3远控开启
do_what = msg.text.split('#')[1] # 以#分割，取第二个元素，即：具体指令。
self.wechat_do(do_what) # 调用微信远控的方法
else:
to_Name = msg.chat.name
elif msg.receiver.name == self.myself.name:
# 这是别人发给我的
to_Name = '我'
if msg.sender.name == '文件传输助手':
from_Name = '助手'
else:
from_Name = msg.chat.name
# 自动回复
if myshow.reply_busy == True: # 忙碌回复
msg_busy = myshow.lineEdit_busy.text()
msg.reply('[自动回复] %s' % msg_busy)
if myshow.reply_robot == True: # 机器人回复
myshow.tuling.do_reply(msg) # 调用图灵机器人回复
message = from_Name + '→' + to_Name + '：' + msg.text
msg_time = msg.create_time
#print(msg_time,type(msg_time),str(msg_time)) # wxpy的时间格式是datetime
send_time = time.mktime(msg_time.timetuple()) #datetime转时间戳
self._signal_1.emit(fromChatroom, message,
send_time) # 信号焕发，连接 write_log
# 私聊信息，图片、视频等
@self.bot.register(chats=User,
msg_types=[PICTURE, RECORDING, ATTACHMENT, VIDEO])
def download_files(msg):
#print(msg)
fromChatroom = False
if msg.sender.name == self.myself.name:
# 这是我发出的消息
from_Name = '我'
if msg.receiver.name == '文件传输助手':
to_Name = '助手'
else:
to_Name = msg.chat.name
elif msg.receiver.name == self.myself.name:
# 这是别人发给我的
to_Name = '我'
if msg.sender.name == '文件传输助手':
from_Name = '助手'
else:
from_Name = msg.chat.name
# 自动回复
if myshow.reply_busy == True:
msg_busy = myshow.lineEdit_busy.text()
msg.reply('[自动回复] %s' % msg_busy)
if myshow.reply_robot == True: # 机器人回复
myshow.tuling.do_reply(msg)
# 新建接收文件夹
downloadDir = '接收文件'
if not os.path.exists(downloadDir): # 目录如果不存在
os.makedirs(downloadDir)
workPath = os.getcwd() # 当前程序工作的路径
downloadPath = os.path.join(workPath, downloadDir) # 接收文件的路径
os.chdir(downloadPath) # 改变当前工作目录
msg.get_file(msg.file_name) # 下载文件
os.chdir(workPath)
message = from_Name + '→' + to_Name + '：' + '[文件: %s]' % msg.file_name
msg_time = msg.create_time
send_time = time.mktime(msg_time.timetuple()) #datetime转时间戳
self._signal_1.emit(fromChatroom, message,
send_time) # 信号焕发，连接 write_log
# 群聊信息,@我的文字信息
@self.bot.register(chats=Group, msg_types=TEXT)
def get_msg_at(msg):
#print(msg)
if msg.is_at:
#print(msg.member.name)
if myshow.reply_busy == True:
msg_busy = myshow.lineEdit_busy.text()
msg.reply(u'@%s\u2005[自动回复] %s' %
(msg.member.nick_name, msg_busy))
if myshow.reply_robot == True:
myshow.tuling.do_reply(msg)
from_Name = msg.member.name # 成员名
chatroom_NickName = msg.chat.name #群聊名
fromChatroom = True
message = '[' + chatroom_NickName + '] ' + from_Name + ' ：' + msg.text
msg_time = msg.create_time
send_time = time.mktime(msg_time.timetuple())
self._signal_1.emit(fromChatroom, message,
send_time) # 信号焕发，连接 write_log
self.bot.join() # 堵塞线程，这里不要用embed()，否则pyinstaller打包无窗口会报错
# 获取好友列表
def get_friendslist(self):
friends_info = self.bot.friends(update=False)
frinends_list = [friend.name for friend in friends_info
] # 好友列表 ['张三','Mango','李四']
frinends_pinyin = [
''.join(lazy_pinyin(frinend)) for frinend in frinends_list
] # 根据好友列表生成拼音列表 ['zhangsan','Mango','lisi']
dict1 = dict(
zip(frinends_pinyin, frinends_list)
) # 拼音列表和昵称列表并成字典 {'zhangsan':'张三','Mango':'Mango','lisi':'李四'}
sort1 = sorted(dict1.items(), key=lambda x: x[0].lower(
)) # 转小写拼音排序 [('lisi','李四'),('Mango','Mango'),('zhangsan','张三')]
friends_sorted = [i[1] for i in sort1] # ['李四','Mango','张三']
self._signal_4.emit(friends_sorted)
#获取群聊列表
def get_chatroomslist(self):
chatrooms_info = self.bot.groups(update=False)
chatrooms_list = [chatroom.name for chatroom in chatrooms_info]
self._signal_5.emit(chatrooms_list)
#######################################
# 微信远程控制
#######################################
def wechat_do(self, do_what):
'''判断并执行具体指令，格式为：命令@参数'''
self._signal_3.emit('[接收指令] ' + do_what)
remote_switch = {
'帮助': self.read_me,
'截图': self.img_to_myself,
'关机': self.shutdown_pc,
'取消关机': self.cancel_shutdown,
'关闭网页': self.close_browser,
'最小化窗口': self.send_win_d,
'切换窗口': self.send_alt_tab,
'打开': self.run_file,
'关闭': self.shutdown_process,
'网页': self.open_web,
'控制': self.more_cmd,
'忙碌回复开': self.reply_busy_on,
'忙碌回复关': self.reply_busy_off,
'机器人回复开': self.reply_robot_on,
'机器人回复关': self.reply_robot_off
}
if '@' not in do_what: # 不带参数的指令
try:
remote_switch[do_what]()
except:
pass
elif '@' in do_what: # 带参数的指令
do_at_1 = do_what.split('@')[0] # @分割，取第一个元素，即：指令
do_at_2 = do_what.split('@')[1] # 指令的参数
try:
remote_switch[do_at_1](do_at_2)
except:
pass
def read_me(self):
'''帮助信息'''
readme_msg = '[帮助信息] 指令示例：\n' \
'#帮助\n' \
'#截图\n' \
'#关机\n' \
'#取消关机\n' \
'#打开@d:\\abc.txt\n' \
'#关闭@notepad\n' \
'#网页@www.baidu.com\n' \
'#关闭网页\n' \
'#控制@explorer c:\\windows\n' \
'#最小化窗口\n' \
'#切换窗口\n' \
'#忙碌回复开\n' \
'#忙碌回复关\n' \
'#机器人回复开\n' \
'#机器人回复关\n'
self.bot.file_helper.send(readme_msg) # 发送帮助信息
self._signal_3.emit('[远控信息] 已发送帮助信息')
def img_to_myself(self):
'''截图并发送'''
timeArray = time.localtime(time.time())
now_time = time.strftime("%y/%m/%d %H:%M:%S", timeArray)
time_msg = '时间: [%s]' % now_time
filename_time = time.strftime("%y%m%d_%H%M%S",
timeArray) # 用时间来命名图片,格式中不能有/ : 和空格
img_name = filename_time + '.png'
self._signal_6.emit(img_name) # 信号通知主线程截图
QtCore.QThread.sleep(1) # 等一下，等主线程截图...
isImgExist = os.path.exists(img_name) # 是否存在
if not isImgExist:
print('找不到截图文件')
QtCore.QThread.sleep(1) # 再等一等......
self.bot.file_helper.send_image(img_name) # 微信发送截图给自己
# print('发送截图完成！')
os.chdir(current_path)
# print(os.getcwd())
self.bot.file_helper.send(time_msg) # 发送消息，截图时间
self._signal_3.emit('[远控信息] 已发送截图')
def shutdown_pc(self):
'''本机关机'''
os.system('shutdown -s -t 60') # 执行计算机系统指令，这里是60秒后关机
send_msg = '[远控信息] 60秒后电脑关机\n取消关机命令:\n#取消关机' # 发送警告消息，提醒取消指令
self.bot.file_helper.send(send_msg)
self._signal_3.emit('[远控信息] 警告：60秒后关机')
def cancel_shutdown(self):
'''取消关机'''
os.system('shutdown -a')
send_msg = '[远控信息] 此次关机已取消'
self.bot.file_helper.send(send_msg)
self._signal_3.emit(send_msg)
def run_file(self, do_at_2):
'''打开文件或程序，文件位置套上英文双引号'''
# file_cmd = '"' +do_at_2+ '"'
file_cmd = 'start ' + do_at_2
os.system(file_cmd)
send_msg = '[远控信息] 已打开文件/程序：' + do_at_2
self.bot.file_helper.send(send_msg)
self._signal_3.emit(send_msg)
def shutdown_process(self, do_at_2):
'''关闭程序'''
process_cmd = 'taskkill /f /t /im ' + do_at_2 + '.exe'
os.system(process_cmd)
send_msg = '[远控信息] 已关闭进程：' + do_at_2
self.bot.file_helper.send(send_msg)
self._signal_3.emit(send_msg)
def open_web(self, do_at_2):
'''浏览器打开网页'''
# web_cmd = 'start https://' + do_at_2 # 可以使用默认浏览器打开网页，但接下来关闭浏览器进程时，需要作相应修改
web_cmd = 'start iexplore https://' + do_at_2 # 使用IE打开网页
os.system(web_cmd)
send_msg = '[远控信息] 已打开网页：' + do_at_2
self.bot.file_helper.send(send_msg)
self._signal_3.emit(send_msg)
def close_browser(self):
'''关闭IE浏览器，其他浏览器请自行加入进程名'''
# close_ie = 'tskill iexplore' # 需要设置环境变量
close_ie = 'taskkill /f /t /im iexplore.exe'
os.system(close_ie)
send_msg = '[远控信息] 已关闭IE浏览器'
self.bot.file_helper.send(send_msg)
self._signal_3.emit(send_msg)
def more_cmd(self, do_at_2):
'''更多指令，即cmd命令，如：explorer是资源管理器，具体请百度cmd命令大全'''
os.system(do_at_2)
send_msg = '[远控信息] 已执行CMD指令：' + do_at_2
self.bot.file_helper.send(send_msg)
self._signal_3.emit(send_msg)
def send_2key(self, key_1, key_2):
'''发送键盘组合键,key_1,key_2,查按键码表'''
win32api.keybd_event(key_1, 0, 0, 0) # 键盘按下
time.sleep(1)
win32api.keybd_event(key_2, 0, 0, 0) # 键盘按下
time.sleep(1)
win32api.keybd_event(key_2, 0, win32con.KEYEVENTF_KEYUP, 0) # 键盘松开
win32api.keybd_event(key_1, 0, win32con.KEYEVENTF_KEYUP, 0) # 键盘松开
# 不发送信息
def send_win_d(self):
'''发送组合键win+D，显示桌面，再按一次显示原程序窗口'''
self.send_2key(91, 68) # 查按键码表 win->91 d->68
send_msg = '[远控信息] Win+D窗口最小化\n再次发送，还原窗口'
self.bot.file_helper.send(send_msg)
self._signal_3.emit('[远控信息] Win+D窗口最小化')
def send_alt_tab(self):
'''发送组合键alt+tab，切换窗口'''
self.send_2key(18, 9) # 查按键码表 win->91 d->68
time.sleep(1) # 等1秒再执行下面的截图
self.img_to_myself() # 发送截图
send_msg = '[远控信息] 已切换程序窗口\n当前窗口见上图'
self.bot.file_helper.send(send_msg)
self._signal_3.emit('[远控信息] 已切换程序窗口')
def reply_busy_on(self):
'''打开忙碌回复'''
myshow.checkBox_busy.setChecked(True)
send_msg = '[远控信息] 已打开忙碌回复功能'
self.bot.file_helper.send(send_msg)
self._signal_3.emit(send_msg)
def reply_busy_off(self):
'''关闭忙碌回复'''
myshow.checkBox_busy.setChecked(False)
send_msg = '[远控信息] 已关闭忙碌回复功能'
self.bot.file_helper.send(send_msg)
self._signal_3.emit(send_msg)
def reply_robot_on(self):
'''打开机器人回复'''
myshow.checkBox_robot.setChecked(True)
send_msg = '[远控信息] 已打开机器人回复功能'
self.bot.file_helper.send(send_msg)
self._signal_3.emit(send_msg)
def reply_robot_off(self):
'''关闭机器人回复'''
myshow.checkBox_robot.setChecked(False)
send_msg = '[远控信息] 已关闭机器人回复功能'
self.bot.file_helper.send(send_msg)
self._signal_3.emit(send_msg)
class MyThread(QtCore.QThread):
_signal_1 = QtCore.pyqtSignal(bool,str,int) # 定义信号，用于记录聊天信息，含：是否群聊，消息内容，消息时间
_signal_2 = QtCore.pyqtSignal(str) # 定义信号，仅用于记录登陆成功的系统信息
_signal_3 = QtCore.pyqtSignal(str) # 定义信号，用于记录远控信息
_signal_4 = QtCore.pyqtSignal(list) # 定义信号，用于记录好友列表
_signal_5 = QtCore.pyqtSignal(list) # 定义信号，用于记录群聊列表
def __int__(self, parent=None):
super(MyThread, self).__init__()
def run(self):
self.bot = Bot(cache_path=True)
self.myself = self.bot.self
self._signal_2.emit('成功登陆！账号：%s，可以关闭二维码了！' % self.myself.name)
self.get_friendslist()
self.get_chatroomslist()
##########################################################
# 处理微信信息
##########################################################
# @self.bot.register(msg_types=TEXT,except_self=False)
# def just_print(msg):
# print(msg)
# 私聊信息，文字
@self.bot.register(msg_types=TEXT,except_self=False)
def get_msg(msg):
fromChatroom = False
print(msg)
if msg.sender.name== self.bot.self.name:
# 这是我发出的消息
from_Name = '我'
if msg.receiver.name == '文件传输助手':
to_Name = '助手'
if '#' in msg.text and remote_pc == True: # 执行命令条件：1发给助手 2命令中带井号 3远控开启
do_what = msg.text.split('#')[1] # 以#分割，取第二个元素，即：具体指令。
wechat_do(do_what) # 调用微信远控的方法
else:
to_Name = msg.chat.name
elif msg.receiver.name == self.bot.self.name:
# 这是别人发给我的
to_Name = '我'
if msg.sender.name == '文件传输助手':
from_Name = '助手'
else:
from_Name = msg.chat.name
# 自动回复
if reply_busy == True: # 忙碌回复
msg_busy = myshow.lineEdit_busy.text()
msg.reply('[自动回复] %s' % msg_busy)
if reply_robot == True: # 机器人回复
myshow.tuling.do_reply(msg)
message = from_Name + '→' + to_Name + '：' + msg.text
send_time = msg.create_time
self._signal_1.emit(fromChatroom, message, send_time) # 信号焕发，连接 write_log
# 私聊信息，图片、视频等
@self.bot.register(msg_types=[PICTURE, RECORDING, ATTACHMENT, VIDEO])
def download_files(msg):
print(msg)
fromChatroom = False
if msg.sender.name == self.bot.self.name:
# 这是我发出的消息
from_Name = '我'
if msg.receiver.name == '文件传输助手':
to_Name = '助手'
else:
to_Name = msg.chat.name
elif msg.receiver.name == self.bot.self.name:
# 这是别人发给我的
to_Name = '我'
if msg.sender.name == '文件传输助手':
from_Name = '助手'
else:
from_Name = msg.chat.name
# 自动回复
if reply_busy == True:
msg_busy = myshow.lineEdit_busy.text()
msg.reply('[自动回复] %s' % msg_busy)
if reply_robot == True: # 机器人回复
myshow.tuling.do_reply(msg)
# 新建接收文件夹
downloadDir = '接收文件'
if not os.path.exists(downloadDir): # 目录如果不存在
os.makedirs(downloadDir)
workPath = os.getcwd() # 当前程序工作的路径
downloadPath = os.path.join(workPath, downloadDir) # 接收文件的路径
os.chdir(downloadPath) # 改变当前工作目录
msg.get_file(msg.file_name) # 下载文件
os.chdir(workPath)
message = from_Name + '→' + to_Name + '：' + '[文件: %s]' % msg.file_name
send_time = msg.create_time
self._signal_1.emit(fromChatroom, message, send_time) # 信号焕发，连接 write_log
# 群聊信息,@我的文字信息
@self.bot.register(chats=Group,msg_types=TEXT)
def get_msg_at(msg):
print(msg)
if msg.is_at:
print('333333')
print(msg.member.name)
if reply_busy == True:
msg_busy = myshow.lineEdit_busy.text()
msg.reply(u'@%s\u2005[自动回复] %s' % (msg.member.nick_name, msg_busy))
if reply_robot == True:
myshow.tuling.do_reply(msg)
from_Name = msg.member.name
chatroom_NickName = msg.chat.name
fromChatroom = True
message = '[' + chatroom_NickName + '] ' + from_Name + ' ：' + msg.text
send_time = msg.create_time
self._signal_1.emit(fromChatroom, message, send_time) # 信号焕发，连接 write_log
embed() # 堵塞线程
# 获取好友列表
def get_friendslist(self):
friends_info = self.bot.friends(update=False)
frinends_list = [friend.name for friend in friends_info]
frinends_pinyin = [''.join(lazy_pinyin(frinend)) for frinend in frinends_list] # 根据好友列表生成拼音列表
dict1 = dict(zip(frinends_pinyin,frinends_list)) # 拼音列表和昵称列表并成字典,像这样 {'zhangsan':'张三','Mango':'Mango','lisi':'李四'}
sort1 = sorted(dict1.items(),key=lambda x:x[0].lower()) # 按拼音排序,输出 [('lisi','李四'),('zhangsan','张三')]
friends_sorted =[i[1] for i in sort1] # ['李四','Mango','张三']
self._signal_4.emit(friends_sorted)
#获取群聊列表
def get_chatroomslist(self):
chatrooms_info = self.bot.groups(update=False)
chatrooms_list = [chatroom.name for chatroom in chatrooms_info]
self._signal_5.emit(chatrooms_list)
import time
import random
import requests
from wxpy import Bot, Friend, TEXT, MAP, CARD, NOTE, SHARING, PICTURE, RECORDING, ATTACHMENT, VIDEO, FRIENDS, embed
from baiduyuyin import post_recording, text_to_audio, get_response
pics = ([str(i) + '.gif'
for i in range(1, 10)] + [str(j) + '.jpeg' for j in range(1, 4)] +
[str(k) + '.jpg' for k in range(1, 3)])
bot = Bot(cache_path=True)
groups = []
group_1 = bot.groups().search('Iprintf 的大蟒蛇')
print(group_1)
if group_1:
groups.append(group_1[0])
# group_2 = bot.groups().search('南山吃鸡战斗群')[0]
group_3 = bot.groups().search('一家亲')
if group_3:
groups.append(group_3[0])
print(groups)
@bot.register(chats=[Friend],
msg_types=[
TEXT, MAP, CARD, NOTE, SHARING, PICTURE, RECORDING,
ATTACHMENT, VIDEO
class ChatManage:
def __init__(self):
# 登录缓存
self.bot = Bot(cache_path=True)
def send_msg_self(self):
# 给机器人自己发送消息
self.bot.self.send('Hello World!')
# 给文件传输助手发送消息
self.bot.file_helper.send('Hello World!')
def get_friends(self, name=None):
"""
获取通讯录对象
:param name: 昵称
:return: 好友对象列表
:rtype: list
"""
if not name:
return self.bot.friends()
return self.bot.friends().search(name)
@print_def
def get_friend_info(self, friends=None):
"""
获取朋友详细信息
:param friends:
:return: [[姓名,昵称,性别,个性签名,城市]]
"""
if not friends:
friends = self.get_friends()
friends_info = []
for friend in friends:
data = [
friend.name,
# friend.nick_name,
# friend.sex,
friend.signature,
# friend.city,
]
friends_info.append(data)
return friends_info
@print_def
def get_friend_nums(self):
"""返回好友总数"""
return len(self.get_friends())
def get_groups(self, name=None):
"""获取所有群"""
if not name:
return self.bot.groups()
return self.bot.groups.search(name)
@print_def
def get_group_info(self, groups=None):
"""
获取群详细信息
:param groups:
:return:
"""
if not groups:
groups = self.get_groups()
groups_info = []
for group in groups:
data = [
group.members,
group.name,
group.owner.nick_name,
[people.name for people in group.members],
]
groups_info.append(data)
return groups_info
def get_mps(self, name=None):
"""获取公众号对象"""
if not name:
return self.bot.mps()
return self.bot.mps().search(name)
# @print_def
def get_mps_info(self, mps_list=None):
"""
获取公众号基本信息
:param mps_list:
:return: [[名称,昵称,地点,签名]]
"""
if not mps_list:
mps_list = self.get_mps()
mps_info = []
for mps in mps_list:
data = [
mps.name,
mps.nick_name,
mps.raw['Province'] + '-' + mps.raw['City'],
mps.signature,
]
mps_info.append(data)
return mps_info
def get_mps_nums(self):
"""获取公众号数量"""
return len(self.get_mps())
def send_div(self, friend, msg, sign='text'):
"""
发送消息体
:param friend:
:param msg:
:param sign:
:return:
"""
if sign == 'text':
friend.send(msg)
elif sign == 'img':
# 发送图片 path 'my_picture.png'
friend.send_image(msg)
elif sign == 'video':
# 发送视频 path 'my_video.mov'
friend.send_video()
elif sign == 'file':
# 发送文件 path 'my_file.zip'
friend.send_file()
else:
# 以动态的方式发送图片 '@img@my_picture.png'
friend.send(msg)
def get_now_msg(self):
"""
获取实时消息
:return:
"""
@self.bot.register()
def print_others(msg):
print(msg)
def reply_msg(self, friend):
"""
自动回复
:param friend: 好友对象
:return:
"""
# 回复 friend 的消息 (优先匹配后注册的函数!)
@self.bot.register(friend)
def reply_my_friend(msg):
return 'received: {} ({})'.format(msg.text, msg.type)
# 自动接受新的好友请求
def auto_accept(self):
@self.bot.register(msg_types=FRIENDS)
def auto_accept_friends(msg):
# 接受好友请求
new_friend = msg.card.accept()
# 向新的好友发送消息
new_friend.send('哈哈，我接受了你的好友请求')
from wxpy import Bot, Tuling, embed, ensure_one
bot = Bot(cache_path=True)
# 想和机器人聊天的好友的备注
# my_friend = ensure_one(bot.search('Say Hello'))
# 记得把名字改成想用机器人的群
my_group = bot.groups().search('chatbot')[0]
tuling = Tuling(api_key='29fcb3f764504aea9301df5630ed52dd')
# 使用图灵机器人自动与指定好友聊天
@bot.register(my_group, except_self=False)
def reply_my_friend(msg):
tuling.do_reply(msg)
embed()
return 'received: {} ({})'.format(msg.text, msg.type)
# 打印出所有群聊中@自己的文本消息，并自动回复相同内容
# 这条注册消息是我们构建群聊机器人的基础
@bot.register(Group, TEXT)
def print_group_msg(msg):
if msg.is_at:
print(msg)
msg.reply(msg.text)
# 获取所有类型的消息（好友消息、群聊、公众号，不包括任何自己发送的消息）
# 并将获得的消息打印到控制台
@bot.register()
def print_others(msg):
print(msg)
# 通过机器人对象 Bot 的 chats(), friends()，groups(), mps() 方法, 可分别获取到当前机器人的 所有聊天对象、好友、群聊，以及公众号列表。
bot.chats()
bot.friends()
bot.groups()
bot.mps()
# 堵塞线程 进入Python 命令行 让程序保持运行
embed()
# 或者仅仅堵塞线程
# bot.join()
from wxpy import Bot, embed, ensure_one # 微信机器人
import os
import codecs
import json
bot = Bot()
sex_dict = {}
sex_dict['0'] = "其他"
sex_dict['1'] = "男"
sex_dict['2'] = "女"
department_group = ensure_one(bot.groups().search('我们运维部'))
# 通常可用在查找聊天对象时，确保查找结果的唯一性，并直接获取唯一项
# 定位部门群
manager = ensure_one(
department_group.search(nick_name='龙')) # 定位部门经理,nick_name(精准名称)
def download_images(friend_list): # 下载好友头像
image_dir = 'info/' + bot.self.name + '/images/'
for myfriend in friend_list:
print('正在保存 %s 的头像...' % myfriend['NickName'])
image_name = str(myfriend['NickName']) + '.jpg'
img = bot.core.get_head_img(userName=myfriend["UserName"])
with open(image_dir + image_name, 'wb') as file:
file.write(img)
def save_data(frined_list):
out_file_name = 'data/myfriends.json'
with codecs.open(out_file_name, 'w', encoding='utf-8') as json_file:
json_file.write(json.dumps(frined_list, ensure_ascii=False, indent=4))
import sys
import time
from wxpy import Bot
from database import db
from tools.hash_tools import hash_tool
from tools.oss2 import OSS2
from config.config import cfg
oss2 = OSS2(cfg['ACCESS_KEY_ID'], cfg['ACCESS_KEY_SECRET'])
oss2_url = cfg['OSS_URL']
robot = Bot(cache_path=True,
console_qr=cfg.getint('CONSOLE_QR'),
logout_callback=sys.exit)
robot.groups(update=True, contact_only=False)
groups = robot.groups()
itchat = robot.core
class GroupMember:
def manager_group_member(self):
print(
"***************************** MANAGER_GROUP_MEMBER START ******************************"
)
if groups is not None and len(groups) > 0:
# group_data_insert_list = []
member_data_insert_list = []
none_name_member_list = []
for group_tmp in groups:
print('group_name:{0}'.format(group_tmp.name))
group_name = []
msg = None
send_time = None
groups = []
log_msg = None
send_init_flag = False
msg_input = None
check_buttons = None
list_items = None
my_group = None
try:
bot = Bot(cache_path=True)
bot.groups(update=True, contact_only=False)
groups = bot.groups()
1/len(groups)
except:
tk.messagebox.showerror(
'Error', '登陆失败！请尝试登录网页版微信： https://wx.qq.com ，若网页版无法登录，则此脚本无法正常运行！')
exit(-1)
gui_thread = threading.Thread(target=gui, name='gui_thread')
gui_thread.setDaemon(True)
gui_thread.start()
while not send_init_flag:
pass
while True:
class Basic(tk.Tk):
def __init__(self):
super().__init__()
self.v_tuling = tk.StringVar(self)
self.v_documents = tk.StringVar(self)
self.v_services = tk.StringVar(self)
#变量定义
self.chats = set()
#一
self.basic_frame = tk.Frame(self, bg="#8A2BE2")
# self.basic_frame.pack(side=tk.TOP,fill=tk.BOTH,expand=1)
self.basic_frame.bind("<1>", self.reset)
self.basic_frame.bind("<3>", self.reset)
self.bg_frame = tk.Frame(self)
self.bg_frame.pack(side=tk.TOP, fill=tk.BOTH, expand=1)
# 背景图片指针
self.bg_status = True
self.bg_status_0_49 = 0
self.bg_stop = False
self.bg_files = ["bg/bg0" + str(i) + ".png" for i in range(50)]
Bak.py_data_file("bg")
self.photo = tk.PhotoImage(file=self.bg_files[self.bg_status_0_49])
self.bg_label = tk.Label(self.bg_frame,
image=self.photo,
text="请点击扫码登陆微信",
bg="black",
fg="green",
compound=tk.CENTER,
font=("华文行楷", 20))
self.bg_label.place(relx=0, rely=0, relheight=1, relwidth=1)
#二
self.login_button = tk.Button(self.bg_frame,
bg="#4B0082",
fg="black",
text="登陆",
command=self.login)
self.login_button.place(relx=0.42,
rely=0.55,
relheight=0.1,
relwidth=0.2)
#二
self.basic_listbox = tk.Listbox(self.basic_frame,
height=24,
width=30,
selectmode=tk.EXTENDED)
self.basic_listbox.place(x=0, y=30)
self.information = ["1、支持群聊、好友自动聊天功能", "2、支持下载手机群聊、好友文件", "3、提供服务监控功能"]
for data in self.information:
self.basic_listbox.insert(tk.END, data)
self.scrollbar = tk.Scrollbar(self.basic_frame,
orient="vertical",
command=self.basic_listbox.yview)
self.basic_listbox["yscrollcommand"] = self.scrollbar.set
self.scrollbar.pack(side="right", fill="y")
#绑定事件
self.basic_listbox.bind("<ButtonPress-1>", self.listenBases)
self.basic_listbox.bind("<Control-a>", self.listenBases)
self.basic_listbox.bind("<Shift-Button-1>", self.listenBases)
#群聊
self.group = tk.Button(self.basic_frame,
bg="green",
fg="black",
text="群聊",
command=self.display_groups)
self.group.place(x=0, y=0)
#好友
self.friend = tk.Button(self.basic_frame,
bg="green",
fg="black",
text="好友",
command=self.display_friends,
anchor="w")
self.friend.place(x=29, y=0)
#设置主窗体
self.title("木火应")
x = self.winfo_screenmmwidth()
y = self.winfo_screenheight()
self.geometry("500x500+%d+%d" % (x, y / 2 * 0.5))
self.resizable(0, 0)
self.datafriends, self.datagroups = ([], [])
#显示列表
self.v = tk.StringVar(self.basic_frame)
self.display = tk.Label(self.basic_frame,
bg="green",
fg="black",
textvariable=self.v)
#聊天机器人
self.tulingbtn = tk.Button(self.basic_frame,
textvariable=self.v_tuling,
bg="#00FA9A",
fg="black",
stat="disable",
command=self.tuling)
self.v_tuling.set("聊天机器人")
self.tulingbtn.place(x=215, y=100)
#收集聊天文件
self.documentsbtn = tk.Button(self.basic_frame,
textvariable=self.v_documents,
bg="#00FF7F",
fg="black",
stat="disable",
command=self.documents)
self.v_documents.set("收集聊天文件")
self.documentsbtn.place(x=215, y=150)
#服务监控
self.servicesbtn = tk.Button(self.basic_frame,
textvariable=self.v_services,
bg="#66CDAA",
fg="black",
stat="disable",
command=self.service)
self.v_services.set("微信服务监控")
self.servicesbtn.place(x=215, y=200)
#隐藏self.basic_frame
self.basic_frame.pack_forget()
#机器人对象
self.bot = None
#生成二维码删除图标
Bak.py_data_file("erweima.png")
def chatTuling(self):
raise Exception
def reset(self, event):
raise Exception
def documents(self):
raise Exception
def tuling(self):
raise Exception
def service(self):
raise Exception
def listenBase(self, event):
raise Exception
def logout(self):
raise Exception
def bgFile(self):
if self.bg_stop:
return
if self.bg_status:
self.bg_status_0_49 += 1
else:
self.bg_status_0_49 -= 1
if self.bg_status_0_49 == 49:
self.bg_status = False
if self.bg_status_0_49 == 0:
self.bg_status = True
self.photo.configure(file=self.bg_files[self.bg_status_0_49])
self.after(30, self.bgFile)
def tips(self):
self.basic_listbox.delete(0, tk.END)
self.basic_listbox.insert(tk.END, "微信掉线，正重新登陆！")
self.friend["stat"] = "disable"
self.group["stat"] = "disable"
def display_friends(self):
self.tulingbtn["stat"] = "active"
self.documentsbtn["stat"] = "active"
self.servicesbtn["stat"] = "active"
if len(self.datafriends) > 0 or len(self.datagroups) > 0:
self.basic_listbox.delete(0, tk.END)
self.v.set("好友列表")
self.display.place(x=90, y=0, height=30)
self.friend["stat"] = "disable"
self.group["stat"] = "active"
for friend in self.datafriends:
if friend:
self.basic_listbox.insert(tk.END, friend[0])
return True
else:
self.tips()
self.login()
def display_groups(self):
self.tulingbtn["stat"] = "active"
self.documentsbtn["stat"] = "active"
self.servicesbtn["stat"] = "active"
if len(self.datafriends) > 0 or len(self.datagroups) > 0:
self.basic_listbox.delete(0, tk.END)
self.v.set("群聊列表")
self.display.place(x=90, y=0, height=30)
self.friend["stat"] = "active"
self.group["stat"] = "disable"
for group in self.datagroups:
if group:
self.basic_listbox.insert(tk.END, group[0])
return True
else:
self.tips()
self.login()
def login(self):
self.bg_stop = True
#机器人对象,有的微信无法登陆...
self.bot = Bot(cache_path=True)
try:
location = pyautogui.locateOnScreen(image=Bak.erweima_png_path)
x, y = pyautogui.center(location)
pyautogui.click(x=x, y=y, clicks=1, button='left')
except:
pass
try:
#真实环境
self.datafriends = self.friends()
self.datagroups = self.groups()
except:
pass
if len(self.datafriends) > 0 or len(self.datagroups) > 0:
self.login_button.pack_forget()
self.bg_frame.pack_forget()
self.basic_frame.pack(side=tk.TOP, fill=tk.BOTH, expand=1)
self.logout_button = tk.Button(self.basic_frame,
width=10,
text="退出",
bg="red",
fg="black",
command=self.logout)
self.logout_button.place(x=400, y=5)
self.friend["stat"] = "active"
self.group["stat"] = "active"
self.basic_listbox.delete(0, tk.END)
self.basic_listbox.insert(0, "恭喜，登陆成功！")
return True
else:
msg.showerror("提示", "登陆失败，请稍后再试！")
return False
def friends(self):
db_friend = (self.friends.__name__ + ".db", self.friends.__name__)
if os.path.exists(db_friend[0]):
names = self.load_tasks(*db_friend)
if names[0][0] == Bak.regex_clear(
Bak.name_emoji(self.bot.self.nick_name)).strip():
return names
else:
os.remove(db_friend[0])
return self.init_friend(db_friend)
return self.init_friend(db_friend)
def init_friend(self, db_table):
names = []
friends = self.bot.friends()
for friend in friends:
names.append(
Bak.regex_clear(Bak.name_emoji(friend.nick_name)).strip())
Basic.connectDB(*db_table)
for name in iter(names):
self.save_task(*db_table, name)
names = self.load_tasks(*db_table)
return names
def init_group(self, db_table):
names = []
groups = self.bot.groups()
for group in groups:
names.append(
Bak.regex_clear(Bak.name_emoji(group.nick_name)).strip())
Basic.connectDB(*db_table)
for name in iter(names):
self.save_task(*db_table, name)
names = self.load_tasks(*db_table)
return names
def groups(self):
db_group = (self.groups.__name__ + ".db", self.groups.__name__)
if os.path.exists(db_group[0]):
os.remove(db_group[0])
return self.init_group(db_group)
return self.init_group(db_group)
def members(self):
pass
def save_task(self, namedb, table, task):
insert_task_query = "INSERT INTO " + table + " VALUES (?)"
insert_task_data = (task, )
self.runQuery(insert_task_query, insert_task_data, namedb=namedb)
def load_tasks(self, namedb, table):
load_tasks_query = "SELECT name FROM " + table
my_tasks = self.runQuery(load_tasks_query, receive=True, namedb=namedb)
return my_tasks
def delete_tasks(self, namedb, table, text):
delete_task_query = "DELETE FROM " + table + " WHERE name=?"
delete_task_data = (text.cget("text"), )
self.runQuery(delete_task_query, delete_task_data, namedb=namedb)
def delete_all(self):
dbs = [self.friends.__name__ + ".db", self.groups.__name__ + ".db"]
@staticmethod
def runQuery(sql, data=None, receive=False, namedb=None):
conn = sqlite3.connect(namedb)
cursor = conn.cursor()
if data:
cursor.execute(sql, data)
else:
cursor.execute(sql)
if receive:
return cursor.fetchall()
else:
conn.commit()
conn.close()
@staticmethod
def connectDB(namedb, table):
create_tables = "CREATE TABLE " + table + "(name TEXT)"
Basic.runQuery(create_tables, namedb=namedb)
class XWechat(object):
def __init__(self, interval=0.5):
self.db = MessageDb()
self.bot = Bot(console_qr=True)
self.bot.enable_puid("/tmp/wxpy_puid.pkl")
self.interval = interval
self.mwin = MainWindow(curses.initscr(), self.db)
self.loop = asyncio.get_event_loop()
self.executor = ThreadPoolExecutor()
self.friends = self.bot.friends()
self.groups = self.bot.groups()
self.friends.extend(self.groups)
self.mwin.rwin.friends = self.friends
async def update_db(self):
try:
while True:
if self.bot.messages.updated:
new_messages = [
_Message(m) for m in self.bot.messages if not m.read
]
self.bot.messages.updated = False
self.db.process(new_messages)
# wxpy retrieves messages every 0.5s, keep the db updating messages every 0.5s as well
await asyncio.sleep(0.5)
except CancelledError:
return
async def print_msg(self):
try:
while True:
# query chaters which has sent messages to you after you login
results = self.db.search_chats()
chats = [
ensure_one(self.bot.search(puid=chat)) for chat in results
]
non_none = lambda x: x is not None and x != ""
self.mwin.rwin.chats = list(filter(non_none, chats))
# query all received messages which will be displayed in the left screen
self.mwin.lwin.messages = self.db.search_all()
# if chose chater, then query all messages received from or sent to this chater
if self.mwin.rwin.chater:
self.mwin.rwin.messages = self.db.search_user_msg(
self.mwin.rwin.chater.puid)
self.mwin.update()
# Make sure the cursor will back to the right bottom screen after updating the messages
if self.mwin.rwin.is_typed:
self.mwin.rwin.right_bottom_screen.refresh()
await asyncio.sleep(self.interval)
except CancelledError:
return
async def listener_executor(self):
# https://docs.python.org/3/library/asyncio-eventloop.html
# The listener is a blocking function, calling the listener in a Executor
# which is pool of threads will avoid blocking other tasks
self.loop.set_default_executor(self.executor)
await self.loop.run_in_executor(None, self.mwin.listener)
async def asynchronous(self):
tasks = [
asyncio.ensure_future(task) for task in
[self.listener_executor(),
self.update_db(),
self.print_msg()]
]
done, pending = await asyncio.wait(tasks, return_when=FIRST_EXCEPTION)
for pending_task in pending:
pending_task.cancel()
# listener is running in executor, can not cancel a running task inside executor,
# just manually exit the blocking process window.getch() by push 'q' to getch()
if not self.mwin.isendwin:
self.mwin.exit(raise_exception=False)
def terminal(self):
# Send 'q' to the listener of curses to raise a Exception
# so that asyncio.wait return and cancel all pending tasks
self.mwin.exit(raise_exception=True)
def cleanup(self):
self.mwin.destroy()
self.bot.logout()
self.db.close()
def run(self):
try:
self.loop.add_signal_handler(signal.SIGTERM, self.terminal)
self.loop.add_signal_handler(signal.SIGINT, self.terminal)
self.loop.run_until_complete(self.asynchronous())
self.executor.shutdown(wait=True)
self.loop.close()
finally:
self.cleanup()
# -*- coding: utf-8 -*-
"""
Created on Tue Mar 13 18:55:04 2018
@author: Administrator
"""
from wxpy import Bot, Tuling, embed
bot = Bot(cache_path=True)
my_group = bot.groups().search('群聊名称')[0] # 记得把名字改成想用机器人的群
tuling = Tuling(api_key='72bce33cb2b248a199d07175225a5264') # 一定要添加，不然实现不了
@bot.register(my_group, except_self=False) # 使用图灵机器人自动在指定群聊天
def reply_my_friend(msg):
print(tuling.do_reply(msg))
embed()
