def test_random_player():
wheel = create_wheel()
rng = NonRandomOutcomeChoice(wheel)
expected_outcomes = [wheel.get_outcome(n) for n in ["Black", "Low", "00"]]
rng.set_outcomes(expected_outcomes)
table = Table(wheel)
random_player = RandomPlayer(table, rng=rng)
bets = [random_player.next_bet() for i in range(3)]
actual_outcomes = [b.outcome for b in bets]
assert actual_outcomes == expected_outcomes
def concat(R, S):
if (R.column != S.column): raise SyntaxError("Wrong condition setting.")
table = Table(R.column) # The returned new
for Rdata in R.data:
if (Rdata == None): continue
table.insert(Rdata)
for Sdata in S.data:
if (Sdata == None): continue
table.insert(Sdata)
return table
def __init__(self):
self.window = Window(SCREEN_WIDTH, SCREEN_HEIGHT)
self.cursor = self.window.create_cursor()
self.table = Table()
self.running = True
self.game_ended = False
self._starting_screen()
self.enemy = self.window.create_enemy()
self.timer = Timer(self.cursor.display, (700, 350),
self.window.mixer.Sound("./../assets/pop.wav"))
def __init__(self, table_size=100):
self.table_size = table_size
self.table = Table(table_size)
self.players = [
RandomPlayer(self.table, 'Player one random'),
MemoryPlayer(1, self.table, 'Player two memory'),
MemoryPlayer(1, self.table, 'Player three memory'),
]
self.counter = 1
self.mongodb = MongoClient().pexes
def setUpClass(cls):
cls.files = ['city.csv', 'country.csv', 'language.csv']
cls.datasets = {}
for file_name in cls.files:
file_path = './assignment-data/' + file_name
table = Table(file_path)
cls.datasets[file_name] = table
cls.solver = CSVQuerySolver(cls.datasets)
def test_playAGame(self):
table = Table()
# table.players = testFunctions.buildPlayers(23)
table.players = buildPlayers(5)
table.setDealerAtRandom()
for _ in range(10):
playAHand(table)
table.prepareForNextHand()
def orders():
orders = Table(("O_Id", int), ("OrderNo", int), ("P_Id", int))
orders.insert(1, 77895, 3)
orders.insert(2, 44678, 3)
orders.insert(3, 22456, 1)
orders.insert(4, 24562, 1)
orders.insert(5, 34764, 15)
return orders
def __init__(self):
super().__init__()
for excel in yaml_rw.read()['excel']: # 从配置文件导出excel文件名
tb_name = os.path.splitext(excel)[0] # 去后缀名
self.tb_box.addItem(tb_name)
if excel != '无':
self.name2table[tb_name] = Table('excel\\' + excel)
self.set_format_list_widget()
self.set_tb_tags_table_widget()
self.set_event_listeners()
def createTable(self, tableName, attributes):
#print(type(attributes))
if tableName in self.dbTables:
print("table ", tableName, " already exist")
else:
user_table = Table(tableName, attributes)
self.dbTables[tableName] = user_table
print(tableName, "Table Created")
return self.dbTables[tableName]
def test_left_round_place(self):
steps = '\
PLACE 0,0,NORTH\n\
LEFT\n\
LEFT\n\
LEFT\n\
LEFT'
parser = Parser(Table())
self.assertEqual(parser.parse_text(steps), "0,0,NORTH")
def __init__(self):
self.initprob = Table(float,
DEALER_CODE + ['BJ'],
INITIAL_CODE,
unit='%')
self.dealprob = defaultdict(
lambda: defaultdict(lambda: 0)) # initialize 0
self.stand_ev = Table(float, DEALER_CODE, STAND_CODE)
self.hit_ev = Table(float, DEALER_CODE, NON_SPLIT_CODE)
self.double_ev = Table(float, DEALER_CODE, NON_SPLIT_CODE)
self.split_ev = Table(float, DEALER_CODE, SPLIT_CODE)
self.optimal_ev = Table(float, DEALER_CODE, PLAYER_CODE)
self.strategy = Table(str, DEALER_CODE, PLAYER_CODE)
self.advantage = 0.
self.resplit_ev = [
Table(float, DEALER_CODE, STAND_CODE),
Table(float, DEALER_CODE, SPLIT_CODE[:-1]),
Table(float, DEALER_CODE, SPLIT_CODE[:-1])
]
def test_fall_robot_north_east_corner(self):
steps = f'\
PLACE {config.UNITS-1},{config.UNITS-1},NORTH\n\
MOVE\n\
RIGHT\n\
MOVE'
parser = Parser(Table())
self.assertEqual(parser.parse_text(steps),
f"{config.UNITS-1},{config.UNITS-1},EAST")
def __init__(self):
self.function_list = []
self.not_acces_table = Table('content_db', 'not_access')
#self.driver = utils.create_firefox()
#self.driver.set_page_load_timeout(60)
#self.driver.set_script_timeout(60)
socket.setdefaulttimeout(60)
self.today=datetime.datetime.now().strftime('%Y-%m-%d')
self.img_dir='/home/ops/appimg/'+self.today+'/'
self.prefix='appimg/'+self.today+'/'
self.func_list=[self.handle_desc_img, self.handle_text, self.handle_go_link_simple, self.handle_remove_go_link, self.handle_remove_short_article, self.handle_remove_crawl_desc_img, self.handle_mark_stat_use, self.handle_remove_empty_title_and_empty_desc, self.handle_gen_loc_code, self.handle_gen_score, self.handle_add_desc_img, self.handle_store_price, self.handle_recognize_link, self.handle_trans_good]
self.info_table = Table('content_db', 'info')
self.info_old_table = Table('content_db', 'info_old')
self.region_table = Table('baseinfo', 'region', 'name')
self.goods_table = Table('goods_db', 'info')
self.id_dict = load_dict('id.list')
self.crawl_source_dict = load_cat_map('old2new_cat.txt')
self.display_name_conf_dict = load_conf('../uniform/start_url_info_new.conf')
self.neg_article_filter = ['002102003', '002114001', '002115001', '002108002']
def run(loop, pools):
runner = RunnerPool(
int(os.getenv("PIPE_SIZE", "100")),
int(os.getenv("BATCH_SIZE", "100")),
*pools
)
player = Table("player")
tribe = Table("tribe")
member = Table("member")
logging.debug("start all")
loop.run_until_complete(asyncio.wait((
runner.extract(player),
runner.extract(tribe),
runner.extract(member),
)))
loop.run_until_complete(post_update(player, tribe, member, *pools))
logging.debug("end all")
def apply(self, data: 'IndexedCorpus'):
table = Table(header=['id'] + self.names)
new_rows = []
for example in data:
row = {'id': example['id']}
for h in self.listed:
row[h.name] = h(example['content'])
new_rows.append(row)
table.extend(new_rows, form='dict')
return table
def test_join(self):
table = Table("./assignment-data/city.csv")
table2 = Table("./assignment-data/country.csv")
col_name = 'CountryCode'
table.join(table2, col_name)
output = {
'CityID': '1',
'CityName': 'Kabul',
'CountryCode': 'AFG',
'CityPop': '1780000',
'CountryName': 'Afghanistan',
'Continent': 'Asia',
'CountryPop': '22720000',
'Capital': '1'
}
assert table.columns.count(col_name) == 1
assert table.records[0] == output
def run(self):
if not self.task.is_valid():
return
table = Table(self.task).create_table()
sigma_table = PreSolver(table).get_table()
solver = Solver(sigma_table, self.task)
solver.calculate()
solution = solver.get_solution()
self.solution.set_solution_data(table, sigma_table, solution)
def initializeAugmentedEq(self, eqsamplesize=1):
'''initialize augmented parameters based on the equivalent array size.
This can be used to give some prior information before learning.
'''
ri = self.nvalues
qi = 1
for parent in self.family[1:]:
qi = qi * parent.distribution.nvalues
self.augmented = Table(self.names_list, shape=self.shape)
self.augmented[:] = float(eqsamplesize) / (ri * qi)
def createMemoryTable():
global tMem
# Memory Table
titleMem = tk.Label(root)
titleMem.config(bg=bgColor, text='Memoria Principal')
titleMem.place(x=570, y=330)
tMem = Table(root, 17, 3)
tMem.createTable(titlesMem, '#5696fc', 'white', False, True, 1)
tMem.place(x=495, y=350)
def _make_next_table(self):
tid = self.state['next_tid']
self.state['next_tid'] += 1
## for testing
# seats = 5
## for release
seats = ord(self.magic_page[tid]) % CONFIG['MAX_TABLE_SIZE']
if CONFIG['MIN_TABLE_SIZE'] > seats:
seats += CONFIG['MIN_TABLE_SIZE']
return Table(tid=tid, seats=seats, customers=[])
def _match(self, cells, ocr: dict, tables, img):
if len(cells) != len(tables) or cells is None:
raise RuntimeError("对表格未检出Cell！")
self.tables = []
for i in range(len(tables)):
my_table = Table(coord=tables[i], cells=cells[i], verbose=False)
img = my_table.match_ocr(ocr, img)
my_table.build_structure()
self.tables.append(my_table)
return img
def __init__(self, players=None, tag=None):
self.players = players
players[0].is_heads = True
players[1].is_heads = False
self.table = Table(game=self)
self.turn_index = -1
self.end_turn()
def parse(self):
t = Table()
self.tdata = []
review_ids = self.review_ids()
review_paths = self.review_paths()
reviews_df = self.to_df(self.join(review_ids, review_paths))
print '# ReviewsParser'
t.from_tuples(self.tdata, columns=['Operation', 'Count', 'Time (sec)'])
t.display()
return reviews_df
def test_add2target_cards():
target_cards = input('Input target_cards separated by commas:\n')
target_cards = input_to_card_set(target_cards)
table = Table([target_cards])
cards2submit = input('Input cards2submit separated by commas:\n')
cards2submit = input_to_card_set(cards2submit)
p1.make_move_add2target_cards(cards2submit, target_cards, table)
p1.print_cards()
print(table)
def test_contains(self):
h2 = Card('h2')
h3 = Card('h3')
h4 = Card('h4')
h5 = Card('h5')
group1 = CardSet([h2, h3])
group2 = CardSet([h4, h5])
table = Table([group1, group2])
self.assertTrue(table.contains(group2))
self.assertFalse(table.contains(h2))
def set_table(self):
data = db_manage.get_books_catalog()
data, headers = utils.unit_by_field(data, 'title')
data = utils.nested_dict_to_list(data)
rows, cols = len(data), len(data[0])
self.table = Table(data, headers, rows, cols, selectable=0)
self.table.horizontalHeader().setSectionResizeMode(
0, QHeaderView.ResizeToContents)
self.table.resizeRowsToContents()
def __init__(self):
self._atnc = {
'A': 0,
'B': 1,
'C': 2,
'D': 3,
'E': 4,
'F': 5,
'G': 6,
'H': 7
}
self._ui = GUIui(Table([]))
self._player = Player()
self._computer = ComputerPlayer()
plShips = self._ui.setupPlayer()
for ship in plShips:
self._player.addShip(ship[3], ship[0], ship[1], ship[2])
self._playerTable = Table(self._player.ships)
self._computerTable = Table([])
def test10():
the_poor = Table('resources/the_poors.csv')
columns = the_poor.data.columns
print(columns)
for item in columns:
if '.1' in item:
print('ddddddddddddddd')
print(type(columns[7]))
print(type(columns))
print(columns.is_unique)
def results(self):
"""
Get Results
"""
if (self.adql_query != None):
if (self.adql_query.table() != None):
return Table(adql_table=self.adql_query.table())
return None
def test_get_empty_row_index():
a = Table(params['x'], params['y'],
params['w'], params['h'])
a.grid = [[0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0], [0, 0, 1, 0, 0, 0, 0],
[0, 0, 2, 0, 0, 0, 0], [0, 0, 1, 0, 0, 0, 0]]
assert a.get_empty_row_index(2) == 2
assert a.get_empty_row_index(1) == 5
