class AllStreamerOverviewsDataPagination:
def __init__(self, game_name, per_page=10):
self.game_name = game_name
self.page = 1
self.per_page = per_page
self.max_page = 0
self.data_list_length = 0
self.pages = []
self.db = None
def run(self):
# Open a DB connection
db_path = os.path.join(os.getcwd(), 'data', self.game_name, '{}_data.db'.format(self.game_name))
self.db = Pysqlite(database_name='{} Page DB'.format(self.game_name), database_file=db_path)
def get_page(self, page_number):
# figure out which indices relate to that page
# page_number is NOT zero indexed, so we subtract 1 to make it zero indexed
# lower bound: (page_number - 1) * self.per_page
# upper bound: (page_number - 1) * self.per_page + (self.per_page - 1)
# EXAMPLE:
# I want page 2 (which is actually page 1, since -1) and I show 10 per page. Page 1's bounds are 10 -> 19, thus:
# (2 - 1) * 10 = 10 for the lower bound
# (2 - 1) * 10 + (10 - 1) = 10 + 9 = 19 for the upper bound
page_indices = {
'lower': (page_number - 1) * self.per_page,
'upper': (page_number - 1) * self.per_page + (self.per_page - 1)
}
# get the streamer overviews, ordered by average viewership
ordered_data = self.db.get_specific_rows(
table='streamers_data',
filter_string='id IS NOT NULL ORDER BY viewers_average DESC')
self.data_list_length = len(ordered_data)
page_data = ordered_data[page_indices['lower']:page_indices['upper']]
# map that data to dictionaries
streamer_dicts = [
{
'name': streamer[1],
'last_update': streamer[2],
'viewers_average': streamer[3],
'viewers_peak': streamer[4],
'followers': streamer[5],
'stream_count': streamer[6],
'viewer_reach': int(streamer[3] * convert_to_hours(streamer[8])),
'duration_average': convert_to_hours(streamer[7]),
'duration_total': convert_to_hours(streamer[8]),
'partnership': streamer[10]
} for streamer in page_data
]
return streamer_dicts
def get_page_count(self):
return int(ceil(self.data_list_length / float(self.per_page)))
def has_previous_page(self):
return self.page > 1
def has_next_page(self):
return self.page < self.get_page_count()
class NewsArticlesPagination:
def __init__(self, per_page=4):
self.page = 1
self.per_page = per_page
self.data_list_length = 0
self.db = None
def run(self):
# Open a DB connection
db_path = os.path.join(os.getcwd(), 'meta', 'news.db')
self.db = Pysqlite(database_name='News DB', database_file=db_path)
def get_page(self, page_number):
# figure out which indices relate to that page
# page_number is NOT zero indexed, so we subtract 1 to make it zero indexed
# lower bound: (page_number - 1) * self.per_page
# upper bound: (page_number - 1) * self.per_page + (self.per_page - 1)
# EXAMPLE:
# I want page 2 (which is actually page 1, since -1) and I show 10 per page. Page 1's bounds are 10 -> 19, thus:
# (2 - 1) * 10 = 10 for the lower bound
# (2 - 1) * 10 + (10 - 1) = 10 + 9 = 19 for the upper bound
page_indices = {
'lower': (page_number - 1) * self.per_page,
'upper': (page_number - 1) * self.per_page + (self.per_page - 1)
}
# get an ordered list of stream overviews
ordered_data = self.db.get_specific_rows(
table='articles',
filter_string='id IS NOT NULL ORDER BY timestamp DESC')
self.data_list_length = len(ordered_data)
page_data = ordered_data[page_indices['lower']:page_indices['upper']]
# map that data to dictionaries
article_dicts = [
{
'id': article[0],
'date_written': article[1].split(' ')[0], # pass only the date part and not the time
'title': article[2],
'contents': article[3][:150] + '...', # truncate the contents string up to the first 150 characters
'word_count': int(article[4]),
# TODO: Implement not showing the article if it is not marked as published
'published': True if int(article[5]) == 1 else 0
} for article in page_data
]
return article_dicts
def get_page_count(self):
return int(ceil(self.data_list_length / float(self.per_page)))
def has_previous_page(self):
return self.page > 1
def has_next_page(self):
return self.page < self.get_page_count()
class GameGlobalData:
def __init__(self, game_url_name):
self.game_url_name = game_url_name
self.global_data_list = []
short_name = convert_name('url', self.game_url_name, 'short')
self.db_path = os.path.join(os.getcwd(), 'data', short_name, '{}_data.db'.format(short_name))
self.db = Pysqlite(database_name='{} Global Overview DB'.format(self.game_url_name), database_file=self.db_path)
def return_global_overview_dict(self):
row = self.db.get_specific_rows(table='global_data', filter_string='id = (SELECT MAX(id) FROM global_data)')
data_list = list(row[0])
game_dict = {
'last_updated': data_list[1],
'streamer_count': data_list[2],
'stream_count': data_list[3],
'stream_duration_average': convert_to_hours(data_list[4]),
'stream_duration_total': convert_to_hours(data_list[5]),
'stream_duration_max': convert_to_hours(data_list[6])
}
return game_dict
def return_tier_bounds(self):
tier_bounds = self.db.get_all_rows(table='tier_bounds')
tier_bounds_dict = [{'tier': bound[1], 'upper': bound[2], 'lower': bound[3]} for bound in tier_bounds]
return tier_bounds_dict
def return_tier_streamers(self):
streamer_tiers = self.db.get_all_rows(table='tier_data')
streamer_tiers_dict = dict()
for index, streamer, tier in streamer_tiers:
streamer_tiers_dict[streamer] = tier
return streamer_tiers_dict
def return_tier_count(self, tier_number=0):
streamer_tiers = self.db.get_all_rows(table='tier_data')
return len([tier for tier in streamer_tiers if tier[2] == tier_number])
def return_tier_counts(self):
tier_count_list = []
tier_bounds = self.db.get_all_rows(table='tier_bounds')
for i in range(1, len(tier_bounds) + 1):
tier_count_list.append(self.return_tier_count(tier_number=i))
return tier_count_list
class StreamData:
def __init__(self, streamer_name, game_name, stream_id):
self.streamer_name = streamer_name
self.game_name = game_name
self.stream_id = int(stream_id) - 1 # Backend is zero indexed, frontend is not
self.max_stream_id = 0
self.db = None
def run(self):
# Open a DB connection
db_path = os.path.join(os.getcwd(), 'data', self.game_name, 'streamers', '{}.db'.format(self.streamer_name))
self.db = Pysqlite(database_name='{} {} DB'.format(self.game_name, self.streamer_name), database_file=db_path)
# set the max stream id
self.max_stream_id = len(self.db.get_table_names()) - 3
def get_stream_data(self):
stream_overview_row = self.db.get_specific_rows(
table='streams',
filter_string='id IS {}'.format(self.stream_id + 1)) # the db index is also not zero indexed... an oversight I know
stream_dict = {
'id': self.stream_id + 1,
'max_id': self.max_stream_id,
'time_start': stream_overview_row[0][1],
'duration': convert_to_hours(stream_overview_row[0][2]),
'viewers_average': stream_overview_row[0][3],
'viewers_peak': stream_overview_row[0][4],
'follower_delta': stream_overview_row[0][5]
}
return stream_dict
def get_stream_raw_data(self):
raw_stream_data = self.db.get_all_rows(table='stream_{}'.format(self.stream_id))
return raw_stream_data
def get_stream_viewer_data_json(self):
# Timestamp in the X axis, viewer count in the Y axis
data = [
[row[1], row[2]] for row in self.get_stream_raw_data()
]
return json.dumps(data)
class NewsArticle:
def __init__(self, article_number=1):
self.article_number = article_number
self.db_path = os.path.join(os.getcwd(), 'meta', 'news.db')
self.db = Pysqlite(database_name='News DB', database_file=self.db_path)
def get_article(self):
# get the article data by the ID
article = self.db.get_specific_rows(
table='articles',
filter_string='id IS {}'.format(self.article_number))[0]
# map that data to dictionaries
article_dict = {
'id': article[0],
'date_written': article[1].split(' ')[0], # pass only the date part and not the time
'title': article[2],
'contents': article[3],
'word_count': int(article[4]),
# TODO: Implement not showing the article if it is not marked as published
'published': True if int(article[5]) == 1 else 0
}
return article_dict
class StreamsDataPagination:
def __init__(self, game_name, streamer_name, per_page=10):
self.game_name = game_name
self.streamer_name = streamer_name
self.page = 1
self.per_page = per_page
self.data_list_length = 0
self.db = None
def run(self):
# Open a DB connection
db_path = os.path.join(os.getcwd(), 'data', self.game_name, 'streamers', '{}.db'.format(self.streamer_name))
self.db = Pysqlite(database_name='{} {} DB'.format(self.game_name, self.streamer_name), database_file=db_path)
def get_page(self, page_number):
# figure out which indices relate to that page
# page_number is NOT zero indexed, so we subtract 1 to make it zero indexed
# lower bound: (page_number - 1) * self.per_page
# upper bound: (page_number - 1) * self.per_page + (self.per_page - 1)
# EXAMPLE:
# I want page 2 (which is actually page 1, since -1) and I show 10 per page. Page 1's bounds are 10 -> 19, thus:
# (2 - 1) * 10 = 10 for the lower bound
# (2 - 1) * 10 + (10 - 1) = 10 + 9 = 19 for the upper bound
page_indices = {
'lower': (page_number - 1) * self.per_page,
'upper': (page_number - 1) * self.per_page + (self.per_page - 1)
}
# get an ordered list of stream overviews
ordered_data = self.db.get_specific_rows(
table='streams',
filter_string='id IS NOT NULL ORDER BY timestamp DESC')
self.data_list_length = len(ordered_data)
page_data = ordered_data[page_indices['lower']:page_indices['upper']]
# map that data to dictionaries
stream_dicts = [
{
'id': stream[0],
'start_time': stream[1],
'duration': convert_to_hours(stream[2]),
'viewers_average': stream[3],
'viewers_peak': stream[4],
'follower_delta': stream[5],
} for stream in page_data
]
return stream_dicts
def get_all_streams_dicts(self):
ordered_data = self.db.get_specific_rows(
table='streams',
filter_string='id IS NOT NULL ORDER BY timestamp DESC')
stream_dicts = [
{
'id': stream[0],
'start_time': stream[1],
'duration': convert_to_hours(stream[2]),
'viewers_average': stream[3],
'viewers_peak': stream[4],
'follower_delta': stream[5],
} for stream in ordered_data
]
return stream_dicts
def get_average_viewer_count_dicts(self):
stream_dicts = self.get_all_streams_dicts()
return [
{
'start_time': stream['start_time'],
'viewers_average': stream['viewers_average']
} for stream in stream_dicts
]
def get_page_count(self):
return int(ceil(self.data_list_length / float(self.per_page)))
def has_previous_page(self):
return self.page > 1
def has_next_page(self):
return self.page < self.get_page_count()
