merged data and pull functions into Client class,

removed pull.py dep.py,
modified existing code to work with new Client class

src/config.py

@@ -2,8 +2,6 @@ import json
 from exceptions import ConfigurationError
 from cerberus import Validator
 
-from data import set_database_config, get_database_config
-
 class Configuration:
 
 	path = None
@@ -215,14 +213,14 @@ class Configuration:
 		if sync:
 			if priority == "local" or priority == "client":
 				logger.info("config-preference set to local/client, loading local config information")
-				remote_config = get_database_config(client)
+				remote_config = client.get_database_config()
 				if remote_config != self.config["variable"]:
-					set_database_config(client, self.config["variable"])
+					client.set_database_config(self.config["variable"])
 					logger.info("database config was different and was updated")
 				# no change to config
 			elif priority == "remote" or priority == "database":
 				logger.info("config-preference set to remote/database, loading remote config information")
-				remote_config = get_database_config(client)
+				remote_config = client.get_database_config()
 				if remote_config != self.config["variable"]:
 					self.config["variable"] = remote_config
 					self.save_config()
@@ -236,7 +234,7 @@ class Configuration:
 				# no change to config
 			elif priority == "remote" or priority == "database":
 				logger.info("config-preference set to remote/database, loading database config information")
-				self.config["variable"] = get_database_config(client)
+				self.config["variable"] = client.get_database_config()
 				# change variable to match remote without updating local version
 			else:
 				raise ConfigurationError("persistent/config-preference field must be \"local\"/\"client\" or \"remote\"/\"database\"")

src/data.py

@@ -1,199 +1,296 @@
 import requests
-import pull
 import pandas as pd
+import pymongo
+from exceptions import APIError
 
-def pull_new_tba_matches(apikey, competition, cutoff):
+class Client:
-	api_key= apikey 
-	x=requests.get("https://www.thebluealliance.com/api/v3/event/"+competition+"/matches/simple", headers={"X-TBA-Auth-Key":api_key})
-	out = []
-	for i in x.json():
-		if i["actual_time"] != None and i["actual_time"]-cutoff >= 0 and i["comp_level"] == "qm":
-			out.append({"match" : i['match_number'], "blue" : list(map(lambda x: int(x[3:]), i['alliances']['blue']['team_keys'])), "red" : list(map(lambda x: int(x[3:]), i['alliances']['red']['team_keys'])), "winner": i["winning_alliance"]})
-	return out
 
-def get_team_match_data(client, competition, team_num):
+	def __init__(self, config):
-	db = client.data_scouting
+		self.competition = config.competition
-	mdata = db.matchdata
+		self.tbakey = config.tba
-	out = {}
+		self.mongoclient = pymongo.MongoClient(config.database)
-	for i in mdata.find({"competition" : competition, "team_scouted": str(team_num)}):
+		self.trakey = config.tra
-		out[i['match']] = i['data']
-	return pd.DataFrame(out)
 
-def get_team_pit_data(client, competition, team_num):
+	def close(self):
-	db = client.data_scouting
+		self.mongoclient.close()
-	mdata = db.pitdata
-	out = {}
-	return mdata.find_one({"competition" : competition, "team_scouted": str(team_num)})["data"]
 
-def get_team_metrics_data(client, competition, team_num):
+	def pull_new_tba_matches(self, cutoff):
-	db = client.data_processing
+		competition = self.competition
-	mdata = db.team_metrics
+		api_key= self.tbakey 
-	return mdata.find_one({"competition" : competition, "team": team_num})
+		x=requests.get("https://www.thebluealliance.com/api/v3/event/"+competition+"/matches/simple", headers={"X-TBA-Auth-Key":api_key})
+		out = []
+		for i in x.json():
+			if i["actual_time"] != None and i["actual_time"]-cutoff >= 0 and i["comp_level"] == "qm":
+				out.append({"match" : i['match_number'], "blue" : list(map(lambda x: int(x[3:]), i['alliances']['blue']['team_keys'])), "red" : list(map(lambda x: int(x[3:]), i['alliances']['red']['team_keys'])), "winner": i["winning_alliance"]})
+		return out
 
-def get_match_data_formatted(client, competition):
+	def get_team_match_data(self, team_num):
-	teams_at_comp = pull.get_teams_at_competition(competition)
+		client = self.mongoclient
-	out = {}
+		competition = self.competition
-	for team in teams_at_comp:
+		db = client.data_scouting
-		try:
+		mdata = db.matchdata
-			out[int(team)] = unkeyify_2l(get_team_match_data(client, competition, team).transpose().to_dict())
+		out = {}
-		except:
+		for i in mdata.find({"competition" : competition, "team_scouted": str(team_num)}):
-			pass
+			out[i['match']] = i['data']
-	return out
+		return pd.DataFrame(out)
 
-def get_metrics_data_formatted(client, competition):
+	def get_team_metrics_data(self, team_num):
-	teams_at_comp = pull.get_teams_at_competition(competition)
+		client = self.mongoclient
-	out = {}
+		competition = self.competition
-	for team in teams_at_comp:
+		db = client.data_processing
-		try:
+		mdata = db.team_metrics
-			out[int(team)] = get_team_metrics_data(client, competition, int(team))
+		return mdata.find_one({"competition" : competition, "team": team_num})
-		except:
-			pass
-	return out
 
-def get_pit_data_formatted(client, competition):
+	def get_team_pit_data(self, team_num):
-	x=requests.get("https://titanscouting.epochml.org/api/fetchAllTeamNicknamesAtCompetition?competition="+competition)
+		client = self.mongoclient
-	x = x.json()
+		competition = self.competition
-	x = x['data']
+		db = client.data_scouting
-	x = x.keys()
+		mdata = db.pitdata
-	out = {}
+		return mdata.find_one({"competition" : competition, "team_scouted": str(team_num)})["data"]
-	for i in x:
-		try:
-			out[int(i)] = get_team_pit_data(client, competition, int(i))
-		except:
-			pass
-	return out
 
-def get_pit_variable_data(client, competition):
+	def unkeyify_2l(self, layered_dict):
-	db = client.data_processing
+		out = {}
-	mdata = db.team_pit
+		for i in layered_dict.keys():
-	out = {}
+			add = []
-	return mdata.find()
+			sortkey = []
+			for j in layered_dict[i].keys():
+				add.append([j,layered_dict[i][j]])
+			add.sort(key = lambda x: x[0])
+			out[i] = list(map(lambda x: x[1], add))
+		return out
 
-def get_pit_variable_formatted(client, competition):
+	def get_match_data_formatted(self):
-	temp = get_pit_variable_data(client, competition)
+		teams_at_comp = self.get_teams_at_competition()
-	out = {}
+		out = {}
-	for i in temp:
+		for team in teams_at_comp:
-		out[i["variable"]] = i["data"]
+			try:
-	return out
+				out[int(team)] = self.unkeyify_2l(self.get_team_match_data(team).transpose().to_dict())
+			except:
+				pass	
+		return out
 
-def push_team_tests_data(client, competition, team_num, data, dbname = "data_processing", colname = "team_tests"):
+	def get_metrics_data_formatted(self):
-	db = client[dbname]
+		competition = self.competition
-	mdata = db[colname]
+		teams_at_comp = self.get_teams_at_competition()
-	mdata.replace_one({"competition" : competition, "team": team_num}, {"_id": competition+str(team_num)+"am", "competition" : competition, "team" : team_num, "data" : data}, True)
+		out = {}
+		for team in teams_at_comp:
+			try:
+				out[int(team)] = self.get_team_metrics_data(int(team))
+			except:
+				pass
+		return out
 
-def push_team_metrics_data(client, competition, team_num, data, dbname = "data_processing", colname = "team_metrics"):
+	def get_pit_data_formatted(self):
-	db = client[dbname]
+		client = self.mongoclient
-	mdata = db[colname]
+		competition = self.competition
-	mdata.replace_one({"competition" : competition, "team": team_num}, {"_id": competition+str(team_num)+"am", "competition" : competition, "team" : team_num, "metrics" : data}, True)
+		x=requests.get("https://titanscouting.epochml.org/api/fetchAllTeamNicknamesAtCompetition?competition="+competition)
+		x = x.json()
+		x = x['data']
+		x = x.keys()
+		out = {}
+		for i in x:
+			try:
+				out[int(i)] = self.get_team_pit_data(int(i))
+			except:
+				pass
+		return out
 
-def push_team_pit_data(client, competition, variable, data, dbname = "data_processing", colname = "team_pit"):
+	def get_pit_variable_data(self):
-	db = client[dbname]
+		client = self.mongoclient
-	mdata = db[colname]
+		db = client.data_processing
-	mdata.replace_one({"competition" : competition, "variable": variable}, {"competition" : competition, "variable" : variable, "data" : data}, True)
+		mdata = db.team_pit
+		return mdata.find()
 
-def get_analysis_flags(client, flag):
+	def get_pit_variable_formatted(self):
-	db = client.data_processing
+		temp = self.get_pit_variable_data()
-	mdata = db.flags
+		out = {}
-	return mdata.find_one({flag:{"$exists":True}})
+		for i in temp:
+			out[i["variable"]] = i["data"]
+		return out
 
-def set_analysis_flags(client, flag, data):
+	def push_team_tests_data(self, team_num, data, dbname = "data_processing", colname = "team_tests"):
-	db = client.data_processing
+		client = self.mongoclient
-	mdata = db.flags
+		competition = self.competition
-	return mdata.replace_one({flag:{"$exists":True}}, data, True)
+		db = client[dbname]
+		mdata = db[colname]
+		mdata.replace_one({"competition" : competition, "team": team_num}, {"_id": competition+str(team_num)+"am", "competition" : competition, "team" : team_num, "data" : data}, True)
 
-def unkeyify_2l(layered_dict):
+	def push_team_metrics_data(self, team_num, data, dbname = "data_processing", colname = "team_metrics"):
-	out = {}
+		client = self.mongoclient
-	for i in layered_dict.keys():
+		competition = self.competition
-		add = []
+		db = client[dbname]
-		sortkey = []
+		mdata = db[colname]
-		for j in layered_dict[i].keys():
+		mdata.replace_one({"competition" : competition, "team": team_num}, {"_id": competition+str(team_num)+"am", "competition" : competition, "team" : team_num, "metrics" : data}, True)
-			add.append([j,layered_dict[i][j]])
-		add.sort(key = lambda x: x[0])
-		out[i] = list(map(lambda x: x[1], add))
-	return out
 
-def get_previous_time(client):
+	def push_team_pit_data(self, variable, data, dbname = "data_processing", colname = "team_pit"):
+		client = self.mongoclient
+		competition = self.competition
+		db = client[dbname]
+		mdata = db[colname]
+		mdata.replace_one({"competition" : competition, "variable": variable}, {"competition" : competition, "variable" : variable, "data" : data}, True)
 
-	previous_time = get_analysis_flags(client, "latest_update")
+	def get_analysis_flags(self, flag):
+		client = self.mongoclient
+		db = client.data_processing
+		mdata = db.flags
+		return mdata.find_one({flag:{"$exists":True}})
 
-	if previous_time == None:
+	def set_analysis_flags(self, flag, data):
+		client = self.mongoclient
+		db = client.data_processing
+		mdata = db.flags
+		return mdata.replace_one({flag:{"$exists":True}}, data, True)
 
-		set_analysis_flags(client, "latest_update", 0)
+	def get_previous_time(self):
-		previous_time = 0
 
-	else:
+		previous_time = self.get_analysis_flags("latest_update")
 
-		previous_time = previous_time["latest_update"]
+		if previous_time == None:
 
-	return previous_time
+			self.set_analysis_flags("latest_update", 0)
-
+			previous_time = 0
-def set_current_time(client, current_time):
-
-	set_analysis_flags(client, "latest_update", {"latest_update":current_time})
-
-def get_database_config(client):
-
-	remote_config = get_analysis_flags(client, "config")
-	return remote_config["config"] if remote_config != None else None
-
-def set_database_config(client, config):
-
-	set_analysis_flags(client, "config", {"config": config})
-
-def load_match(client, competition):
-
-	return get_match_data_formatted(client, competition)
-
-def load_metric(client, competition, match, group_name, metrics):
-
-	group = {}
-
-	for team in match[group_name]:
-
-		db_data = get_team_metrics_data(client, competition, team)
-
-		if db_data == None:
-
-			elo = {"score": metrics["elo"]["score"]}
-			gl2 = {"score": metrics["gl2"]["score"], "rd": metrics["gl2"]["rd"], "vol": metrics["gl2"]["vol"]}
-			ts = {"mu": metrics["ts"]["mu"], "sigma": metrics["ts"]["sigma"]}
-
-			group[team] = {"elo": elo, "gl2": gl2, "ts": ts}
 
 		else:
 
-			metrics = db_data["metrics"]
+			previous_time = previous_time["latest_update"]
 
-			elo = metrics["elo"]
+		return previous_time
-			gl2 = metrics["gl2"]
-			ts = metrics["ts"]
 
-			group[team] = {"elo": elo, "gl2": gl2, "ts": ts}
+	def set_current_time(self, current_time):
 
-	return group
+		self.set_analysis_flags("latest_update", {"latest_update":current_time})
 
-def load_pit(client, competition):
+	def get_database_config(self):
 
-	return get_pit_data_formatted(client, competition)
+		remote_config = self.get_analysis_flags("config")
+		return remote_config["config"] if remote_config != None else None
 
-def push_match(client, competition, results):
+	def set_database_config(self, config):
 
-	for team in results:
+		self.set_analysis_flags("config", {"config": config})
 
-		push_team_tests_data(client, competition, team, results[team])
+	def load_match(self):
 
-def push_metric(client, competition, metric):
+		return self.get_match_data_formatted()
 
-	for team in metric:
+	def load_metric(self, match, group_name, metrics):
 
-		push_team_metrics_data(client, competition, team, metric[team])
+		group = {}
 
-def push_pit(client, competition, pit):
+		for team in match[group_name]:
 
-	for variable in pit:
+			db_data = self.get_team_metrics_data(team)
-	
-		push_team_pit_data(client, competition, variable, pit[variable])
 
-def check_new_database_matches(client, competition):
+			if db_data == None:
 
-	return True
+				elo = {"score": metrics["elo"]["score"]}
+				gl2 = {"score": metrics["gl2"]["score"], "rd": metrics["gl2"]["rd"], "vol": metrics["gl2"]["vol"]}
+				ts = {"mu": metrics["ts"]["mu"], "sigma": metrics["ts"]["sigma"]}
+
+				group[team] = {"elo": elo, "gl2": gl2, "ts": ts}
+
+			else:
+
+				metrics = db_data["metrics"]
+
+				elo = metrics["elo"]
+				gl2 = metrics["gl2"]
+				ts = metrics["ts"]
+
+				group[team] = {"elo": elo, "gl2": gl2, "ts": ts}
+
+		return group
+
+	def load_pit(self):
+
+		return self.get_pit_data_formatted()
+
+	def push_match(self, results):
+
+		for team in results:
+
+			self.push_team_tests_data(team, results[team])
+
+	def push_metric(self, metric):
+
+		for team in metric:
+
+			self.push_team_metrics_data(team, metric[team])
+
+	def push_pit(self, pit):
+
+		for variable in pit:
+		
+			self.push_team_pit_data(variable, pit[variable])
+
+	def check_new_database_matches(self):
+
+		return True
+
+	#----- API implementations below -----#
+
+	def get_team_competition(self):
+		trakey = self.trakey
+		url = self.trakey['url']
+		endpoint = '/api/fetchTeamCompetition'
+		params = {
+			"CLIENT_ID": trakey['CLIENT_ID'],
+			"CLIENT_SECRET": trakey['CLIENT_SECRET']
+		}
+		response = requests.request("GET", url + endpoint, params=params)
+		json = response.json()
+		if json['success']:
+			return json['competition']
+		else:
+			raise APIError(json)
+
+	def get_team(self):
+		trakey = self.trakey
+		url = self.trakey['url']
+		endpoint = '/api/fetchTeamCompetition'
+		params = {
+			"CLIENT_ID": trakey['CLIENT_ID'],
+			"CLIENT_SECRET": trakey['CLIENT_SECRET']
+		}
+		response = requests.request("GET", url + endpoint, params=params)
+		json = response.json()
+		if json['success']:
+			return json['team']
+		else:
+			raise APIError(json)
+
+	""" doesn't seem to be functional:
+	def get_team_match_data(self, team_num):
+		trakey = self.trakey
+		url = self.trakey['url']
+		competition = self.competition
+		endpoint = '/api/fetchAllTeamMatchData'
+		params = {
+			"competition": competition,
+			"teamScouted": team_num,
+			"CLIENT_ID": trakey['CLIENT_ID'],
+			"CLIENT_SECRET": trakey['CLIENT_SECRET']
+		}
+		response = requests.request("GET", url + endpoint, params=params)
+		json = response.json()
+		if json['success']:
+			return json['data'][team_num]
+		else:
+			raise APIError(json)"""
+
+	def get_teams_at_competition(self):
+		trakey = self.trakey
+		url = self.trakey['url']
+		competition = self.competition
+		endpoint = '/api/fetchAllTeamNicknamesAtCompetition'
+		params = {
+			"competition": competition,
+			"CLIENT_ID": trakey['CLIENT_ID'],
+			"CLIENT_SECRET": trakey['CLIENT_SECRET']
+		}
+		response = requests.request("GET", url + endpoint, params=params)
+		json = response.json()
+		if json['success']:
+			return list(json['data'].keys())
+		else:
+			raise APIError(json)

src/dep.py

@@ -1,141 +0,0 @@
-# contains deprecated functions, not to be used unless nessasary!
-
-import json
-
-sample_json = """
-{
-   "persistent":{
-      "key":{
-         "database":"",
-         "tba":"",
-         "tra":{
-            "CLIENT_ID":"",
-            "CLIENT_SECRET":"",
-			"url": ""
-         }
-      },
-      "config-preference":"local",
-      "synchronize-config":false
-   },
-   "variable":{
-      "max-threads":0.5,
-      "team":"",
-      "event-delay":false,
-      "loop-delay":0,
-      "reportable":true,
-      "teams":[
-         
-      ],
-      "modules":{
-         "match":{
-            "tests":{
-               "balls-blocked":[
-                  "basic_stats",
-                  "historical_analysis",
-                  "regression_linear",
-                  "regression_logarithmic",
-                  "regression_exponential",
-                  "regression_polynomial",
-                  "regression_sigmoidal"
-               ],
-               "balls-collected":[
-                  "basic_stats",
-                  "historical_analysis",
-                  "regression_linear",
-                  "regression_logarithmic",
-                  "regression_exponential",
-                  "regression_polynomial",
-                  "regression_sigmoidal"
-               ],
-               "balls-lower-teleop":[
-                  "basic_stats",
-                  "historical_analysis",
-                  "regression_linear",
-                  "regression_logarithmic",
-                  "regression_exponential",
-                  "regression_polynomial",
-                  "regression_sigmoidal"
-               ],
-               "balls-lower-auto":[
-                  "basic_stats",
-                  "historical_analysis",
-                  "regression_linear",
-                  "regression_logarithmic",
-                  "regression_exponential",
-                  "regression_polynomial",
-                  "regression_sigmoidal"
-               ],
-               "balls-started":[
-                  "basic_stats",
-                  "historical_analyss",
-                  "regression_linear",
-                  "regression_logarithmic",
-                  "regression_exponential",
-                  "regression_polynomial",
-                  "regression_sigmoidal"
-               ],
-               "balls-upper-teleop":[
-                  "basic_stats",
-                  "historical_analysis",
-                  "regression_linear",
-                  "regression_logarithmic",
-                  "regression_exponential",
-                  "regression_polynomial",
-                  "regression_sigmoidal"
-               ],
-               "balls-upper-auto":[
-                  "basic_stats",
-                  "historical_analysis",
-                  "regression_linear",
-                  "regression_logarithmic",
-                  "regression_exponential",
-                  "regression_polynomial",
-                  "regression_sigmoidal"
-               ]
-            }
-         },
-         "metric":{
-            "tests":{
-               "elo":{
-                  "score":1500,
-                  "N":400,
-                  "K":24
-               },
-               "gl2":{
-                  "score":1500,
-                  "rd":250,
-                  "vol":0.06
-               },
-               "ts":{
-                  "mu":25,
-                  "sigma":8.33
-               }
-            }
-         },
-         "pit":{
-            "tests":{
-               "wheel-mechanism":true,
-               "low-balls":true,
-               "high-balls":true,
-               "wheel-success":true,
-               "strategic-focus":true,
-               "climb-mechanism":true,
-               "attitude":true
-            }
-         }
-      }
-   }
-}
-"""
-
-def load_config(path, config_vector):
-	try:
-		f = open(path, "r")
-		config_vector.update(json.load(f))
-		f.close()
-		return 0
-	except:
-		f = open(path, "w")
-		f.write(sample_json)
-		f.close()
-		return 1

src/module.py

@@ -1,5 +1,4 @@
 import abc
-import data as d
 import signal
 import numpy as np
 from tra_analysis import Analysis as an
@@ -28,20 +27,16 @@ class Module(metaclass = abc.ABCMeta):
 class Match (Module):
 
 	config = None
-	apikey = None
-	tbakey = None
 	timestamp = None
-	competition = None
+	client = None
 
 	data = None
 	results = None
 	
-	def __init__(self, config, apikey, tbakey, timestamp, competition):
+	def __init__(self, config, timestamp, client):
 		self.config = config
-		self.apikey = apikey
-		self.tbakey = tbakey
 		self.timestamp = timestamp
-		self.competition = competition
+		self.client = client
 
 	def validate_config(self):
 		return True, ""
@@ -52,7 +47,7 @@ class Match (Module):
 		self._push_results()
 
 	def _load_data(self):
-		self.data = d.load_match(self.apikey, self.competition)
+		self.data = self.client.load_match()
 
 	def _simplestats(self, data_test):
 
@@ -140,25 +135,21 @@ class Match (Module):
 
 		self.results = return_vector
 
-		d.push_match(self.apikey, self.competition, self.results)
+		self.client.push_match(self.results)
 
 class Metric (Module):
 
 	config = None
-	apikey = None
-	tbakey = None
 	timestamp = None
-	competition = None
+	client = None
 
 	data = None
 	results = None
 	
-	def __init__(self, config, apikey, tbakey, timestamp, competition):
+	def __init__(self, config, timestamp, client):
 		self.config = config
-		self.apikey = apikey
-		self.tbakey = tbakey
 		self.timestamp = timestamp
-		self.competition = competition
+		self.client = client
 
 	def validate_config(self):
 		return True, ""
@@ -169,7 +160,7 @@ class Metric (Module):
 		self._push_results()
 
 	def _load_data(self):
-		self.data = d.pull_new_tba_matches(self.tbakey, self.competition, self.timestamp)
+		self.data = self.client.pull_new_tba_matches(self.timestamp)
 
 	def _process_data(self):
 
@@ -183,8 +174,8 @@ class Metric (Module):
 
 		for match in matches:
 
-			red = d.load_metric(self.apikey, self.competition, match, "red", self.config["tests"])
+			red = self.client.load_metric(match, "red", self.config["tests"])
-			blu = d.load_metric(self.apikey, self.competition, match, "blue", self.config["tests"])
+			blu = self.client.load_metric(match, "blue", self.config["tests"])
 	
 			elo_red_total = 0
 			elo_blu_total = 0
@@ -262,7 +253,7 @@ class Metric (Module):
 			temp_vector.update(red)
 			temp_vector.update(blu)
 
-			d.push_metric(self.apikey, self.competition, temp_vector)
+			self.client.push_metric(temp_vector)
 
 	def _push_results(self):
 		pass
@@ -270,20 +261,16 @@ class Metric (Module):
 class Pit (Module):
 
 	config = None
-	apikey = None
-	tbakey = None
 	timestamp = None
-	competition = None
+	client = None
 
 	data = None
 	results = None
 	
-	def __init__(self, config, apikey, tbakey, timestamp, competition):
+	def __init__(self, config, timestamp, client):
 		self.config = config
-		self.apikey = apikey
-		self.tbakey = tbakey
 		self.timestamp = timestamp
-		self.competition = competition
+		self.client = client
 	
 	def validate_config(self):
 		return True, ""
@@ -294,7 +281,7 @@ class Pit (Module):
 		self._push_results()
 
 	def _load_data(self):
-		self.data = d.load_pit(self.apikey, self.competition)
+		self.data = self.client.load_pit()
 
 	def _process_data(self):
 		tests = self.config["tests"]
@@ -309,7 +296,7 @@ class Pit (Module):
 		self.results = return_vector
 
 	def _push_results(self):
-		d.push_pit(self.apikey, self.competition, self.results)
+		self.client.push_pit(self.results)
 
 class Rating (Module):
 	pass

src/pull.py

@@ -1,63 +0,0 @@
-import requests 
-from exceptions import APIError
-from dep import load_config
-
-url = "https://titanscouting.epochml.org"
-config_tra = {}
-load_config("config.json", config_tra)
-trakey = config_tra['persistent']['key']['tra']
-
-def get_team_competition():
-	endpoint = '/api/fetchTeamCompetition'
-	params = {
-		"CLIENT_ID": trakey['CLIENT_ID'],
-		"CLIENT_SECRET": trakey['CLIENT_SECRET']
-	}
-	response = requests.request("GET", url + endpoint, params=params)
-	json = response.json()
-	if json['success']:
-		return json['competition']
-	else:
-		raise APIError(json)
-
-def get_team():
-	endpoint = '/api/fetchTeamCompetition'
-	params = {
-		"CLIENT_ID": trakey['CLIENT_ID'],
-		"CLIENT_SECRET": trakey['CLIENT_SECRET']
-	}
-	response = requests.request("GET", url + endpoint, params=params)
-	json = response.json()
-	if json['success']:
-		return json['team']
-	else:
-		raise APIError(json)
-
-def get_team_match_data(competition, team_num):
-	endpoint = '/api/fetchAllTeamMatchData'
-	params = {
-		"competition": competition,
-		"teamScouted": team_num,
-		"CLIENT_ID": trakey['CLIENT_ID'],
-		"CLIENT_SECRET": trakey['CLIENT_SECRET']
-	}
-	response = requests.request("GET", url + endpoint, params=params)
-	json = response.json()
-	if json['success']:
-		return json['data'][team_num]
-	else:
-		raise APIError(json)
-
-def get_teams_at_competition(competition):
-	endpoint = '/api/fetchAllTeamNicknamesAtCompetition'
-	params = {
-		"competition": competition,
-		"CLIENT_ID": trakey['CLIENT_ID'],
-		"CLIENT_SECRET": trakey['CLIENT_SECRET']
-	}
-	response = requests.request("GET", url + endpoint, params=params)
-	json = response.json()
-	if json['success']:
-		return list(json['data'].keys())
-	else:
-		raise APIError(json)

src/superscript.py

@@ -148,12 +148,9 @@ __author__ = (
 
 # imports:
 
-import os, sys, time
+import sys, time, traceback, warnings
-import pymongo # soon to be deprecated
-import traceback
-import warnings
 from config import Configuration, ConfigurationError
-from data import get_previous_time, set_current_time, check_new_database_matches
+from data import Client
 from interface import Logger
 from module import Match, Metric, Pit
 
@@ -182,25 +179,24 @@ def main(logger, verbose, profile, debug, config_path):
 			
 			logger.info("found and loaded config at <" + config_path + ">")
 
-			apikey, tbakey = config.database, config.tba
+			client = Client(config)
-
-			logger.info("found and loaded database and tba keys")
-
-			client = pymongo.MongoClient(apikey)
 
 			logger.info("established connection to database")
 
-			previous_time = get_previous_time(client)
+			previous_time = client.get_previous_time()
 
 			logger.info("analysis backtimed to: " + str(previous_time))
 
 			config.resolve_config_conflicts(logger, client)
 
 			config_modules, competition = config.modules, config.competition
+
+			client.competition = competition
+
 			for m in config_modules:
 				if m in modules:
 					start = time.time()
-					current_module = modules[m](config_modules[m], client, tbakey, previous_time, competition)
+					current_module = modules[m](config_modules[m], previous_time, client)
 					valid = current_module.validate_config()
 					if not valid:
 						continue
@@ -209,7 +205,7 @@ def main(logger, verbose, profile, debug, config_path):
 					if debug:
 						logger.save_module_to_file(m, current_module.data, current_module.results) # logging flag check done in logger
 
-			set_current_time(client, loop_start)
+			client.set_current_time(loop_start)
 			close_all()
 
 			logger.info("closed threads and database client")
@@ -227,7 +223,7 @@ def main(logger, verbose, profile, debug, config_path):
 				new_match = False
 				while not new_match:
 					time.sleep(1)
-					new_match = check_new_database_matches(client, competition)
+					new_match = client.check_new_database_matches()
 				logger.info("database returned new matches")
 			else:
 				loop_delay = float(config["variable"]["loop-delay"])