def test_populate(self): populate() self.assertIsNotNone(User.objects.get(username="******")) self.assertIsNotNone(Leaderboard.objects.get(seed="test0", plays=4, challanges=0)) lead=Leaderboard.objects.get(seed="test0", plays=4, challanges=0) usr=User.objects.get(username="******") self.assertIsNotNone(Score.objects.get(leaderboard=lead, user=usr, score=10))
def runserver(): import fs, optparse, daemon from os.path import join, exists from base import enable_logging from config import SiteConfig from populate import populate from cached import cache_expander, wipe_sitelists options, remainder = server_options_parser.parse_args() apply_site_dirs(remainder) enable_logging(options) config = SiteConfig(options) wipe_sitelists(config.active_domain) populate(cache_expander,config) if options.fork: pid = os.fork() if pid == 0: # The Child Process with daemon.DaemonContext(): start_server(site.PROJECT_DIR,"runserver",config) else: print "Forked a Daemon as", pid else: start_server(site.PROJECT_DIR,"runserver",config)
def mainfct(document): path_to_docx = document document = Document(path_to_docx) tables = document.tables i = 0 for table in tables: x = 0 y = 0 p = 0 cell_counter = 0 main_dict = {} # document.tables[i].cell(x,y).paragraphs[p].text != None while True: try: test_end = document.tables[i].cell(x, y).paragraphs[p].text p = 0 while True: try: paragraphs = document.tables[i].cell(x, y).paragraphs text = "" for paragraph in paragraphs: text = text + "\n" + paragraph.text text = text.strip("\n") p = p + 1 print text.encode("UTF-8") filtered_dict2 = {} if cell_counter > 0: for k, v in parse_cell(text).items(): if v: filtered_dict2[k] = v elif cell_counter == 0: main_dict = parse_cell(text) main_dict.update(filtered_dict2) print main_dict cell_counter = cell_counter + 1 if cell_counter == 3: populate(main_dict) cell_counter = 0 main_dict = {} x = x + 1 print ("----------------y+1------------------") p = 0 except IndexError: x = 0 break except IndexError: break p = 0 y = y + 1 print ("-----------------------x+1----------------------------") i = i + 1 print ("REACHED").encode("UTF-8")
def test_populate(self): populate() self.assertIsNotNone(User.objects.get(username="******")) self.assertIsNotNone( Leaderboard.objects.get(seed="test0", plays=4, challanges=0)) lead = Leaderboard.objects.get(seed="test0", plays=4, challanges=0) usr = User.objects.get(username="******") self.assertIsNotNone( Score.objects.get(leaderboard=lead, user=usr, score=10))
def setUp(self): try: from populate import populate populate() except ImportError: print('The module populate_rango does not exist') except NameError: print('The function populate() does not exist or is not correct') except: print('Something went wrong in the populate() function :-(')
def test_population_script(self): populate.populate() restaurant = Restaurant.objects.get(name='Chow') self.assertEquals(restaurant.address, '98 Byres Road, Glasgow, G12 8TB') food1 = Food.objects.get(name='Mushroom Curry') self.assertEquals(food1.vegetarian, True) food2 = Food.objects.get(name='Salmon Feast Set') self.assertEquals(food2.restaurant.name, 'Okome')
def resize_for_new_nodes(new_total_nodes, k8s, cluster, test=False): """create new nodes to match new_total_nodes required only for scaling up""" if confirm(("Resizing up to: %d nodes" % new_total_nodes)): scale_logger.info("Resizing up to: %d nodes", new_total_nodes) if not test: cluster.add_new_node(new_total_nodes) wait_time = 130 scale_logger.debug( "Sleeping for %i seconds for the node to be ready for populating", wait_time) time.sleep(wait_time) populate(k8s)
def Checkdb(dbname): prgrm = 1 if checkdb(dbname) is True: #Check the existance of the database (if exists or not) createdb(dbname) #Create the database session = connect(dbname) #Connect to the database createtables(dbname) #Create the tables populate(dbname, rawdata) #Populate the database finishTime = datetime.now() #End of the set up timeDetla = finishTime - startTime print('\n----------------------------------------------------') print("Setup is finished. Your database is now available.") print("The process was completed in : " + str( timeDetla.total_seconds()) + "s.") #Total time print('----------------------------------------------------\n') return prgrm else: print("Your database already exists.\n") print('Do you want to delete the tables to run the program anyway ?') print('1 = Delete the tables and recreate others.') print('Other integer: do not run the program\n') try: Choice = int(input('Your choice : ')) except ValueError: print("The input is not right...\n") prgrm = 0 return prgrm if Choice == 1: engine = db.create_engine(f'mysql+pymysql://{username}:{password}@{host}/{dbname}') connection = engine.connect() #Connect session = connect(dbname) #Connect to the database query = db.delete(Books) results = connection.execute(query) populate(dbname, rawdata) #Populate the database with what we want return prgrm else : prgrm = 0 print('The program will not run') return prgrm print('----------------------------------------------------\n')
def __init__(self, remoteShell, domainAdmin="admin", domain=None): self.remoteShell = remoteShell self.uptoolPath = "/opt/quest/bin/uptool" self.domainAdmin = domainAdmin self.defaultDomain = domain self.container = container.container(self.remoteShell, self.domainAdmin, self.defaultDomain) self.create = upCreate.create(self.remoteShell, self.domainAdmin, self.defaultDomain) self.delete = upDelete.delete(self.remoteShell, self.domainAdmin, self.defaultDomain) self.depopulate = depopulate.depopulate(self.remoteShell, self.domainAdmin, self.defaultDomain) self.list = upList.list(self.remoteShell, self.domainAdmin, self.defaultDomain) self.membership = membership.membership(self.remoteShell, self.domainAdmin, self.defaultDomain) self.migrate = migrate.migrate(self.remoteShell, self.domainAdmin, self.defaultDomain) self.modify = modify.modify(self.remoteShell, self.domainAdmin, self.defaultDomain) self.populate = populate.populate(self.remoteShell, self.domainAdmin, self.defaultDomain) isinstance(self.container, container.container) isinstance(self.create, upCreate.create) isinstance(self.delete, upDelete.delete) isinstance(self.depopulate, depopulate.depopulate) isinstance(self.list, upList.list) isinstance(self.membership, membership.membership) isinstance(self.migrate, migrate.migrate) isinstance(self.modify, modify.modify) isinstance(self.populate, populate.populate)
def setUp(self): try: from populate import populate populate() except ImportError: print('The module populate does not exist') except NameError: print('The function populate() does not exist or is not correct') except: print('Something went wrong in the populate() function') from django.contrib.auth import get_user_model User = get_user_model() testuser = User.objects.create_user('testuser', '*****@*****.**', 'pass') from projects import models project = models.Project.objects.get(project_title="fake_title") pm = models.ProjectMember.objects.get_or_create(user=testuser, project=project, is_owner=True)
def setUp(self): print "asdfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff" for item in model.__dict__.values(): if inspect.isclass(item) and issubclass(item, sqlobject.SQLObject) and item != sqlobject.SQLObject \ and item != InheritableSQLObject: item.dropTable(ifExists=True) testutil.DBTest.setUp(self) self.objs = populate()
def populateserver(): import fs, optparse from os.path import join, exists from base import enable_logging from config import SiteConfig from populate import populate, save_expander from cached import cache_expander, wipe_sitelists options, remainder = populate_options_parser.parse_args() apply_site_dirs(remainder) enable_logging(options) config = SiteConfig(options) if config["output"]: populate(save_expander,config) else: wipe_sitelists(config.active_domain) populate(cache_expander,config)
def test_standard_case(self): """Checks method runs correctly under typical inputs.""" db = populate.populate() nat_environment = { c.C_BIDEN: 30, c.C_WARREN: 30, c.C_SANDERS: 20, c.C_BUTTIGIEG: 20, "confidence": 0.5 } candidates = [c.C_BIDEN, c.C_WARREN, c.C_SANDERS, c.C_BUTTIGIEG] primary_calendar = db.get_primary_calendar() result = ps.simulate(db, nat_environment, candidates, primary_calendar) self.assertNotEqual(result.winner, None)
def test_no_candidates(self): """Tests the case where there are no candidates provided.""" db = populate.populate() nat_environment = { c.C_BIDEN: 30, c.C_WARREN: 30, c.C_SANDERS: 20, c.C_BUTTIGIEG: 20, "confidence": 0.5 } candidates = [] primary_calendar = db.get_primary_calendar() with self.assertRaises(ValueError): result = ps.simulate(db, nat_environment, candidates, primary_calendar)
def test_negative_support(self): """Tests the case where one candidate has negative national support.""" db = populate.populate() nat_environment = { c.C_BIDEN: 40, c.C_WARREN: 31, c.C_SANDERS: 31, c.C_BUTTIGIEG: -2, "confidence": 0.5 } candidates = [c.C_BIDEN, c.C_WARREN, c.C_SANDERS, c.C_BUTTIGIEG] primary_calendar = db.get_primary_calendar() with self.assertRaises(ValueError): result = ps.simulate(db, nat_environment, candidates, primary_calendar)
def populate_command(): populate.populate() print('Populated the database.')
from merge import mergesort from merge import mergesort_time from quick import quicksort from counting import countingsort from radix import radixsort from shell import shellsort #utils from populate import populate import time v100 = list(range(0, 100)) v1000 = list(range(0, 1000)) v10000 = list(range(0, 10000)) v100 = populate(v100) v1000 = populate(v1000) v10000 = populate(v10000) def time_execute_shellsort_v100(): before = time.time() shellsort(v100) after = time.time() total = ((after - before) * 1000) print("time shellsort (100 elements) = %0.4f" % total) time_execute_shellsort_v100()
def Checkdb(dbname): prgrm = 1 #Default value for the program to run if checkdb( dbname ) is True: #Check the existance of the database (if exists or not) """ The database does not exist: we need to create it from scratch and populate it """ createdb(dbname) #Create the database session = connect(dbname) #Connect to the database createtables(dbname) #Create the tables populate(dbname, rawdata) #Populate the database finishTime = datetime.now() #End of the set up timeDetla = finishTime - startTime print('\n----------------------------------------------------') print("Setup is finished. Your database is now available.") print("The process was completed in : " + str(timeDetla.total_seconds()) + "s.") #Total time for the database's setup print('----------------------------------------------------\n') return prgrm else: print("Your database already exists.\n") print('Here are the tables and their columns that exists : ') engine = db.create_engine( f'mysql+pymysql://{username}:{password}@{host}/{dbname}') connection = engine.connect() #Connect session = connect(dbname) #Connect to the database metadata = MetaData(bind=engine) m = MetaData() m.reflect(engine) listtable = [] for table in m.tables.values(): #Create a list listtable.append(table.name) print("\nTable name: ", table.name, "\n") for column in table.c: print("Column name: ", column.name) print('\nDo you want to see what is inside a specific table ? ') print('1 = You want to see inside a table.') print('Other integer : do not show anything\n') try: choice = int(input('Your choice : ')) except ValueError: print( '\nThe input is not right. We will consider you do not want to see anything\n' ) choice = 0 if choice == 1: print( '\nYou asked to see what is inside a table. Which one do you want to see ? \n' ) try: tablechosen = choosetable() except ValueError: print('\nPlease write a valid input (string)') tablechosen = choosetable() try: existingtable = listtable.index(tablechosen) except ValueError: print("You did not entered a valid table name...") print("Please write a valid one now\n") tablechosen = choosetable() else: print( pd.DataFrame( connection.execute( "SELECT * FROM {}".format(tablechosen)))) else: pass print( '\nDo you want to add the data that does not exist (without deleting the previously existing one ?' ) print('1 = You want to add the data and run the program') print('Other integer : Do not do anything. The program will stop\n') try: Choice = int(input('Your choice : ')) except ValueError: print( "The input is not right... We will consider you do not want the program to run.\n" ) prgrm = 0 return prgrm if Choice == 1: # Create a code that add the data from the jason file # if it does not exist in the table with open('data.json') as f: data_json = json.load(f) for data in data_json: if not Books.objects.filter(Title=data['Title']).exists: data = Books(Title=data['Title'], Author=data['Author'], ReadOrNot='0') data.save() print( f"Added to the database: {data.Title} \ (TITLE {data.Title}). " ) else: print( f'This book already exists: \ {Books.objects.get(Title = data["Title"]).Title} (TITLE: {data["Title"]}).' ) return prgrm #The program will run properly else: prgrm = 0 print('The program will not run') return prgrm
# Date: Thu 25 Jul 2019 17:23:15 CEST # Author: Nicolas Flandrois from sqlalchemy.orm import sessionmaker, query from connection import connect, createdb, checkdb from datetime import datetime from createtables import createtables from populate import populate startTime = datetime.now() print("Setup in progress. Please wait.") dbname = 'ocpizza' rawdata = 'data.json' if checkdb(dbname) is True: createdb(dbname) session = connect(dbname) createtables(dbname) populate(dbname, rawdata) finishTime = datetime.now() timeDetla = finishTime - startTime print("Setup is finished. Your database is now available.") print("The process was completed in : " + str(timeDetla.total_seconds()) + "s.") else: print("Your database already exists.")
def populate_db_tests(): populate(MONGO_DATABASE_TESTS, MONGO_HOST, MONGO_PORT)
def update_unschedulable(number_unschedulable, nodes, k8s, calculate_priority=None): """Attempt to make sure given number of nodes are blocked, if possible; return number of nodes newly blocked; negative value means the number of nodes unblocked calculate_priority should be a function that takes a node and return its priority value for being blocked; smallest == highest priority; default implementation uses get_pods_number_on_node CRITICAL NODES SHOULD NOT BE INCLUDED IN THE INPUT LIST""" assert number_unschedulable >= 0 number_unschedulable = int(number_unschedulable) scale_logger.info( "Updating unschedulable flags to ensure %i nodes are unschedulable", number_unschedulable) if calculate_priority == None: # Default implementation based on get_pods_number_on_node def calculate_priority(node): return k8s.get_pods_number_on_node(node) schedulable_nodes = [] unschedulable_nodes = [] priority = [] # Analyze nodes status and establish blocking priority for count in range(len(nodes)): if nodes[count].spec.unschedulable: unschedulable_nodes.append(nodes[count]) else: schedulable_nodes.append(nodes[count]) priority.append((calculate_priority(nodes[count]), count)) # Attempt to modify property based on priority toBlock = [] toUnBlock = [] heapq.heapify(priority) for _ in range(number_unschedulable): if len(priority) > 0: _, index = heapq.heappop(priority) if nodes[index] in schedulable_nodes: toBlock.append(nodes[index]) else: break for _, index in priority: if nodes[index] in unschedulable_nodes: toUnBlock.append(nodes[index]) __update_nodes(k8s, toBlock, True) scale_logger.debug("%i nodes newly blocked", len(toBlock)) __update_nodes(k8s, toUnBlock, False) scale_logger.debug("%i nodes newly unblocked", len(toUnBlock)) if (len(toBlock) != 0 or len(toUnBlock) != 0) and ( len(toBlock) != len(toUnBlock)) and not k8s.test: slack_logger.info("%i nodes newly blocked, %i nodes newly unblocked", len(toBlock), len(toUnBlock)) if len(toUnBlock) != 0: populate(k8s) return len(toBlock) - len(toUnBlock)
def setUp(self): populate() up = UserProfile() up.user = User.objects.create_user('a', 'b', 'c') up.save() self.client.login(username='******', password='******')
def mainfct(document): path_to_docx = document document = Document(path_to_docx) tables = document.tables i = 0 for table in tables: x = 0 y = 0 p = 0 cell_counter = 0 main_dict={} #document.tables[i].cell(x,y).paragraphs[p].text != None while True: try: test_end = document.tables[i].cell(x,y).paragraphs[p].text p=0 while True: try: paragraphs = document.tables[i].cell(x,y).paragraphs text="" for paragraph in paragraphs: text = text +'\n'+ paragraph.text text = text.strip('\n') p = p+1 print text.encode('UTF-8') filtered_dict2 = {} if cell_counter > 0: for k, v in parse_cell(text).items(): if v: filtered_dict2[k] = v elif cell_counter ==0: main_dict = parse_cell(text) main_dict.update(filtered_dict2) print main_dict cell_counter = cell_counter + 1 if cell_counter == 3: populate(main_dict) cell_counter = 0 main_dict={} x=x+1 print ("----------------y+1------------------") p=0 except IndexError: x=0 break except IndexError: break p=0 y = y + 1 print ("-----------------------x+1----------------------------") i = i + 1 print ("REACHED").encode('UTF-8')
def setUp(self): populate.populate() self.user = User.objects.create_user('john', '*****@*****.**', 'johnpassword') self.user.save() self.client.force_login(self.user)
def populate_tables(): from populate import populate populate()
for i in range(0, len(list_of_config)): print("CONFIG OF DOC -", count, ":-", list_of_config[i], "\n") count = count + 1 aggregated_config = {} for j in range(0, len(list_of_config)): config_j = list_of_config[j] data_merge(aggregated_config, config_j) print("Config Of Document ", j, "is MERGED!!") print("\n Aggregated CONFIG is :- ", aggregated_config, "\n") data_merge(aggregated_config, config_from_outside) for i in range(0, fake_documents_count): fake_doc_i = cp.deepcopy(aggregated_config) for key, value in fake_doc_i.items(): val = pl.populate(value) fake_doc_i[key] = val fake_docs_list.append(fake_doc_i) count = 0 for i in range(0, len(fake_docs_list)): print("Fake DOC -", count, ":-", fake_docs_list[i], "\n") count = count + 1 c = "in-3" mydb = client['Output'] mycollection = mydb[col] for i in range(0, len(fake_docs_list)): mycollection.insert_one(fake_docs_list[i]) mydb = client['Output'] colls = mydb.collection_names()
"""Probabilistic model of the 2020 Democratic Primary.""" import populate import database import simulate.primary_simulation as ps import analyse.plot as plot # Define constants. NUM_SIMULATIONS = 1000 # Carry out the simulations. results = [] for simulation in range(NUM_SIMULATIONS): # Create a clean database containing required information. db = populate.populate() # Initialise other variables. base_nat_environment = db.get_nat_primary_environment() candidates = db.get_primary_candidates() # Set up to iterate through the primary calendar. primary_calendar = db.get_primary_calendar() result = ps.simulate(db, base_nat_environment, candidates, primary_calendar) results.append(result) # Analyse and present the results. plot.winners_pie_chart(results) plot.most_delegates_pie_chart(results)
def setUpClass(cls): cls.conn = get_connection() cls.cur = cls.conn.cursor() init_db(cls.cur) populate(cls.cur) cls.conn.commit()
def setUp(self): populate.populate() self.credentials = { 'username': '******', 'password': '******'} User.objects.create_user(**self.credentials)
def index(request): display_array = json.dumps(populate.populate()) print display_array return render(request, 'index.html',{'data_for_site' : display_array})
def setup(count): """Empties the collection and populates with `count` number of documents. """ dbinit.init_collection() populate.populate(count)
def setUp(self): populate(MONGO_DATABASE_TESTS, MONGO_HOST, MONGO_PORT)
def populate(): import populate populate.populate(saidb)
app.config.from_object('config') # Define the database object which is imported by modules and controllers db = SQLAlchemy(app) # Sample HTTP error handling @app.errorhandler(404) def not_found(error): return render_template('404.html'), 404 # Import a module / component using its blueprint handler variable from app.module_authentication.controllers import mod_auth from app.module_schedule.controllers import mod_schedule #import models from app.module_authentication import models from app.module_schedule import models # Register blueprints app.register_blueprint(mod_auth) app.register_blueprint(mod_schedule) # Define and populate the database from populate import populate if(os.path.exists(BASE_DIR + '/app.db')): print "Database already populated." else: db.create_all() populate()
def nn_submit(): body = request.get_json() data = [ body['age'] / 100, body['high_risk_exposure_occupation'], body['high_risk_interactions'], body['diabetes'], body['chd'], body['htn'], body['cancer'], body['asthma'], body['copd'], body['autoimmune_dis'], body['smoker'], minMaxTemp(body['temperature']), minMaxPulse(body['pulse']), body['labored_respiration'], body['cough'], body['fever'], body['sob'], body['diarrhea'], body['fatigue'], body['headache'], body['loss_of_smell'], body['loss_of_taste'], body['runny_nose'], body['muscle_sore'], body['sore_throat'] ] junk0 = [0 for i in range(25)] junk1 = [1 for i in range(25)] columns = ['age', 'high_risk_exposure_occupation', 'high_risk_interactions', 'diabetes', 'chd', 'htn', 'cancer', 'asthma', 'copd', 'autoimmune_dis', 'smoker', 'temperature', 'pulse', 'labored_respiration', 'cough', 'fever', 'sob', 'diarrhea', 'fatigue', 'headache', 'loss_of_smell', 'loss_of_taste', 'runny_nose', 'muscle_sore', 'sore_throat'] binary_features = ['diabetes', 'chd', 'htn', 'cancer', 'asthma', 'copd', 'autoimmune_dis', 'high_risk_exposure_occupation', 'high_risk_interactions', 'smoker', 'labored_respiration', 'cough', 'fever', 'sob', 'diarrhea', 'fatigue', 'headache', 'loss_of_smell', 'loss_of_taste', 'runny_nose', 'muscle_sore', 'sore_throat'] df = pd.DataFrame([data, junk0, junk1], columns=columns) for col in binary_features: df[col] = df[col] * 1 dummy_cols = list(set(df[binary_features])) df = pd.get_dummies(df, columns=dummy_cols) df = df.drop(index=[1,2]) predictions = model.predict(df) data.append(predictions[0][0].item()) data.insert(0, counter()) with open('user.csv', 'w') as f_object: writer_object = writer(f_object) writer_object.writerow(['id','age', 'high_risk_exposure_occupation', 'high_risk_interactions', 'diabetes', 'chd', 'htn', 'cancer', 'asthma', 'copd', 'autoimmune_dis', 'smoker', 'temperature', 'pulse', 'labored_respiration', 'cough', 'fever', 'sob', 'diarrhea', 'fatigue', 'headache', 'loss_of_smell', 'loss_of_taste', 'runny_nose', 'muscle_sore', 'sore_throat','prediction']) writer_object.writerow(data) f_object.close() populate() return {'prediction': predictions[0][0].item()}
from app.controllers.shows_on_date_route import ShowsOnDateRoute from app.controllers.show_seating_route import ShowSeatingRoute from app.controllers.seat_reserved_route import SeatReservedRoute from app.controllers.reservation_route import ReservationRoute # add route controllers to routes base_uri = '/api' api.add_resource(ApiLoginRoute, base_uri + '/access') api.add_resource(DatesRoute, base_uri + '/dates') api.add_resource(MovieRoute, base_uri + '/movie') api.add_resource(MovieListRoute, base_uri + '/movies/all') api.add_resource(MoviesOnDateRoute, base_uri + '/movies/date') api.add_resource(ShowsOnDateRoute, base_uri + '/shows/date') api.add_resource(ShowSeatingRoute, base_uri + '/show/seating') api.add_resource(ReservationRoute, base_uri + '/reservations') api.add_resource(SeatReservedRoute, base_uri + '/seat/reserved') api.add_resource(RegistrationRoute, base_uri + '/registration') ''' @app.route('/') def index(): return render_template('index.html') # renders parameter in templates folder ''' db.create_all() # populate database and add the admin from populate import populate with app.app_context(): populate(db)
def populate_ep(): populate(es) return 'Done populate!\n'