def test_straight(self): card_ranks_set = self.rank_cards_set() for index in range(len(card_ranks_set) - 4): if ranks.index(card_ranks_set[index].value) - ranks.index( card_ranks_set[index + 4].value) == 4: self.straight = True self.straight_lead = card_ranks_set[index].value return True if Rank('A') in card_ranks_set and card_ranks_set[len(card_ranks_set) - 4] == Rank('5'): self.straight = True self.straight_lead = '5' return True return False
def __init__(self, num_ranks: int, timestep: int, vpic_reader: VPICReader) -> None: self.vpic_reader = vpic_reader self.num_ranks = num_ranks self.time_step = timestep self.ranks = [Rank(vpic_reader, ridx) for ridx in range(num_ranks)] # all data, including what's not yet produced self.ranks_data = [] # data that has been produced. reset after reneg self.ranks_produced = [[] for ridx in range(num_ranks)] # data that has been produced, flattened. reset after reneg. self.ranks_produced_flattened = [] self.ranks_cursors = [] """ number of bins finally returned by the renegotiation. usually equal to the number of ranks, but configurable in case we want to find out 'how much information' the global distribution contains """ self.num_bins_final = num_ranks """ number of pivots gathered from each rank. ideally, this wouldn't be a function of the scale. we hope that in practice, this is some logarithmic function of scale or something """ self.num_pivots_sent = num_ranks * 4 """ number of counters maintained by each rank to construct the pivots to be sent in the previous step. 1x-2x should be sufficient if we expect the distribution to change slowly. we don't think (yet) that this needs to be a function of scale """ self.num_pivots_stored = self.num_pivots_sent * 2 return
def topThreeNum(request): if request.method == 'POST': username = json.loads(request.body.decode()).get('username') try: anchorDict = {} userId = models.User.objects.get(userName=username, isAnchor=0) # rank data room = models.UserStatistics.objects.filter( userId_id=userId).annotate(rank=Rank('num')) # get related statistics for i in range(room.count()): name = models.User.objects.get( userId=room[i].roomId_id).userName rank = room[i].rank num = room[i].num if (rank > 3): break newDict = {name: {'rank': rank, 'num': num}} anchorDict.update(newDict) except: anchorDict = 0 ret = anchorDict return HttpResponse(json.dumps(ret), content_type="application/json")
def test_2_rank_pivots(self): vpicReader = VPICReader('.') rank = Rank(vpicReader, 2) rank.insert(range(20)) pivots, pivot_width = rank.compute_pivots(5) self.assertEqual(pivots, [0, 5, 10, 15, 19]) self.assertAlmostEqual(pivot_width, 5.0) return
def annotate_results_rank(self, results): """ Annotate results list with lower_rank and upper_rank. The result cannot be filtered, so use get_result_id_rank_list function to get the rank list. """ results = results.annotate( lower_rank=Rank("result"), upper_rank=UpperRank("result"), ) return results
def test_straightflush(self): self.royal = False if self.test_flush(): self.flush_ranks = [] for card in self.cards: if card.suit.value == self.flush_suit: self.flush_ranks.append(card.rank) if self.flush_ranks[4] == Rank('T'): self.royal = True return True for index in range(len(self.flush_ranks) - 4): if ranks.index(self.flush_ranks[index].value) - ranks.index( self.flush_ranks[index + 4].value) == 4: self.sf_lead = self.flush_ranks[index].value return True if Rank('A') in self.flush_ranks and self.flush_ranks[ len(self.flush_ranks) - 4] == Rank('5'): self.sf_lead = '5' return True return False
def test_1_insert_init(self): self.vpicReader = VPICReader('.') self.rank = Rank(self.vpicReader, 2) self.rank.insert(range(20)) self.assertEqual(len(self.rank.oob_left), 20, msg="init insertion not okay") self.assertEqual(len(self.rank.oob_right), 0, msg="init insertion not okay") self.assertIsNone(self.rank.pivots) self.assertIsNone(self.rank.pivot_counts)
def cardsInOrder(ranks): sortedRanks = list(map(createRank, ranks)) sortedRanks.sort() asRank = Rank('A') if (asRank in sortedRanks): sortedRanks.pop(0) for rank in sortedRanks: if (rank == sortedRanks[len(sortedRanks) - 1]): continue if (rank.getNextValue() not in sortedRanks): return False return (Rank('2') in sortedRanks or Rank('K') in sortedRanks) else: for rank in sortedRanks: if (rank == sortedRanks[len(sortedRanks) - 1]): continue if (rank.getNextValue() not in sortedRanks): return False return True
class TestParseUrl(unittest.TestCase): rank = Rank() def test_CountRankPersonInPage(self): self.assertEqual(self.rank.counts_in(page, words_dict), {1: 4, 2: 4}) def test_CountRankPersonInEmptyPage(self): self.assertEqual(self.rank.counts_in(empty_page, words_dict), { 1: 0, 2: 0 })
def __init_status(self): # 선 random.shuffle(self.players) # self.first = self.players[0] # 족보 with open('ranks.csv', 'r', encoding='utf-8') as f: csv_reader = csv.reader(f) for l in csv_reader: comb = set(zip(l[2::4], l[3::4], l[4::4], l[5::4])) self.ranks.append( Rank(name=l[0], ranking=l[1], combination=comb))
def get_ranking_data(course_class, ranking_size): ranking = Grade.objects.values('enrollment__student__id').annotate( total=Sum( Case(When(is_canceled=True, then=0), When(assignment_task__points=None, then=F('score')), default=F('score') * F('assignment_task__points'), output_field=IntegerField())), full_name=F('enrollment__student__full_name'), student_id=F('enrollment__student__id'), ).annotate( # this "dense_rank" was throwing an error sometimes, randomly # it was not finding the previous "total" annotation # so I put it in another "annotate" to respect the dependency dense_rank=Rank('total'), ).filter( enrollment__course_class=course_class).order_by( '-total', 'full_name')[:ranking_size] # print(ranking.query) return ranking
def test_sort(): [Rank("2"), Rank("Q"), Rank("A"), Rank("4")].sort() == [Rank("A"), Rank("2"), Rank("4"), Rank("Q")]
def test_A_equals(): assert Rank("A") == Rank("A")
def test_K_equals(): assert Rank("K") == Rank("K")
def test_Q_equals(): assert Rank("Q") == Rank("Q")
def test_J_equals(): assert Rank("J") == Rank("J")
def create_card(cardstring): rank = Rank(cardstring[0]) suit = Suit(cardstring[1]) card = Card(rank, suit) return card
def __init__(self, suit_number, rank_number): self.suit = Suit(suit_number) self.rank = Rank(rank_number)
outname = '../paper/figures/synth.wav' s = utilities.mk_synth(pf[0], 1, wp[2], pf, c) utilities.write_wav(s, wp[2], outname) wav, wp, pxx, fxx, p, c, pf = f(outname) print '%s: %s' % (outname, pf) pxx, fxx = utilities.get_psd(s, wp[2]) p, c = utilities.get_peaks(pxx, n) pf = [fxx[i] for i in p] print 'synth: %s' % pf if __name__ == '__main__': n = 5 if len(sys.argv) == 2: n = int(sys.argv[1]) if n < 2: n = 2 ranks = [] for wavdir, wavlist in wavfiles.iteritems(): ranks.append(Rank(wavdir, wavlist, n)) r = ranks[0] print r r.chuck()
#!/usr/bin/env python # -*- coding: utf-8 -*- import remote import threading import time from video import Video from vr import VR from rank import Rank import asyncio if __name__ == '__main__': Video().start() VR().start() Rank().start() asyncio.get_event_loop().run_forever() # while input() != 'q': # time.sleep(1)
rdr = csv.reader(f) csv_data = [] for line in rdr: csv_data.append(line) f.close() # csv_contents_type = ["tem", "cat", "cat", "num", "cat", "num", "num", "num", "num"] csv_contents_type = [ "cat", "cat", "cat", "cat", "num", "num", "num", "num", "num", "num" ] startTime = time.time() #Create Column Data Dictionary data_dict = CreateDictionary(csv_data, csv_contents_type).initialize_dic() #Create Column Combination column_combination = ColumnCombination(data_dict).create_combination() print("Column combination Created.") scenario_dict = Transformation(data_dict, column_combination).transformation() print("Scenario dictionary created") Rank(scenario_dict).rank() endTime = time.time() - startTime print(endTime)
def make_deck(self): for rank in self.card_ranks: for suit in self.card_suits: yield Card(Rank(rank), Suit(suit))
def topThreeTime(request): if request.method == 'POST': username = json.loads(request.body.decode()).get('username') try: userDict = {} anchorId = models.User.objects.get(userName=username, isAnchor=1).userId roomId = models.Room.objects.get(roomId=anchorId) # rank data user = models.UserStatistics.objects.filter(roomId_id=roomId).annotate(rank=Rank('browsingTime')) # get related statistics for i in range(user.count()): name = models.User.objects.get(userId=user[i].userId_id).userName rank = user[i].rank time = user[i].browsingTime if (rank > 3): break newDict = {name: {'rank': rank, 'time': time}} userDict.update(newDict) print(userDict) except: userDict = 0 ret = userDict print(ret) return HttpResponse(json.dumps(ret), content_type="application/json")
def test_2_equals(): assert Rank("2") == Rank("2")
def createRank(rank): return Rank(rank)
def test_10_equals(): assert Rank("10") == Rank("10")
def DFA_module(input_data): """ Mock-up Ver. Dataset 1: TmaxDay_data Dataset 2: tmax_raw_data (from ERP) Dataset 3: Carcrash data """ # read CSV file format (may change) # f = open("./TmaxDay_data.csv", 'r', encoding='utf-8') # f = open("./tmax_raw_data.csv", 'r', encoding='utf-8') # f = open("./carcrash.csv", 'r', encoding='utf-8') # rdr = csv.reader(f) # data_table = [] # for line in rdr: # data_table.append(line) # # f.close() # get data_type (from meta in future) # data_type = ["tem", "cat", "cat", "num", "cat", "num", "num", "num", "num"] #tmaxday # csv_contents_type = ["cat", "cat", "cat", "cat", "cat", "cat", "cat", "cat", "cat", "cat", "cat", "tem", "tem", "num", "cat", "num", "num", "num", "cat"] #tmax_raw_data_set # csv_contents_type = ["cat", "cat", "cat", "cat", "num", "num", "num", "num", "num", "num"] #carcrash data_table = [] data_type = [] data_name = [] for i in range(len(input_data['meta'])): data_name.append(input_data['meta'][i]['name']) data_type.append(input_data['meta'][i]['type']) data_table.append(data_name) for i in range(len(input_data['data'])): data_table.append(input_data['data'][i]) # Time check startTime = time.time() # Create Column Data Dictionary data_dict = CreateDictionary(data_table, data_type).initialize_dic() runtime = time.time() # Pop the csv object to reduce memory usage del data_table print("Runtime : %.4f" % (runtime - startTime)) # Create Column Combination column_combination = ColumnCombination(data_dict).create_combination() print("Column combination Created.") runtime2 = time.time() print("Runtime : %.4f" % (runtime2 - runtime)) # Create Scenario Dictionary - Transformation + Guessing Scenario value scenario_dict = Transformation(data_dict, column_combination).transformation() print("Scenario dictionary created") runtime3 = time.time() print("Runtime : %.4f" % (runtime3 - runtime2)) # Calculate Scenario score and Rank. Top 20 will be printed picked_scenario = Rank(scenario_dict).rank() # Final Time Check endTime = time.time() - startTime json = JsonGenerator(picked_scenario).generate_json() print("Program Runtime : %.4f" % endTime) return json
# Pop the csv object to reduce memory usage del data_table print("Runtime : %.4f" % (runtime - startTime)) # Create Column Combination column_combination = ColumnCombination(data_dict).create_combination() print("Column combination Created.") runtime2 = time.time() print("Runtime : %.4f" % (runtime2 - runtime)) # Create Scenario Dictionary - Transformation + Guessing Scenario value scenario_dict = Transformation(data_dict, column_combination).transformation() print("Scenario dictionary created") runtime3 = time.time() print("Runtime : %.4f" % (runtime3 - runtime2)) # Calculate Scenario score and Rank. Top 20 will be printed picked_scenario = Rank(scenario_dict).rank() # Final Time Check endTime = time.time() - startTime json = JsonGenerator(picked_scenario).generate_json() print("Program Runtime : %.4f" % endTime) print(json)
from menu import Menu from play import Play from fps import Fps from rank import Rank from difficulty import Difficulty import GVar window = Window(GVar.WIDTH, GVar.HEIGHT) window.set_title("Space Invaders") window.set_background_color((0, 0, 0)) keyboard = Keyboard() menu = Menu(window) play = Play(window, "./assets/lvl/level_1.txt") difficulty_menu = Difficulty(window) rank = Rank(window) clock = Clock() fps = Fps(window) window.update() while GVar.STATE != 4: window.set_background_color((0, 0, 0)) if keyboard.key_pressed("esc"): GVar.STATE = 0 play.__init__(window, "./assets/lvl/level_1.txt") if GVar.STATE == 0: menu.run() if GVar.STATE == 1: if GVar.DIFC_CHOSEN == True: play.__init__(window, "./assets/lvl/level_1.txt") GVar.DIFC_CHOSEN = False