def write(self):
log('write')
if self.request:
if not self.response_created:
self.create_response()
self._write()
def chat_listen():
global chat_window
while ui_running: # Wait on messages from IRC
try:
# Wait for new data so that control-C works
ready = select([irc], [], [], 1) # 1 second timeout
if ready[0]:
data = irc.recv(4096).decode('utf-8')
log(data)
if data == 'PING :tmi.twitch.tv\r\n':
send(irc, 'PONG :tmi.twitch.tv')
continue
elif JTV_MSG.match(data):
m = JTV_MSG.match(data)
chat_window.on_chat({}, '', m.group(2))
elif CHAT_MSG.match(data):
m = CHAT_MSG.match(data)
line_data = {}
for kvp in m.group(1).split(';'):
line_data[kvp.split('=')[0]] = kvp.split('=')[1]
chat_window.on_chat(line_data, m.group(2), m.group(3))
elif JOIN_MSG.search(data):
for m in JOIN_MSG.finditer(data):
if m.group(2) == my_username:
on_join(m.group(1))
elif PART_MSG.search(data):
for m in PART_MSG.finditer(data):
if m.group(2) == my_username:
on_join(m.group(1))
else:
log('Unable to parse message!\n')
except:
log_exception()
sleep(1000)
def start_connection(host, port, request):
addr = (host, port)
my_logger.log("starting connection to {}".format(addr))
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
sock.setblocking(False)
sock.connect_ex(addr)
events = selectors.EVENT_READ | selectors.EVENT_WRITE
message = libclient.Message(sel, sock, addr, request)
sel.register(sock, events, data=message)
try:
while True:
events = sel.select(timeout=1)
for key, mask in events:
message = key.data
try:
message.process_events(mask)
except Exception:
print(
"main: error: exception for",
f"{message.addr}:\n{traceback.format_exc()}",
)
message.close()
# Check for a socket being monitored to continue.
if not sel.get_map():
break
except KeyboardInterrupt:
print("caught keyboard interrupt, exiting")
finally:
pass
def wrapper(*args, **kwargs):
t_start = time.time()
result = step_function(*args, **kwargs)
t_stop = time.time()
log(
logging.INFO,
'--- Execution time of "{}" function: {:.3f} seconds ---'.format(
step_function.__name__, t_stop - t_start))
return result
def wrapper(*args, **kwargs):
name = step_function.__name__
log(
logging.INFO, "***** Started {}: '{}' *****".format(
'test' if 'test' in name else 'step', name))
result = step_function(*args, **kwargs)
log(
logging.INFO, "***** Finished {}: '{}' *****".format(
'test' if 'test' in name else 'step', name))
return result
def load_bttv_global():
while 1:
try:
raw = load(request.urlopen('https://api.betterttv.net/2/emotes'))
break
except:
sleep(5000)
log('Loaded global BTTV emotes')
for emote in raw['emotes']:
emotes[emote[
'code']] = 'https://cdn.betterttv.net/emote/%s/1x' % emote['id']
def _write(self):
if self._send_buffer:
log("sending {} to {}".format(repr(self._send_buffer), self.addr))
try:
# Should be ready to write
sent = self.sock.send(self._send_buffer)
except BlockingIOError:
# Resource temporarily unavailable (errno EWOULDBLOCK)
pass
else:
self._send_buffer = self._send_buffer[sent:]
def load_bttv_channel(username):
while 1:
try:
raw = load(
request.urlopen('https://api.beetterttv.net/2/channels/' +
username))
break
except:
sleep(5000)
log('Loaded BTTV emotes for ' + username)
for emote in raw['emotes']:
emotes[emote[
'code']] = 'https://cdn.betterttv.net/emote/%s/1x' % emote['id']
def load_ffz_global():
while 1:
try:
raw = load(
request.urlopen('https://api.frankerfacez.com/v1/set/global'))
break
except:
sleep(5000)
log('Loaded global FFZ emotes')
set_id = str(raw['default_sets'][0])
for emote in raw['sets'][set_id]['emoticons']:
emotes[emote[
'name']] = 'https://cdn.frankerfacez.com/emoticon/%s/1' % emote[
'id']
def load_ffz_channel(username):
while 1:
try:
raw = load(
request.urlopen('https://api.frankerfacez.com/v1/room/' +
username))
break
except:
sleep(5000)
log('Loaded FFZ emotes for ' + username)
set_id = str(raw['room']['set'])
for emote in raw['sets'][set_id]['emoticons']:
emotes[emote[
'name']] = 'https://cdn.frankerfacez.com/emoticon/%s/1' % emote[
'id']
def process_response(self):
content_len = self.jsonheader["content-length"]
if not len(self._recv_buffer) >= content_len:
return
data = self._recv_buffer[:content_len]
self._recv_buffer = self._recv_buffer[content_len:]
if self.jsonheader["content-type"] == "text/json":
encoding = self.jsonheader["content-encoding"]
self.response = self._json_decode(data, encoding)
log("received response {} from {}".format(repr(self.response),
self.addr))
self._process_response_json_content()
else:
# Binary or unknown content-type
self.response = data
print(
f'received {self.jsonheader["content-type"]} response from',
self.addr,
)
self._process_response_binary_content()
# Close when response has been processed
self.close()
def close(self):
log("closing connection to {}".format(self.addr))
try:
self.selector.unregister(self.sock)
except Exception as e:
log("error: selector.unregister() exception for {}:{}".format(
self.addr, repr(e)))
try:
self.sock.close()
except OSError as e:
log("error: socket.close() exception for {}:{}".format(
self.addr, repr(e)))
finally:
# Delete reference to socket object for garbage collection
self.sock = None
lsock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
# Avoid bind() exception: OSError: [Errno 48] Address already in use
lsock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
lsock.bind((host, port))
lsock.listen()
print("listening on", (host, port))
lsock.setblocking(False)
sel.register(lsock, selectors.EVENT_READ, data=None)
try:
while True:
events = sel.select(timeout=None)
for key, mask in events:
if key.data is None:
accept_wrapper(key.fileobj)
log('key.data is None')
else:
log('key.data is NOT None')
message = key.data
message.set_trial('tony')
try:
message.process_events(mask)
except Exception:
print(
"main: error: exception for",
f"{message.addr}:\n{traceback.format_exc()}",
)
message.close()
except KeyboardInterrupt:
print("caught keyboard interrupt, exiting")
finally:
def set_trial(self,input):
log(input)
def _process_response_binary_content(self):
content = self.response
log("got result: {}".format(content))
