def register(self, chat_p=None): """Logs a new chat to the daemon and hosts it. - chat_p : None - A nameless chat is created and hosted. - chat_p : str - creates a chat named as {chat_p} and registers it. - chat_p : chat.Chat - registers the chat.""" if isinstance(chat_p, str): chat_p = chat.Chat(name=chat_p) self.register(chat_p) elif chat_p is None: chat_p = chat.Chat() self.register(chat_p) elif isinstance(chat_p, chat.Chat): uri = str(self.daemon.register(chat_p)) self.chats.append((chat_p.name, uri))
def chat_nessage_hendler(message): #Если сообщение пришло в ЛК if message.chat.type == "private": pass #Если сообщение пришло в чат else: #Вызов класса Chat target_chat = chat.Chat(message.chat.id) #Выбираем обьект Чата из БД check_chat = target_chat.init_chat("obj") if check_chat[3] != "No": i = 0 while i <= len(c.box): if c.box[i][0:-1] in message.text: break i += 1 if i == len(c.box): c.bot.delete_message(message.chat.id, message.message_id) if check_chat[2] != "No": #Это сообщение обьясняет причину удаления сообщения юзера c.bot.send_message(message.chat.id, "заткнись сука") break else: break
def Join(self, chat, prefix): if chat not in self.connections.keys(): self.connections[chat] = chat.Chat(chat, prefix, self) self.chats.append(chat) return True else: return False
def test01_not_reserved(self): event = {} event["body"] = None chat_id = 10 event["pathParameters"] = {} event["pathParameters"]["chatId"] = chat_id with mock.patch( "UnreserveChatById.lambda_function.Session") as mock_session: mock_query = mock_session.return_value.query mock_get = mock_query.return_value.get mock_chat = chat.Chat() mock_chat.chat_status = chat.ChatStatus.ACTIVE mock_chat.aspiring_professionals = ["Henry"] mock_get.return_value = mock_chat actual = unreserve.handler(event, context) expected = {"statusCode": 400, "body": json.dumps({})} self.assertEqual(actual["statusCode"], expected["statusCode"], \ self.msg_status_code.format(expected["statusCode"], \ actual["statusCode"]))
def do_stuff(self, username, message, net_socket): command_to_remove = message.replace("!remove", "") command_to_remove = command_to_remove.strip() print("Remove: {}".format(command_to_remove)) if(not "!" in command_to_remove): command_to_remove = "!{}".format(command_to_remove) print("command keys: {}".format(self.commands.keys())) if(not command_to_remove in self.commands.keys()): chat_obj = chat.Chat("Command {} not found in command list".format(command_to_remove)) chatcommands.chat(net_socket, chat_obj.get_chat_text()) return self.commands.pop(command_to_remove) with open(os.path.dirname(os.path.realpath(__file__))+'/commands.json', 'w') as commands_file: commands_file.write(json.dumps(self.commands)) chat_obj = chat.Chat("Removed command {}".format(command_to_remove)) chatcommands.chat(net_socket, chat_obj.get_chat_text())
def do_stuff(self, username, message, net_socket, tags): is_resub = tags[tagsutil.MSG_ID_KEY] == "resub" chat_obj = chat.Chat() chat_obj.add_decorator( chatdecorators.SubOrResubDecorator( username, tags[tagsutil.SUB_MONTH_KEY], tags[tagsutil.SUB_PLAN_KEY].replace("\s", " "), is_resub)) chatcommands.chat(net_socket, chat_obj.get_chat_text())
def newChat(self, uri_str): uri = ch.ParseSipUri(uri_str) if not uri: return None chat = ch.Chat(self.app, self, uri) self.chatList.append(chat) self.app.updateWindowMenu() return chat
def click(self, obj = None): self.i += 1 pytanie = self.inp.text self.adapter.data.append('Ty: '+pytanie) odpowiedz = chat.Chat().odpowiedz(pytanie) self.adapter.data.append('Franek: ' + odpowiedz) if self.i >= 6: self.list_view.scroll_to((self.i*2)-9) self.inp.text = ""
def delete_chat(message): if message.left_chat_member.id == c.bot.get_me().id: target_chat = chat.Chat(message.chat.id) check_chat = target_chat.init_chat("chat") if check_chat is True: target_chat.delete_chat(message.chat.id) #тут сообщение выдает ошибку print("Прошло удаление бота в чате ", message.chat.title)
def __process_xfr(self, command): sb = split(command.args[1], ':') server = (sb[0], int(sb[1])) cr = self.chat_requests[command.trn] invitee = cr.invitee chat_ = chat.Chat(self, server, command.args[3], self.passport_id, self.display_name, None, invitee) self.active_chats[chat_.session_id] = chat_ self.callbacks.chat_started(chat_)
def __host(self): dialog = ConnectDialog(self) if not dialog.was_canceled(): try: if self.__net is not None and not self.__net.is_done(): raise RuntimeError('Chat is already running.') self.__net = chat.Chat(dialog.get_username(), self.__got_message, self.__thread_error) self.__net.host(dialog.get_address(), dialog.get_port()) except RuntimeError as e: tkinter.messagebox.showerror('Error!', str(e))
def reg_cchat(message): if message.new_chat_member.id == c.bot.get_me().id: target_chat = chat.Chat(message.chat.id) check_chat = target_chat.init_chat("chat") if check_chat is False: target_chat.create_chat(message) c.bot.send_message(message.chat.id, "Вы зарегали чат, скоро Эрек напишет правила") print("Прошла регистрация в чате ", message.chat.title) else: c.bot.send_message(message.chat.id, "Бот уже зарегистрировал ваш чат")
def addNewChat(): print("type chat id: ") new_chat_id = int(input()) new_chat = chat.Chat(new_chat_id, session) chats.append(new_chat) new_cthread = mthread.refreshingThread(new_chat, 0.5) threads.update({new_chat_id: new_cthread}) new_cthread.setName(new_chat.chat_name) new_cthread.daemon = True new_cthread.start() print("Added new Chat: " + new_chat.chat_name)
def __init__(self, clientsocket, data): self.data = data try: self.chatlisten = chat.Chat("listen") threading.Thread(self.chatlisten.main()) except: print("Error Launching Chat") self.gamep2p = gamep2p.Gamep2p('listen') threading.Thread(self.gamep2p.main()) threading.Thread(self.client()) self.sock = clientsocket
def get_game_info(self, sock, msg, username): game = None try: game = Game() print(game.__str__()) except exceptions.NotStreamingException as e: chat_obj = chat.Chat("@{} isn't streaming right now!".format(config.USERNAME)) chat_obj.add_decorator(chatdecorators.UsernamePrefixDecorator(username)) chatcommands.chat(sock, chat_obj.get_chat_text()) return except exceptions.GameNotFoundException as e: chat_obj = chat.Chat("We couldn't find \"{}\" in the IGDB database. Want to help out? Add it to the database! https://www.igdb.com/".format(e.message)) chat_obj.add_decorator(chatdecorators.UsernamePrefixDecorator(username)) chatcommands.chat(sock, chat_obj.get_chat_text()) return except Exception as e: chat_obj = chat.Chat("Weird, something else went wrong.") chat_obj.add_decorator(chatdecorators.UsernamePrefixDecorator(username)) chatcommands.chat(sock, chat_obj.get_chat_text()) return print(game.__str__()) if game: chat_obj = chat.Chat() msg = msg.replace("\r", "") msg = msg.replace("\n", "") args = re.split(WHITESPACE_RE, msg) args.pop(0) if not args: chat_obj.add_decorator(chatdecorators.SummaryDecorator(game)) elif "summary" in args: chat_obj.add_decorator(chatdecorators.SummaryDecorator(game)) elif "beat-time" in args: chat_obj.add_decorator(chatdecorators.TimeToBeatDecorator(game)) print(game.__str__()) chat_obj.add_decorator(chatdecorators.URLDecorator(game)) chat_obj.add_decorator(chatdecorators.UsernamePrefixDecorator(username)) chatcommands.chat(sock, chat_obj.get_chat_text())
def __process_rng(self, buf): cmdline = split(buf) session_id = cmdline[1] sb = split(cmdline[2], ':') server = (sb[0], int(sb[1])) hash = cmdline[4] passport_id = cmdline[5] display_name = url_codec.decode(cmdline[6]) try: chat_ = chat.Chat(self, server, hash, passport_id, display_name, session_id) except Error, e: if e.code == 1: # connection closed return raise e
def parse(filename): events = [] authors = {} with codecs.open(filename, encoding='utf-8') as f: last_event_type = None for line in f.readlines(): event_type, fields = parse_event(line) if event_type is not None: dt = datetime.datetime.strptime(fields[0], '%d/%m/%y %H:%M:%S') # Create the author if it doesn't exist. if fields[1] not in authors: authors[fields[1]] = Author(fields[1]) author = authors[fields[1]] try: params = dt, author, fields[2] except IndexError: params = dt, author # This is horrible. if last_event_type == Message: events[-1].text = events[-1].text.strip() newevent = event_type(*params) events.append(newevent) elif last_event_type == Message: events[-1].text += line event_type = Message last_event_type = event_type # This is horrible, again. if last_event_type == Message: events[-1].text = events[-1].text.strip() events = sorted(events, key=attrgetter('datetime')) return chat.Chat(events, authors.values())
def do_stuff(self, username, message, net_socket): command_to_add = message.replace("!add", "") split_pair = command_to_add.split("=") chat_obj = chat.Chat() if len(split_pair) != 2: exception = exceptions.FormatException("command = response") user_decorator = chatdecorators.UsernamePrefixDecorator(username) exception_decorator = chatdecorators.ExceptionDecorator(exception) chat_obj.add_decorator(user_decorator) chat_obj.add_decorator(exception_decorator) chatcommands.chat(net_socket, chat_obj.get_chat_text) return split_pair[0] = split_pair[0].strip() split_pair[1] = split_pair[1].strip() text = self.commands["!{}".format(split_pair[0])] = split_pair[1] with open(os.path.dirname(os.path.realpath(__file__))+'/commands.json', 'w') as commands_file: commands_file.write(json.dumps(self.commands)) chat_obj.add_decorator(chatdecorators.DictDecorator("Added command !{}".format(split_pair[0]))) chatcommands.chat(net_socket, chat_obj.get_chat_text())
def handleConn(self, conn): data = conn.recv(4096) if data: hello = ipcMessage_pb2.Hello() hello.ParseFromString(data) if not hello.response: respHello = ipcMessage_pb2.Hello() respHello.response = True conn.send(respHello.SerializeToString()) while True: #Receiving from client data = conn.recv(4096) if not data: break msg = ipcMessage_pb2.Message() msg.ParseFromString(data) if msg.chatId not in self.chatDict: self.chatDict[msg.chatId] = chat.Chat(self.g) self.chatDict[msg.chatId].addMessage(msg) respMsg = ipcMessage_pb2.Message() if msg.respond: respMsg.text = self.chatDict[msg.chatId].runNN() respMsg.chatId = msg.chatId respMsg.userId = msg.userId respMsg.time = msg.time respMsg.respond = True conn.send(respMsg.SerializeToString()) conn.close()
def decode_object(o): if '__User__' in o: u = user.User(None, None) u.__dict__.update(o['__User__']) return u elif '__Message__' in o: m = user.Message(None, None) m.__dict__.update(p['__Message__']) return m elif '__Chat__' in o: c = chat.Chat() c.__dict__.update(o['__Chat__']) return c return o
def start(message): if message.chat.type == "private": pass else: #Вызов класса Чат target_chat = chat.Chat(message.chat.id) #Проверка чата на существование check_chat = target_chat.init_chat("bool") #Если чат существует в БД то: if check_chat is True: this_chat = target_chat.init_chat("obj") admins = c.bot.get_chat_administrators(message.chat.id) for i in admins: if i.user.id == message.from_user.id: if this_chat[2] == "No": target_chat.update_chat(this_chat[0], this_chat[1], "Yes", this_chat[3]) c.bot.send_message(message.chat.id, "Системные сообщения включены") elif this_chat[2] == "Yes": c.bot.send_message(message.chat.id, "В этом чате уже включены системные сообщения") else: c.bot.send_message(message.chat.id, "Ваш чат не зарегестрирован")
def updprof_addfr_remfr_chat_gui(self): """ Update Profile and Move to Chat Windows choosing GUI """ img = "choose.gif" msg = "What to do?" choices = ("Chat!", "Update Profile!", "Add Friends!", "Remove Friends!", "See Others Profile!", "Exit") reply = eg.buttonbox(msg, title=self.title, image=img, choices=choices) if reply == "Chat!": ch = chat.Chat(self.username, self.re) if ch.chat_window_gui() == 0: self.updprof_addfr_remfr_chat_gui() elif reply == "Update Profile!": rl = self.update_profile() self.updprof_addfr_remfr_chat_gui() elif reply == "Add Friends!": if self.add_friends() == 1: msg = "Friends Added Successfully!" eg.msgbox(msg, self.title) self.updprof_addfr_remfr_chat_gui() elif reply == "Remove Friends!": if self.remove_friends() == 1: msg = "Selected Friends Removed Successfully!" eg.msgbox(msg, self.title) self.updprof_addfr_remfr_chat_gui() elif reply == "See Others Profile!": msg = "Choose the Person to see details" choices = self.re.keys('*') ch = eg.choicebox(msg, self.title, choices) if ch is not None: data = json.loads(self.re.get(ch)) msg = """ Username:\t%s \n\n Name:\t\t%s \n\n EmailID:\t\t%s """ \ % (ch, data[2], data[3]) eg.msgbox(msg, self.title) self.updprof_addfr_remfr_chat_gui() else: exit(0)
def test02_valid_id_invalid_status(self): event = {} event["body"] = None chat_id = 10 event["pathParameters"] = {} event["pathParameters"]["chatId"] = chat_id with mock.patch( "ReserveChatById.lambda_function.Session") as mock_session: mock_query = mock_session.return_value.query mock_get = mock_query.return_value.get mock_chat = chat.Chat() mock_chat.chat_status = chat.ChatStatus.DONE mock_get.return_value = mock_chat actual = reserve.handler(event, context) expected = {"statusCode": 409, "body": json.dumps({})} self.assertEqual(actual["statusCode"], expected["statusCode"], \ self.msg_status_code.format(expected["statusCode"], \ actual["statusCode"]))
import os from twitchio.ext import commands import asyncio import kekfunc import emote import chat from datetime import datetime import csv import pasta import numpy as np # GENERAL SETUP # load channel config and initialize chat object chat_config = chat.Chat.load_chat_config('utils/config.yaml') chat_object = chat.Chat(chat_config) # load pasta list pasta_list, pasta_id = pasta.load_pasta('Data/copypasta/deep_fake_pasta.csv') # COLORS FOR TERMINAL print_color_green = '\033[92m' print_color_cyan = '\u001b[36;1m' print_color_red = '\u001b[31m' print_color_reset = '\u001b[0m' # set up the bot class Bot(commands.Bot): def __init__(self): super().__init__(irc_token=os.environ['TMI_TOKEN'], client_id=os.environ['CLIENT_ID'], client_secret=os.environ['CLIENT_SECRET'], nick=os.environ['BOT_NICK'],
currentEndurance.insert(INSERT, c.currentE) currentIntelligence.insert(INSERT, c.currentI) currentPerception.insert(INSERT, c.currentP) currentSocial.insert(INSERT, c.currentS) currentAgilite.insert(INSERT, c.currentA) currentChance.insert(INSERT, c.currentC) ##########################################################"""HEBERGER""" MUTEX = RLock() queue1 = queue.Queue() queue2 = queue.Queue() SERVER = server.Server(queue1, queue2) CHAT = chat.Chat(queue2, queue1, MUTEX) class Client(): def __init__(self, q, p, mutex): #Thread.__init__(self) self.isClient = False self.queue_v_c = q self.queue_f_c = p self.mutex = mutex def connect(self, ip, port, name): try: self.ip = ip self.port = port self.name = name
def timed_chat(): intro_chat = chat.Chat() intro_chat.add_decorator(chatdecorators.MotdDecorator()) chatcommands.chat(s, intro_chat.get_chat_text()) msg_count = 0 last_msg_time = time.time()
from logging.handlers import RotatingFileHandler from flask import Flask, request, session, g, redirect, url_for, \ abort, render_template, flash, make_response, jsonify, json, \ send_from_directory from flask.views import MethodView from uadetector.flask import UADetector from decimal import Decimal from urllib.error import HTTPError from urllib.parse import quote, unquote import chat application = Flask(__name__) UADetector(application) chat.FLAGS.out_dir = 'nmt_model/' chatbot = chat.Chat() default_hparams = chat.create_hparams(chat.FLAGS) chatbot.nmt_main(chat.FLAGS, default_hparams) @application.route('/favicon.ico') def favicon(): return send_from_directory(os.path.join(application.root_path, 'static'), '/images/favicon.ico', mimetype='image/vnd.microsoft.icon') @application.route('/') def root(): return render_template('home.html')
def send(): while True: time.sleep(1) network.s.send(chat.type_message.encode()) def recv(): while True: time.sleep(0.5) data = network.s.recv(1024) chat.chat_text.config(state="normal") chat.chat_text.insert(tk.INSERT, data) chat.chat_text.config(state="disabled") nicks = ["seifer", "dima"] network = network.Network() log = log.Log(network.s, network.connected) log.window() nick = network.s.recv(1024) chat = chat.Chat(network.s, nick.decode()) chat.add_contacts(nicks) send_thread = threading.Thread(target=send) send_thread.daemon = True send_thread.start() receive_thread = threading.Thread(target=recv) receive_thread.daemon = True receive_thread.start() chat.window()
def Start(self, prefix, chats=None): for x in chats: if x not in self.connections.keys(): self.connections[x] = chat.Chat(x, prefix, self) self.chats.append(x) self.myHomies()
def signup(self): """ New user Signup class """ msg = " Enter Details!" fnames = [ "Full Name(atleast 6 chars): ", "Email-ID: ", "UserName:"******"Security Code(Atleast 6 chars):", "Password(Atleast 8 chars that includes alpha-numeric):" ] errormsg = "" fvals = [] mac = get_mac() #print mac fvals = eg.multpasswordbox(msg, self.title, fnames) if fvals is not None: if fvals[0] == '' or fvals[1] == '' or fvals[2] == '' or \ fvals[3] == '' or fvals[4] == '': errormsg = "Fill all Boxes!" else: # Checking if username exists or not if len(fvals[0]) >= 6: if self.check_emailid(fvals[1]): if len(fvals[2]) >= 3: if self.re.exists(fvals[2]) == False: if len(fvals[3]) >= 6: if len(fvals[4] ) >= 8 and self.check_password( fvals[4]): pas = self.make_password(fvals[4]) # Empty list => friends of user # Value in DB: [Password,SC,Name,EmailID,Friend list,mac] val = json.dumps([ pas, fvals[3], fvals[0], fvals[1], [], mac ]) self.re.set(fvals[2], val) self.re.bgsave() # Making Queues for every signup client so that his friends can send him # msgs when he is Offline also, and user can get them later :) ch = chat.Chat(fvals[2], self.re) ch.connection() eg.msgbox("You Signup Successfully!", self.title) return 1 else: errormsg = """ Password should contain atleast 1 digit, 1 uppercase chars, 1 lowercase chars & should be of atleast 8 chars! """ else: errormsg = "Security Code should be of atleast 6 in length" else: errormsg = "UserName Already Exists" else: errormsg = "UserName should be of atleast 4 chars" else: errormsg = "Enter EmailID in proper format" else: errormsg = "Name should be of atleast 6 chars" if errormsg != "": eg.msgbox(errormsg, title=self.title) return 2 else: return 0