def test_show_products_for_customer(self):
"""Tests database.show_products_for_customer"""
_, _ = DatabaseInterface.import_data(DATA_DIR, PRODUCTS, CUSTOMERS, RENTALS)
correct = []
for key in sorted(self.products_remaining):
correct.append({PROD_DESC: self.product_data[key][PROD_DESC],
PROD_TYPE: self.product_data[key][PROD_TYPE],
'quantity_available': self.products_remaining[key]})
self.assertEqual(correct,
DatabaseInterface.show_products_for_customer())
def test_show_available_products(self):
"""Test database.show_available_products"""
self.assertEqual({}, DatabaseInterface.show_available_products(), "Nothing so far")
success, fail = DatabaseInterface.import_data(DATA_DIR, PRODUCTS, CUSTOMERS, RENTALS)
prods_to_show = DatabaseInterface.show_available_products()
self.assertEqual(sorted(self.products_remaining.keys()), sorted(prods_to_show.keys()))
correct = dict(zip(prods_to_show, ({PROD_DESC: self.product_data[prod][PROD_DESC],
PROD_TYPE: self.product_data[prod][PROD_TYPE],
PROD_REMAIN: self.products_remaining[prod]}
for prod in prods_to_show)))
self.assertEqual(correct, prods_to_show, "Products to show")
def test_read_dict(self):
"""Test reading CSV with dict output"""
# Read the file and assert that the dictionary output
# matches self.data_dict
data = DatabaseInterface.read_csv(self.filename, keyed=True)
self.assertEqual(self.data_dict, data)
def test_show_rentals(self):
"""Test database.show_rentals"""
_, _ = DatabaseInterface.import_data(DATA_DIR, PRODUCTS, CUSTOMERS, RENTALS)
if "prodX" not in self.product_data:
self.assertEqual({}, DatabaseInterface.show_rentals("prodX"))
else:
raise NameError("Test case invalid - 'prodX' exists as a product key")
# Compute correct rental data
for product in self.product_keys:
correct = {}
for entry in self.rental_data:
user, prod, qty = entry[USER_ID], entry[PROD_ID], entry[RENT_QTY]
if prod == product: # Add as rental for this product
correct[user] = self.customer_data[user]
try:
correct[user].pop(USER_ID)
except KeyError:
pass
self.assertEqual(correct, DatabaseInterface.show_rentals(product))
def setUp(self) -> None:
"""Set up test case"""
# The read_csv method is tested above
self.customer_data = DatabaseInterface.read_csv(os.path.join(DATA_DIR, CUSTOMERS), keyed=True)
self.product_data = DatabaseInterface.read_csv(os.path.join(DATA_DIR, PRODUCTS), keyed=True)
self.rental_data = DatabaseInterface.read_csv(os.path.join(DATA_DIR, RENTALS), keyed=False)
self.customer_keys = list(self.customer_data.keys())
self.product_keys = list(self.product_data.keys())
self.products_remaining = dict(zip(self.product_keys,
(self.product_data[k][PROD_QTY] for
k in self.product_keys)))
for rental in self.rental_data: # Subtract rented quantities from stock
prod, qty = rental[PROD_ID], rental[RENT_QTY]
try:
self.products_remaining[prod] = self.products_remaining[prod] - qty
except KeyError:
pass
else:
if self.products_remaining[prod] <= 0:
self.products_remaining.pop(prod)
def test_import_data(self):
"""Test database.import_data"""
success, fail = DatabaseInterface.import_data(DATA_DIR, PRODUCTS, CUSTOMERS, RENTALS)
# Order = products, customers, rentals
names = ("Products", "Customers", "Rentals")
n_prod = len(self.product_keys)
n_cust = len(self.customer_keys)
n_rent = len(self.rental_data)
for correct, value, name in zip((n_prod, n_cust, n_rent), success, names):
self.assertEqual(correct, value, name)
self.assertEqual((0, 0, 0), fail, "Fail count")
# Assert they were added to the database correctly
with database.MongoManager() as mm:
self.assertEqual(len(self.rental_data), mm.db.rentals.count_documents({}), "Rental count")
self.assertEqual(len(self.product_keys), mm.db.products.count_documents({}), "Prod count")
self.assertEqual(len(self.customer_keys), mm.db.customers.count_documents({}), "Cust count")
import csv
from database import DatabaseInterface
import utilities as ut
players_dir_path = 'c:/my_projects/fantasy_football/players/'
db = 'c:/sqlite/chinook/sample.db'
dbi = DatabaseInterface(db)
# pos = 0, name = 2, fgm = 7, team = 12
def load_kickers(kickers_csv):
"""pos = 0, name = 2, fgm = 7, team = 12"""
with open(players_dir_path + kickers_csv, 'r', newline='') as infile:
kickers = csv.reader(infile)
for kicker in kickers:
if ut.input_is_integer(kicker[7]):
score = ut.kicker_score(int(kicker[7]))
else:
score = 0
dbi.add_player_to_game(kicker[2], kicker[0], kicker[12], score)
def load_quarterbacks(quarterbacks_csv):
"""IN the csv, pos is [0], name = [2], team = [12[, tds = [5], int = [7], yards= [9]"""
with open(quarterbacks_csv, 'r', newline='') as infile:
quarterbacks = csv.reader(infile)
for quarterback in quarterbacks:
if ut.input_is_integer(quarterback[5]):
tds = int(quarterback[5])
else:
tds = 0
def index():
dbi = DatabaseInterface('c:/sqlite/chinook/sample.db')
players = dbi.get_lastyear_stats('WR')
return render_template('base.html', title='Home', players=players)
OBJECT_EXTRACTION_PICTURE_FOLDER = CURRENT_PATH + "data/objects/"
LAYER_FOLDER = CURRENT_PATH + "data/layers/" + CURRENT_LABEL + "/"
LOCAL_PICTURES = CURRENT_PATH + "pictures/"
## MODELS ##
BACKGROUND_SUBTRACTOR_GRAPH_NAME = MODELS_PATH + 'models/deeplab/frozen_inference_graph.pb'
OBJECT_DETECTION_GRAPH_NAME = MODELS_PATH + 'models/rnn_8/frozen_inference_graph.pb'
OBJECT_DETECTION_LABELS = MODELS_PATH + 'models/rnn_8/labels.pbtxt'
OBJECT_DETECTION_NUM_CLASSES = 8
LAYER_EXTRACTOR_GRAPH_NAME = MODELS_PATH + 'models/inception/inception.pb'
PERSON_DETECTION_GRAPH_NAME = MODELS_PATH + 'models/coco/frozen_inference_graph.pb'
PERSON_DETECTION_LABELS = MODELS_PATH + 'models/coco/coco.pbtxt'
PERSON_DETECTION_NUM_CLASSES = 90
## FIND IMAGES IN DATABASE
db = DatabaseInterface(LAYER_FOLDER)
if LOCAL_MODE:
downloader = ImageDownloader([], "tmp")
downloader.set_local_mode(LOCAL_PICTURES + CURRENT_LABEL + ".json",
restore_folder=LAYER_FOLDER)
db.set_treshold(downloader.get_restore_treshold())
total_image = len(downloader.read())
print(total_image)
else:
images = db.load_pictures(LABELS[CURRENT_LABEL]["category_ids"],
LABELS[CURRENT_LABEL]["subcategory_ids"])
total_image = len(images)
print("IMAGES", len(images))
#sys.exit()
## START DOWNLOADING THREAD
"category_ids":
[1, 172, 191, 144, 150, 137, 108, 94, 86, 95, 107, 114, 190, 113],
"subcategory_ids": []
}, #40116
"dresses": {
"category_ids": [58, 112],
"subcategory_ids": []
}, #82450
}
EXIT_FLAG = False
LAYER_FOLDER = "data/layers/" + CURRENT_LABEL + "/"
PICTURE_FOLDER = "pictures/"
## FIND IMAGES IN DATABASE
db = DatabaseInterface(LAYER_FOLDER)
print("GET IMAGES")
images = db.load_pictures(LABELS[CURRENT_LABEL]["category_ids"],
LABELS[CURRENT_LABEL]["subcategory_ids"])
total_image = len(images)
print("IMAGES", len(images))
## START DOWNLOADING THREAD
modulo = len(images) % 10
total_per_thread = int((total_image - modulo) / 10)
downloader = ImageDownloader(images[:total_per_thread],
PICTURE_FOLDER + CURRENT_LABEL,
found_peers = []
try:
for (ip_address, port) in dns_seeds:
for info in socket.getaddrinfo(ip_address, port, socket.AF_INET,
socket.SOCK_STREAM,
socket.IPPROTO_TCP):
found_peers.append((info[4][0], info[4][1]))
return found_peers
except Exception as e:
print('Invalid dns seed {}'.format(e))
raise
if __name__ == '__main__':
hosts = get_node_addresses()
database = DatabaseInterface()
maxConnections = 2
if hosts is None:
raise IndexError('Hosts is None')
for host in hosts:
c = Connection(host, database)
asyncore.loop()
database.close()