def create_normalize_event(e_i, e_j):
"""
created temp Event instance base on e_i and e_j members or None:
exp: e_i = Events('First', 'Second and some', 'some_url_1'),
e_j = Events('Second', 'Some and First', 'some_url_2')
will be returned: Events('First', 'Second', 'TEMP EVENT')
:param e_i: Event instance
:param e_j: Event instance
:return:
"""
a1 = e_i.first_member.lower()
a2 = e_i.second_member.lower()
a3 = e_j.first_member.lower()
a4 = e_j.second_member.lower()
first = ''
second = ''
if a1 in a3 or a3 in a1:
first = a1 if len(a1) < len(a3) else a3
second = a2 if len(a2) < len(a4) else a4
if a1 in a4 or a4 in a1:
first = a1 if len(a1) < len(a4) else a4
second = a2 if len(a2) < len(a3) else a3
if not first or not second:
return None
sorted_members = sorted([first, second])
first = sorted_members[0]
second = sorted_members[1]
logger.info('Created normalized: {f} - {s}: {url}'.format(f=first, s=second, url='NORMALIZED_EVENT'))
return Event(first_member=first, second_member=second, url='NORMALIZED_EVENT')
def parse_data(json_data):
"""parse the json file into Event object
* Qualy: starting grid is based on qualy
* Race: starting grid is based on the selected lap
the method may ask for user input
Args:
json_data ([type]): json dict of server dump
Returns:
[type]: Event Object
"""
ev = Event()
ev.name = json_data['trackName']
leaders = json_data['sessionResult']['leaderBoardLines']
i = 1
for team_json in leaders:
car = team_json['car']
team = Team()
team.defaultGridPosition = i
team.forcedCarModel = car['carModel']
team.raceNumber = car['raceNumber']
team.carId = car['carId']
for driver in car['drivers']:
d = Driver()
d.firstName = driver['firstName']
d.lastName = driver['lastName']
d.shortName = driver['shortName']
d.playerID = driver['playerId']
team.drivers.append(d)
ev.teams.append(team)
i += 1
if json_data['sessionType'] == 'Q':
print('detected Qualy session')
return ev
elif json_data['sessionType'] == 'R':
print('detected Race session')
return parse_race_abort(json_data, ev)
else:
print('unsupported session type, applying qualy procedure')
return ev
return ev
def create_event(username, title, members,
event_length=None, event_deadline=None):
"""
Create an event with the given details.
Parameters:
username (str): username of event creator
title (str): name of event
members ([str]): list of usernames of additional event members
event_length (int): event length in hours
event_deadline (datetime.date): latest desired event date
Returns:
event_id (int): unique ID of new event
Exceptions:
AuthError if any of:
the user is not logged in
InputError if any of:
username does not exist
a username in the members list does not exist
title is longer than 100 characters or empty
event_length is less than 1 or greater than 14 * 24 (fortnight)
event_deadline is a date in the past
"""
check_username(username)
for u in members:
check_username(u)
check_logged_in(username)
if not len(title) or len(title) > MAX_TITLE:
raise InputError("Title length is invalid")
if (event_length != None and
(event_length < MIN_EVENT or event_length > MAX_EVENT)):
raise InputError("Event length is invalid")
if event_deadline and event_deadline < datetime.now().date():
raise InputError("Event deadline is invalid")
new_event = Event(data.event_next_id, title, username)
data.event_next_id += 1
for u in members:
new_event.member_usernames.add(u)
new_event.event_length = event_length
new_event.event_deadline = event_deadline
data.events[new_event.event_id] = new_event
return new_event.event_id
def parse_html_element_to_event(html):
import re
findings = re.search(r'title=\".{1,200}\"\shref=\"(/.{1,50}){1,20}\">', html)
if not findings:
logger.warning('Could not parse HTML element via regex')
return None
title_and_href_parts = findings.group(0).split('href=')
raw_title = title_and_href_parts[0].split('title')[1].strip()
raw_title = raw_title.replace('\"', '')
first, second = raw_title.split(' - ')
raw_href = re.sub(r'[\">]', '', title_and_href_parts[1])
url = 'https://winline.ru{appendix}'.format(appendix=raw_href)
e = Event(first_member=first, second_member=second, url=url)
logger.info('Created: %s' % e)
return e
def __init__(self, command_prefix='!'):
self.socket = socket()
self.connected = False
self.command_prefix = command_prefix
self.on_message_received = Event()
self.on_message_sent = Event()
self.on_whisper_received = Event()
self.on_whisper_sent = Event()
self.on_command_executed = Event()
self.on_command_triggered = Event()
def parse_element_to_event(element):
"""
extract data from DOM-element
:param element: DOM-object, WebElement type
:return: event object
"""
title = ''
try:
url = element.get_attribute("href")
title = element.get_attribute("title")
first, second = title.split(" - ")
logger.info('Created: {}/{}:[{}]'.format(first, second, url))
if not (url and first and second):
logger.error('Some info parsed as empty string: [{f}][{s}][{url}]'.format(f=first, s=second, url=url))
return Event(first, second, url)
except Exception as e:
logger.error('Could not took some info from element (title-[{title}]): {err}. None will be returned.'
.format(err=e, title=title))
return None
def create_event(self, arg):
'''
creates a new event instance
'''
# creating a new event from Event class
event_name = arg['<name>']
start_date = datetime.strptime(arg['<start_date>'], "%d-%m-%Y" )
end_date = datetime.strptime(arg['<end_date>'], "%d-%m-%Y" )
venue = arg['<venue>']
event = Event(name=event_name, start_date=start_date, end_date=end_date, venue=venue)
try:
# add event object to session for db commit
Tickets.session.add(event)
Tickets.session.commit()
return "Event created"
except Exception as e:
print (e)
raise e
def parse_server_result(file):
if file is None or not os.path.exists(file):
print('couldn\'t locate file ' + file)
return None
ev = Event()
try:
with open(file, 'r') as json_utf8:
json_lines = json_utf8.readlines()
json_str = ' '.join(json_lines)
data = json.loads(json_str)
except json.JSONDecodeError:
with open(file, 'r', encoding='utf_16_le') as json_utf16:
json_lines = json_utf16.readlines()
json_str = ' '.join(json_lines)
data = json.loads(json_str)
event = serverResult.parse_data(data)
return event
async def parse_config(suppress_message=False):
async for message in config.config_channel.history(limit=None):
try:
if message.content.startswith("On deck emoji"):
config.on_deck = message.content.split(" ")[-1]
elif message.content.startswith("Approve emoji"):
config.approve = message.content.split(" ")[-1]
elif message.content.startswith("Event"):
_, day, name, tz, start, *_ = message.content.split(",")
channel = message.channel_mentions[0]
host = message.mentions[0]
event = Event(day.strip(), name.strip(), tz.strip(),
start.strip(), channel, host)
config.events.append(event)
elif message.content.startswith("Respond in"):
config.response_channel = message.channel_mentions[0]
elif message.content.startswith("Voice template"):
config.voice_template = message.channel_mentions[0]
except:
pass
if not suppress_message:
await config.response_channel.send("Ingested new configuration")
def test_for_object_instance(self):
event = Event(1, 'birthday', 11 - 11 - 2016, 18 - 11 - 2016)
self.assertIsInstance(event, Event, msg="Check class Instance")
