class FantasySeasonInitializer:
def __init__(self):
self.data_loader = DataLoader()
self.query_tool = QueryTool()
def _clean_database(self) -> None:
"""Clean the database at the beginning of a season
By "cleaning" we mean deleting all the data from the `teams`, `rosters`,
and `match_ups` tables. We don't want to track this data year over year so we can just refresh them.
"""
tables_to_clean = ("rosters", "match_ups", "teams")
for table in tables_to_clean:
print(f"Cleaning {table}")
query = f"DELETE FROM {table};"
self.query_tool.delete(query)
def initialize_season(self) -> None:
"""Initialize the database for a new Fantasy Basketball season
Initializing a season consists of cleaning the database, then uploading all the
data that we get from Yahoo. Lastly we upload the NBA schedule from Basketball Reference
and the player salaries from Spotrac
"""
self._clean_database()
self.data_loader.load_players_and_nba_teams()
self.data_loader.load_teams_and_rosters()
self.data_loader.load_matchups()
self.data_loader.load_schedule()
self.data_loader.load_salaries()
def test_loader_read_id_length(data_filepath):
test_name = test_loader_read_id_length.__name__
expected = len('002f0f2d-ffc1-4072-82d3-6ce425d9724e')
loader = DataLoader(data_filepath)
actual = len(loader.load_read_ids()[0])
result = AssertThat(actual, expected).are_equal()
print_test_result(result, test_name, expected, actual)
def test_loader_read_id_list_length(data_filepath):
test_name = test_loader_read_id_list_length.__name__
expected = 5
loader = DataLoader(data_filepath)
reads = loader.load_read_ids()
actual = len(reads)
result = AssertThat(actual, expected).are_equal()
print_test_result(result, test_name, expected, actual)
def test_loader_read_dacs_is_normilized(data_filepath):
test_name = test_loader_read_dacs_is_normilized.__name__
loader = DataLoader(data_filepath)
read_id = loader.load_read_ids()[0]
dacs, _, _ = loader.load_read(read_id)
arr = np.array(dacs)
actual = np.std(arr)
result = AssertThat(actual).is_in_interval(0.99, 1.01)
print_test_result(result, test_name,
"std of signal to be < 1.3 and > 0.7.", actual)
def test_loader_read_dacs_list_elemnt(data_filepath):
test_name = test_loader_read_dacs_list_elemnt.__name__
expected = np.float64
loader = DataLoader(data_filepath)
read_id = loader.load_read_ids()[0]
dacs, _, _ = loader.load_read(read_id)
actual = type(dacs[0])
result = AssertThat(actual, expected).are_equal()
print_test_result(result, test_name, expected, actual)
class MidSeasonUpdater:
def __init__(self):
self.query_tool = QueryTool()
self.data_loader = DataLoader()
def _clean_rosters(self) -> None:
"""Clean the rosters table before they are re-uploaded from Yahoo"""
print("Cleaning rosters")
query = "DELETE FROM rosters;"
self.query_tool.delete(query)
def update_season(self) -> None:
"""Update the database mid-season.
This consists of:
- Updating the players table to add any new players and update their statuses
- Reloading the salaries
- Updating the teams in case someone changed their team name
- Reloading the rosters
- Loading any new game logs
"""
self._clean_rosters()
self.data_loader.load_players_and_nba_teams()
self.data_loader.load_salaries()
self.data_loader.load_teams_and_rosters()
self.data_loader.load_game_logs()
def test_main():
d_loader = DataLoader(
'/home/yhsu/Desktop/EDGAR/insight_testsuite/tests/test_1/input')
s_tracker = SessionMonitor(
2,
'/home/yhsu/Desktop/EDGAR/insight_testsuite/tests/test_1/output/sessionization2.txt'
)
data = d_loader.get_next_data()
while data is not None:
s_tracker.process_data(data)
data = d_loader.get_next_data()
s_tracker.reach_EOF()
def main(argv):
in_csv_fpath = argv[0]
inact_period_fpath = argv[1]
output_fpath = argv[2]
with open(inact_period_fpath, 'r') as file:
line = file.readline()
timeout = int(line.strip())
d_loader = DataLoader(in_csv_fpath)
s_tracker = SessionMonitor(timeout, output_fpath)
data = d_loader.get_next_data()
while data is not None:
s_tracker.process_data(data)
data = d_loader.get_next_data()
s_tracker.reach_EOF()
def run_tests():
batch_size = 32
buffer_size = 5
signal_window_size = 300
signal_window_stride = 30
min_labels_per_window = 1
label_window_size = 100
loader = DataLoader('./data/test_data.hdf5')
buffer = DataBuffer(loader, buffer_size, batch_size, signal_window_size,
signal_window_stride)
test_generator_get_batch_x_shape(buffer, label_window_size)
test_generator_get_batch_y_shape(buffer, label_window_size)
test_generator_get_batch_y_start_token(buffer, label_window_size)
test_generator_get_batch_y_end_token(buffer, label_window_size)
test_generator_get_batch_y_padding(buffer, label_window_size)
test_generator_get_batched_read_x_shape(buffer, label_window_size)
def __init__(self):
self.data_loader = DataLoader()
self.query_tool = QueryTool()
def get_loader(config, key='training'):
data_path = config[key]['data']
return DataLoader(data_path)
def run_tests():
data_loader = DataLoader('./data/test_data.hdf5')
test_buffer_get_batch_x_shape(data_loader)
test_buffer_get_batch_y_shape(data_loader)
test_buffer_get_batched_read_x_shape(data_loader)