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
