def __init__(self, host, port):
self.host = host
self.port = port
self.ln = Listener(host, port)
self.tk = Talker(host, port)
thread.start_new_thread(self.ln.listening, (self.recv_data,))
self.client_list = {}
def __init__(self, host, port, dhost = '', dport = 0):
self.host = host
self.port = port
self.dhost = dhost
self.dport = dport
self.prev_cmd = ''
self.user = ''
self.msg_id = 0
self.ack_status = {}
self.irc_mode = False
self.parser = Parser()
self.tk = Talker(self.host, self.port)
self.ln = Listener(self.host, self.port)
thread.start_new_thread(self.ln.listening, (self.receive_packet,))
if self.dhost and self.dport:
self.connect_server(self.dhost, self.dport)
class HServer:
def __init__(self, host, port):
self.host = host
self.port = port
self.ln = Listener(host, port)
self.tk = Talker(host, port)
thread.start_new_thread(self.ln.listening, (self.recv_data,))
self.client_list = {}
def recv_data(self, data):
"""
Callback function to receive from the server.
Note that data is NOT deserialized yet.
Args:
socket (socket): the socket that is connected to the server.
"""
self.process_packet(pickle.loads(data))
def send_ack_message(self, msg):
"""
Inform the client that the request succeeds.
Args:
msg (Message): the original message.
"""
logging.info('Sending ACK')
ack_msg = pickle.dumps(Message('', Message.ACK, id = msg.id))
self.tk.talk(ack_msg, msg.origin[0], msg.origin[1])
def send_fail_message(self, msg):
"""
Inform the client that the request fails.
Args:
msg (Message): the original message.
"""
fail_msg = pickle.dump(Message('', Message.FAIL, id = msg.id))
self.tk.talk(fail_msg, msg.origin[0], msg.origin[1])
def process_packet(self, data):
"""
Process a packet after receiving.
Args:
data (Object): data that has been deserialized by pickle.
"""
if data.type == Message.JOIN:
# update user.
username = data.msg
if username not in self.client_list:
self.client_list[username] = data.origin
logging.info('User "%s" joined', username)
else:
logging.warning('User "%s" is already in the server.', username)
elif data.type == Message.MESSAGE:
# broadcast the message to all other users.
print 'receive new message:"%s"'%data.msg
print 'broadcasting...'
logging.info('Receive message from (%s, %s) with id %s', data.origin[0]
, data.origin[1], data.id)
data.type = Message.BROADCAST
for username in self.client_list:
self.tk.talk(pickle.dumps(data), self.client_list[username][0],
self.client_list[username][1])
elif data.type == Message.LEAVE:
username = data.msg
logging.info('User "%s" is leaving.', username)
if username not in self.client_list:
return
else:
self.client_list.pop(username, None)
elif data.type == Message.CHANGE_NAME:
# We need to check that the new name is not used, and the old name
# exists. If one of the condition fails, inform the sender.
oldname, newname = data.msg.split(' ')[0], data.msg.split(' ')[1]
print "user %s changes the name to %s" %(oldname, newname)
logging.info('Change username from %s to %s', oldname, newname)
if oldname not in self.client_list or newname in self.client_list:
logging.warning('Change username from %s to %s unsuccessfully.'
, oldname, newname)
self.send_fail_message(data)
else:
self.client_list[newname] = self.client_list.pop(oldname)
self.send_ack_message(data)
def __init__(self, database):
self.lines = Lines()
self.database = database
self.talker = Talker()
self.talker.start()
class CommentatorTalker(object):
def __init__(self, database):
self.lines = Lines()
self.database = database
self.talker = Talker()
self.talker.start()
def tag(self, tagger, tagged):
tag_lines = []
weighted_tag_lines = []
tagger_speed = tagger.getActualSpeed()
tagged_speed = tagged.getActualSpeed()
tag_line = None
if tagger_speed - tagged_speed > 60:
tag_lines.append(self.lines.get_fast_tagger_slow_tagged_line())
elif tagger_speed > 60:
tag_lines.append(self.lines.get_fast_tagger_line())
elif tagged_speed < 60:
tag_lines.append(self.lines.get_slow_tagged_line())
tag_lines.append(self.lines.get_standard_tag_line())
self.say(random.choice(tag_lines) % {'tagger': tagger.getName(), 'tagged': tagged.getName()})
print str(tagger_speed) + ", " + str(tagged_speed)
self.check_for_tag_color(tagger, tagged)
def check_for_tag_color(self, tagger, tagged):
tag_line_strings = []
# cflewis | 2008-11-22 | Say something about the number of tags
tag_line_strings.append(self.lines.get_number_of_tags_line() \
% {'tagger': tagger.getName(), 'tagged': tagged.getName(), 'tags': \
self.database.get_tag_number(tagger.getName(), tagged.getName())})
# cflewis | 2008-11-22 | Say something about the speed of the tagger
speed_comment = self.get_speed_comment(tagger)
if speed_comment is not None: tag_line_strings.append(speed_comment)
speed_comment = self.get_speed_comment(tagged)
if speed_comment is not None: tag_line_strings.append(speed_comment)
self.say(random.choice(tag_line_strings))
# cflewis | 2008-11-26 | Shuffle the color commentary and
# push it to the commentator talking buffer, where it can
# say these things if it has time to
#random.shuffle(tag_line_strings)
#while len(tag_line_strings) > 0:
# self.say(tag_line_strings.pop())
def get_speed_comment(self, character):
average_speed = self.database.get_average_speed(character.getName())
print "Average speed is %s, and actual speed is %s" % (average_speed, character.getActualSpeed())
if character.getActualSpeed() > (average_speed + 10):
return self.lines.get_faster_than_average_line() % \
{'character': character.getName(), 'speed': average_speed}
if character.getActualSpeed() < (average_speed - 10):
return self.lines.get_slower_than_average_line() % \
{'character': character.getName(), 'speed': average_speed}
# cflewis | 2008-11-26 | Nothing interesting to say about this
return None
def say(self, comment):
print comment
#os.system('say "' + comment +' " &')
self.talker.addComment(comment)
def clean_up(self):
self.talker.end()
class HClient:
"""
HClient is another alternative to IRCClient. This only connects to HServer.
The difference between this and IRCClient is that, for this, user will need
to specify the listening port that this program will bind to.
Example:
c = HClient(host, port)
c.connect_server(dhost, dport)
c.set_username(user)
while True:
line = raw_input()
c.on_typing(line)
"""
def __init__(self, host, port, dhost = '', dport = 0):
self.host = host
self.port = port
self.dhost = dhost
self.dport = dport
self.prev_cmd = ''
self.user = ''
self.msg_id = 0
self.ack_status = {}
self.irc_mode = False
self.parser = Parser()
self.tk = Talker(self.host, self.port)
self.ln = Listener(self.host, self.port)
thread.start_new_thread(self.ln.listening, (self.receive_packet,))
if self.dhost and self.dport:
self.connect_server(self.dhost, self.dport)
def on_typing(self, line):
"""
Process what user types.
Args:
line: input from user.
"""
msg = self.parser.parse(line)
if(msg.type == Message.COMMAND):
self.dispatch_command(msg)
elif msg.type == Message.MESSAGE:
self.say(msg)
def set_username(self, newname):
"""
Set nickname
"""
if not self.dhost or not self.dport:
self.user = newname
else:
self.request_change_name(newname)
def request_change_name(self, newname):
"""
Request to change a new username. This method will BLOCK until it completes
either successfully or unsuccessfully.
Args:
newname (string): new username.
"""
msg = Message("%s %s"%(self.user, newname), Message.CHANGE_NAME,
origin = (self.host, self.port),
destination = (self.dhost, self.dport))
self.increment_msg_id(msg)
self.ack_status[msg.id] = MessageStatus.PENDING
self.tk.talk(pickle.dumps(msg), self.dhost, self.dport)
while self.ack_status[msg.id] is MessageStatus.PENDING:
pass
if self.ack_status[msg.id] is MessageStatus.SUCCESS:
self.ack_status.pop(msg.id)
return True
else:
self.ack_status.pop(msg.id)
return False
def increment_msg_id(self, msg):
"""
Give each message a unique message ID.
Args:
msg (Message): the message to assign ID for.
"""
msg.id = self.msg_id
self.msg_id += 1
def connect_server(self, dest_host, dest_port):
"""
Join a chat server.
Args:
dest_host (string): address of server.
dest_port (int): port of server.
"""
self.dhost = dest_host
self.dport = dest_port
if not self.user:
self.user = '******'
msg = Message(self.user, Message.JOIN, origin = (self.host, self.port),
destination =(self.dhost, self.dport))
self.tk.talk(pickle.dumps(msg), self.dhost, self.dport)
def leave_server(self):
"""
Leave a chat server. This function resets the dhost and dport.
Args:
talker (Talker): the network worker that executes the sending of packet.
"""
msg = Message(self.user, Message.LEAVE, (self.host, self.port),
(self.dhost, self.dport))
self.tk.talk(pickle.dumps(msg), self.dhost, self.dport)
self.dhost = ''
self.dport = 0
def say(self, msg):
"""
Broadcast a message.
Args:
msg (Message): message to broadcast.
"""
if not self.dhost or not self.dport:
print 'You need to connect to a HServer.'
msg.origin = (self.host, self.port)
msg.destination = (self.dhost, self.dport)
msg.author = self.user
self.increment_msg_id(msg)
self.tk.talk(pickle.dumps(msg), self.dhost, self.dport)
def dispatch_command(self, msg):
"""
Dispatch the command. Called when user type a command.
Args:
msg (Message): message that contains the command, after parsed.
"""
if msg.cmd_args[0] == 'JOIN':
dest_host = msg.cmd_args[1]
dest_port = int(msg.cmd_args[2])
self.connect_server(dest_host, dest_port)
elif msg.cmd_args[0] == 'NICK':
# this will block until username is changed, or unsuccessfully
# reported by the server.
if self.dhost and self.dport:
status = self.request_change_name(msg.cmd_args[1])
else:
status = True
if status is True:
print '>>> change successfully'
self.user = msg.cmd_args[1]
else:
print '>>> change of username unsuccessfully'
elif msg.cmd_args[0] == 'LEAVE':
self.leave_server()
def process_packet(self, data):
"""
Process a packet after receiving.
Args:
data (Object): data that has been deserialized by pickle.
"""
if data.type is Message.BROADCAST:
print "%s: %s" %(data.author, data.msg)
elif data.type is Message.ACK:
self.ack_status[data.id] = MessageStatus.SUCCESS
elif data.type is Message.FAIL:
self.ack_status[data.id] = MessageStatus.FAIL
def receive_packet(self, data):
"""
Callback function when listener receives a packet.
Args:
data (Object): data that has been deserialized by pickle.
"""
self.process_packet(pickle.loads(data))
if step['type'] == 'AUDIO_FILE':
player.play(step['file'], step['thread'], delay)
else:
text = talker.process(step)
talker.say(text, delay)
path = os.path.dirname(os.path.realpath(__file__))
with open(path + '/../config.toml') as config_file:
config = toml.loads(config_file.read())
os.environ['GOOGLE_APPLICATION_CREDENTIALS'] = config['google_credentials']
audio_cmd = config['audio_cmd']
weekdays = config.get('weekdays', DEFAULT_WEEKDAYS)
lang = config.get('lang', 'en-US')
gender = config.get('gender', 'NEUTRAL')
speaking_rate = config.get('speaking_rate', 0.85)
pitch = config.get('pitch', 0)
talker = Talker(audio_cmd, weekdays, lang, gender, speaking_rate, pitch)
player = Player(audio_cmd)
for step in config['steps']:
validator.validateStep(step)
for step in config['steps']:
runStep(step)
from random import randint
from talker import Talker
if __name__ == '__main__':
talker = Talker()
talker.talk_to_the_quote_extractor()
talker.parse_quotes()
tag_list = talker.get_tags()
while True:
print('Are you feeling like geting a particular quote?')
print('You can give me sentences, I can manage.')
desired_tag = input('')
# if any(word in 'I want some love' for word in tag_list):
tag_found = False
for tag in tag_list:
if tag in desired_tag:
quote_tag = tag
tag_found = True
break
if not tag_found:
quote_tag = 'popular'
print('I guess I\'ll just give you one of the popular quotes')
raw_id = input('\nDo you have a particular number in mind? (make it less that 100): ')
try:
int(raw_id)
page_id = int(raw_id)
