def setup_inst():
    instlist =[]
    for qualty in [100,20,90,80,50,30,40,10,70,60]:
        name = Inst()
        name.quality = qualty
        name.observed_1 = 1
        name.observed_2 = 1.25
        name.name = 'i'+str(qualty)
        instlist.append(name)
    return instlist
def setup_inst():
    instlist = []
    for qualty in [100, 20, 90, 80, 50, 30, 40, 10, 70, 60]:
        name = Inst()
        name.quality = qualty
        name.observed_1 = 1
        name.observed_2 = 1.25
        name.name = 'i' + str(qualty)
        instlist.append(name)
    return instlist
예제 #3
0
 def __init__(self,
              name,
              infec_prob=0.0,
              posn=(0, 0, 0, 0),
              door_posns=[],
              opening_time=0,
              closing_time=0):
     Institution.__init__(self, name, infec_prob, posn)
     self.door_posns = door_posns
     self.opening_time = opening_time
     self.closing_time = closing_time
     self.classrooms = []
예제 #4
0
def test_lawInstitution_fields():
    # Verify, upon instantiation, that all fields of the law and institution
    # classes are of the type they should be.
    society = Society(population_size=10)
    institution = Institution(society)
    laws = institution._generate_laws(society)

    assert isinstance(institution.get_affiliation(), float)

    for law in laws:
        for person_id in range(society.population_size):
            assert isinstance(law.affected_persons[person_id], int)
        assert isinstance(law.mean, float)
        assert isinstance(law.law_type, str)
        assert isinstance(law.actual_value, float)
예제 #5
0
파일: fbread.py 프로젝트: akaler/dfs-ias
def read_institutions(program:str):
	db = dfsapi.get_db()

	institutions = list()

	keys = db.child(program).child("institutions").shallow().get()

	if keys.val() == None:
		return False

	recentdb = max(keys.val())

	data = db.child(program).child("institutions").child(recentdb).get()

	for i in data.each():
		institution = i.val()

		Name = institution["Name"]
		Address = institution["Address"]
		County = institution["County"]
		Instructors = institution["Instructors"]
		Schedule = manageinstructors.schedule_to_dict(institution["Schedule"])

		institutions.append(Institution(Name, Address, County, 
			Instructors, Schedule))

	return institutions
예제 #6
0
 def from_config(c):
     institution = Institution.from_config(Settings.banks(c['institution']))
     return Account(
         institution = institution,
         guid = c['guid'],
         description = c['description'],
         routing_number = c['routing_number'],
         account_type = c['account_type'],
         broker_id = c['broker_id']
     )
예제 #7
0
def make_institution_list(info: dict, program: str):
    institutions = list()

    for school in info:
        new_schedule = schedule_to_dict(info[school]['Schedule'])
        institutions.append(
            Institution(info[school]['Name'], info[school]['Address'],
                        info[school]['County'], info[school]['Instructors'],
                        new_schedule))

    return institutions
def get_or_create_placeholder_institution():
    display_name = 'placeholder, see prepared_demo_publisher.py'
    institution = Institution.query.filter(
        Institution.display_name == display_name).scalar()

    if not institution:
        institution = Institution(display_name=display_name,
                                  is_consortium=False,
                                  is_demo_institution=True)
        db.session.add(institution)

    return institution
예제 #9
0
def add_institution(institution_name,
                    old_username,
                    ror_id_list,
                    is_consortium=False):
    logger.info(u"initializing institution {}".format(institution_name))

    my_institutions = db.session.query(Institution).filter(
        Institution.display_name == institution_name,
        Institution.id.notlike('%jisc%')).all()

    if my_institutions:
        my_institution = my_institutions[0]
        logger.info(
            u"  *** using existing institution {} ***".format(my_institution))

    if is_consortium:
        print "SETTING UP AS A CONSORTIUM ACCOUNT"

    else:
        my_institution = Institution()
        my_institution.display_name = institution_name
        my_institution.old_username = old_username
        my_institution.is_demo_institution = False
        my_institution.is_consortium = is_consortium
        db.session.add(my_institution)
        logger.info(u"  adding {}".format(my_institution))

    if not ror_id_list:
        return

    for ror_id in ror_id_list:
        add_ror(ror_id, my_institution.id)
 def test_Proposed_applicant_1(self):
     """Proposed_applicant_1: Institution has room (is not filled) accepts
     applicant
     """
     apps = setup_app()
     #setup institution
     inst = Inst()
     inst.matched_to = [apps[5], apps[3]]
     #inst.rank_list = apps Next line takes care of this
     inst.inst_rank_app(apps)
     inst.bumped_applicants = [apps[1]]
     inst.ranked_to_low = []
     inst.openings = 5
     results = inst.Proposed_applicant(apps[6])
     self.assertEqual(
         (results[0] and results[1] is None), True,
         'There was room, applicant should have been accepted' +
         str(results[0]) + ' ' + str(results[1]))
 def test_Proposed_applicant_3(self):
     """Proposed_applicant_3: Institution is filled applicant can NOT bump
     """
     apps = setup_app()
     #setup institution
     inst = Inst()
     #inst.rank_list = apps Next line takes care of this
     inst.inst_rank_app(apps)
     inst.matched_to = [
         inst.rank_list[0], inst.rank_list[1], inst.rank_list[2],
         inst.rank_list[3]
     ]
     inst.bumped_applicants = [inst.rank_list[9]]
     inst.ranked_to_low = []
     inst.openings = 4
     results = inst.Proposed_applicant(inst.rank_list[4])
     self.assertEqual((not (results[0]) and results[1] is None), True,
                      ('Applicant should have matched ' + str(results[0]) +
                       ' ' + str(results[1])))
 def test_Proposed_applicant_2(self):
     """Proposed_applicant_2: Institution is filled applicant can bump lowest
     ranked applicant
     """
     apps = setup_app()
     #setup institution
     inst = Inst()
     #inst.rank_list = apps Next line takes care of this
     inst.inst_rank_app(apps)
     inst.matched_to = [
         inst.rank_list[0], inst.rank_list[2], inst.rank_list[4],
         inst.rank_list[6]
     ]
     inst.bumped_applicants = [inst.rank_list[9]]
     inst.ranked_to_low = []
     inst.openings = 4
     results = inst.Proposed_applicant(inst.rank_list[1])
     self.assertEqual((results[0] and results[1] == inst.rank_list[6]),
                      True, 'Applicant should have bumped a10 ' +
                      str(results[0]) + ' ' + str(results[1].name))
 def test_interview_few(self):
     """
     Interview selection Test 1: , number that apply < number to interview
     """
     inst = Inst()
     inst.quality = 50
     inst.number_to_interview = 10
     inst.applied = setup_app()[:5]
     inst.interview()
     desired = {'a20', 'a90', 'a100', 'a50', 'a80'}
     actual = set([app.name for app in inst.invite_interview])
     self.assertEqual(desired, actual,
                      'desired '+str(desired)+' != '+ 'Actual '+str(actual))
 def test_Proposed_applicant_1(self):
     """Proposed_applicant_1: Institution has room (is not filled) accepts
     applicant
     """
     apps = setup_app()
     #setup institution
     inst = Inst()
     inst.matched_to = [apps[5], apps[3]]
     #inst.rank_list = apps Next line takes care of this
     inst.inst_rank_app(apps)
     inst.bumped_applicants = [apps[1]]
     inst.ranked_to_low = []
     inst.openings = 5
     results = inst.Proposed_applicant(apps[6])
     self.assertEqual((results[0] and results[1] is None), True,
                      'There was room, applicant should have been accepted' +
                      str(results[0]) + ' ' + str(results[1]))
 def test_Proposed_applicant_3(self):
     """Proposed_applicant_3: Institution is filled applicant can NOT bump
     """
     apps = setup_app()
     #setup institution
     inst = Inst()
     #inst.rank_list = apps Next line takes care of this
     inst.inst_rank_app(apps)
     inst.matched_to = [inst.rank_list[0], inst.rank_list[1], 
                        inst.rank_list[2], inst.rank_list[3]]
     inst.bumped_applicants = [inst.rank_list[9]]
     inst.ranked_to_low = []
     inst.openings = 4
     results = inst.Proposed_applicant(inst.rank_list[4])
     self.assertEqual((not(results[0]) and results[1] is None), True,
                      ('Applicant should have matched '+
                      str(results[0]) + ' ' +str(results[1])))
 def test_interview_few(self):
     """
     Interview selection Test 1: , number that apply < number to interview
     """
     inst = Inst()
     inst.quality = 50
     inst.number_to_interview = 10
     inst.applied = setup_app()[:5]
     inst.interview()
     desired = {'a20', 'a90', 'a100', 'a50', 'a80'}
     actual = set([app.name for app in inst.invite_interview])
     self.assertEqual(
         desired, actual,
         'desired ' + str(desired) + ' != ' + 'Actual ' + str(actual))
예제 #17
0
파일: fbread.py 프로젝트: dalcala94/dfs-ias
def read_institutions(program: str):
    db = dfsapi.get_db()

    institutions = list()

    keys = db.child(program).child("institutions").shallow().get()
    recentdb = max(keys.val())

    data = db.child(program).child("institutions").child(recentdb).get()

    for i in data.each():
        institution = i.val()

        Name = institution["Name"]
        Address = institution["Address"]
        County = institution["County"]
        Program = institution["Program"]
        Instructors = institution["Instructors"]

        Mon = dbtools.minute_range(institution["Monday"])
        Tue = dbtools.minute_range(institution["Tuesday"])
        Wed = dbtools.minute_range(institution["Wednesday"])
        Thurs = dbtools.minute_range(institution["Thursday"])
        Fri = dbtools.minute_range(institution["Friday"])

        Schedule = defaultdict(list)

        if Mon != None:
            Schedule[1].append(Mon)
        if Tue != None:
            Schedule[2].append(Tue)
        if Wed != None:
            Schedule[3].append(Wed)
        if Thurs != None:
            Schedule[4].append(Thurs)
        if Fri != None:
            Schedule[5].append(Fri)

        institutions.append(
            Institution(Name, Address, County, Program, Instructors, Schedule))

    return institutions
 def test_Proposed_applicant_2(self):
     """Proposed_applicant_2: Institution is filled applicant can bump lowest
     ranked applicant
     """
     apps = setup_app()
     #setup institution
     inst = Inst()
     #inst.rank_list = apps Next line takes care of this
     inst.inst_rank_app(apps)
     inst.matched_to = [inst.rank_list[0], inst.rank_list[2], 
                        inst.rank_list[4], inst.rank_list[6]]
     inst.bumped_applicants = [inst.rank_list[9]]
     inst.ranked_to_low = []
     inst.openings = 4
     results = inst.Proposed_applicant(inst.rank_list[1])
     self.assertEqual((results[0] and results[1]==inst.rank_list[6]), True, 
                      'Applicant should have bumped a10 '+
                      str(results[0]) + ' ' +str(results[1].name))
    def test_inst_rank_app(self):
        """
        Rank selection Test 1:
        """
        inst = Inst()
        inst.quality = 50
        inst.num_to_rank = 5
        inst.accept_range = [.5, 1000]
#TODO: need to filter based on inst.accept_range
        inst.inst_rank_app(setup_app())
        #order matters on rank_list
# TODO # Need to determin the right answer
        desired = ['a100', 'a90', 'a80', 'a70', 'a60', 'a50', 'a40', 'a30', 'a20', 'a10'] # Need to determin the right answer
        actual = [app.name for app in inst.rank_list]
        print('actual 2',actual)
        self.assertEqual(desired, actual,
                         'desired '+str(desired)+' != '+ 'Actual '+str(actual))
 def test_inst_rank_app(self):
     """
     Rank selection Test 1:
     """
     inst = Inst()
     inst.quality = 50
     inst.num_to_rank = 5
     inst.accept_range = [.5, 1000]
     #TODO: need to filter based on inst.accept_range
     inst.inst_rank_app(setup_app())
     #order matters on rank_list
     # TODO # Need to determin the right answer
     desired = [
         'a100', 'a90', 'a80', 'a70', 'a60', 'a50', 'a40', 'a30', 'a20',
         'a10'
     ]  # Need to determin the right answer
     actual = [app.name for app in inst.rank_list]
     print('actual 2', actual)
     self.assertEqual(
         desired, actual,
         'desired ' + str(desired) + ' != ' + 'Actual ' + str(actual))
예제 #21
0
	def login( self, institution_cnpj, password ):
		new_institution = Institution( institution_cnpj, password )
예제 #22
0
	def removeInstitution( self, institution_cnpj, password ):
		institution = Institution( institution_cnpj, password )
		institution.deleteFromStorage()
예제 #23
0
	def registerInstitution( self, institution_name, cnpj, address, phone_number, email, access_password ):
		new_institution = Institution( cnpj, access_password, address, phone_number, email, institution_name )
		new_institution.registerToStorage( access_password )
예제 #24
0
 def __init__(self, name, infec_prob=0.0, posn=(0, 0, 0, 0), door_posns=[]):
     Institution.__init__(self, name, infec_prob, posn)
     self.door_posns = door_posns
예제 #25
0
# Import institution mAtch data
# Make the list of Institutions
print('importing institution data')
data2008 = InstitutionData('/Users/vmd/Dropbox/Match/residency-match-simulation/matchdata2008.csv', 140, 'C', 1)
data2008.read_data_file()
data2008.prep_data()
data2008.select_data()

print('Setting Institution Attributes')
all_institutions = []
for x in data2008.finaldata:

#TODO: how to name the instances
    tname = x[1] # the Code is set as the object instance name, (I don't think this really works)
    tname = Institution() # the Code is set as the object instance name
    tname.name = x[1] #The name attribute is also set as the Code
    tname.openings = x[6] #Set the number of openings, comes from quota in the data file
    tname.prog_type = x[4] #Set the Type, for example 'C' is categorical
    tname.specialty = x[3] #Set the specialty, for example 140 is internal medicine
    tname.institution = x[2] #Set the institution number, basicly the name without the prog_type and specialty info
    tname.specialty_name = x[0] #This is the Speacialty name rather then code
    tname.obs_match = x[7] # The is the number that matched in the actual data set

    # Comment out the Following to use defualt
    tname.quality = max(min(r.gauss(50, 30), 100), 1) # on a scale 0-100
    tname.number_to_interview = 10 * tname.openings
    tname.observe_1 = r.gauss(1, .2)
    tname.observe_2 = tname.observe_2 = (r.gauss(1, .1)- tname.observe_1)
    tname.observed_1 = r.gauss(1, .2)
    tname.observed_2 = (r.gauss(1, .1)- tname.observed_1) # based on applicant interviewed, percentage
예제 #26
0
 def parse(self, token):
     self.parsed = json.loads(self.data)
     # print formatted received json
     # print(json.dumps(self.parsed, indent=4, sort_keys=True))
     db = DataBase()
     self.institutions = []
     for row in self.parsed["data"]:
         new_institution = Institution()
         new_institution.id = row["id"]
         new_institution.address = self.try_figure_out(row, "address")
         new_institution.benefit = self.try_figure_out(row, "benefit")
         new_institution.car_park = self.try_figure_out(row, "car-park")
         new_institution.locality = self.try_figure_out(row, "locality")
         new_institution.phone = self.try_figure_out(row, "phone")
         new_institution.place = self.try_figure_out(row, "place")
         new_institution.provider = self.try_figure_out(row, "provider")
         new_institution.regon = self.try_figure_out(row, "regon-provider")
         if token is not None:
             new_institution.is_fav = db.is_fav(token, row["id"])
         # new_institution.p_print()
         self.institutions.append(new_institution)
     self.create_response_dict()
예제 #27
0
 def parse_id_response(self):
     self.parsed = json.loads(self.data)
     new_institution = Institution()
     new_institution.id = self.parsed["data"]["id"]
     new_institution.address = self.try_figure_out(self.parsed["data"],
                                                   "address")
     new_institution.benefit = self.try_figure_out(self.parsed["data"],
                                                   "benefit")
     new_institution.car_park = self.try_figure_out(self.parsed["data"],
                                                    "car-park")
     new_institution.locality = self.try_figure_out(self.parsed["data"],
                                                    "locality")
     new_institution.phone = self.try_figure_out(self.parsed["data"],
                                                 "phone")
     new_institution.place = self.try_figure_out(self.parsed["data"],
                                                 "place")
     new_institution.provider = self.try_figure_out(self.parsed["data"],
                                                    "provider")
     new_institution.regon = self.try_figure_out(self.parsed["data"],
                                                 "regon-provider")
     new_institution.is_fav = True
     self.institutions = [new_institution]
     self.create_response_dict()
예제 #28
0
 def __init__(self, name, infec_prob=0.0, posn=(0, 0, 0, 0)):
     Institution.__init__(self, name, infec_prob, posn)
예제 #29
0
 def __init__(self, name, infec_prob=0.0, posn=(0, 0, 0, 0), door_posns=[]):
     Institution.__init__(self, name, infec_prob, posn)
     self.door_posns = door_posns
     PROB_STUDENT_BOARDS = 0.50  # TODO: reconsider this constant