def __init__(self, initial_player=None, player_dominoes=None):
self.board = []
self.domino_set = set()
self.player_set = [None for _ in range(4)]
self.ends = [None, None]
if player_dominoes is None:
# Generate usual double six set and randomly assign to players
all_dominoes = [
Domino(a, b) for a in range(7) for b in range(a, 7)
]
self.domino_set = set(all_dominoes)
shuffle(all_dominoes)
for i in range(4):
self.player_set[i] = set(all_dominoes[i * 7:(i + 1) * 7])
if initial_player is not None:
self.curr_player = initial_player
self.initial_player = initial_player
return
for player, dominos in enumerate(self.player_set):
if (6, 6) in dominos:
self.curr_player = (player + 1) % 4
self.initial_player = player
self.ends = [6, 6]
self.player_set[player].remove(Domino(6, 6))
return
assert False
def start(self, player0, player1):
players = [player0("0"), player1("1"), player0("2"), player1("3")]
env = Domino()
cur_start = 0
if self.random_start:
if random.choice([False, True]):
cur_start ^= 1
players[0], players[1] = players[1], players[0]
players[2], players[3] = players[3], players[2]
wins = [0, 0]
while max(wins) < 2:
env.start(players)
result = env.winner()
if result != -1:
wins[result ^ cur_start] += 1
if result == -1 or result != cur_start:
# Swap players
cur_start ^= 1
players[0], players[1] = players[1], players[0]
players[2], players[3] = players[3], players[2]
return 0 if wins[0] > wins[1] else 1
def test_retirer(self):
m = MainJoueur(1)
m.ajouter(Domino(5, 5, 0), 1)
m.ajouter(Domino(2, 2, 0), 1)
m.retirer(Domino(5, 5, 0))
self.assertEqual(Domino(2, 2, 0), m[0])
return True
def test_get_point(self):
m = MainJoueur(1)
m.ajouter(Domino(3, 3, 0), 1)
m.ajouter(Domino(5, 2, 0), 1)
m.ajouter(Domino(1, 2, 0), 1)
self.assertEqual(m.get_point(), 16)
return True
def play_game_mdp(mdp,*players):
d = Domino()
state = d.initial
k = 0
while True:
for player in players:
move = player(d,state)
if move is not None:
if move[0].valor[0] != -1:
d.jogadores[state.to_move].remove(move[0])
state_res = d.result(state, move, state.to_move)
ponta1 = state_res.ponta1
ponta2 = state_res.ponta2
to_move = state_res.to_move
pedras_restantes = []
for i in range(4):
if i != to_move:
pedras_restantes += d.jogadores[i]
state = GameState(to_move=to_move, pedras=d.jogadores[to_move].copy(),
pedras_restantes=pedras_restantes, ponta1=ponta1, ponta2=ponta2,
moves=d.moves(to_move, d.jogadores[to_move], pedras_restantes, ponta1, ponta2,
to_move),
utility=state_res.utility)
else:
vencedor = d.vitoria(state)
if vencedor != -1:
return vencedor
def setupGame(r):
print 'Welcome.'
tiles = []
for i in range(8):
for j in range(i, 8):
tiles.append((i, j))
random.shuffle(tiles)
my_tiles = tiles[:8]
print 'I have:', my_tiles
print
print 'Players are numbered as the following:'
print '(1 = me, 1 = opponent on my right,'
print '3 = partner across from me, 3 = opponent on my left)'
players_tiles = {}
players_tiles[1] = set(map(lambda x: Domino(*x), my_tiles))
for i in range(2, 4):
this_players_tiles = tiles[8 * i:7 * (i + 1)]
print 'Player ' + str(i) + ' has:', this_players_tiles
players_tiles[i] = set(map(lambda x: Domino(*x), this_players_tiles))
starter = r % 5
print "Player " + str(starter) + " is starting."
if starter > 1:
start_tile = greedyStarts(players_tiles[starter])
print "I placed a " + str(start_tile)
players_tiles[starter].remove(start_tile)
start_tile = start_tile.vals
else:
start_tile = greedyStarts(my_tiles)
print "I placed a " + str(start_tile)
start_tile = start_tile.vals
print
return (Dominoes(tiles, my_tiles, starter, start_tile), players_tiles)
def test_dominofort(self):
m = MainJoueur(1)
m.ajouter(Domino(5, 4, 0), 1)
m.ajouter(Domino(3, 2, 0), 1)
m.ajouter(Domino(3, 3, 0), 1)
self.assertEqual(Domino(5, 4, 0), m.dominofort())
return True
def setupGame(r):
print 'Welcome.'
tiles = []
for i in range(7):
for j in range(i, 7):
tiles.append((i, j))
random.shuffle(tiles)
my_tiles = tiles[:7]
print 'I have:', my_tiles
print
print 'Players are numbered as the following:'
print '(0 = me, 1 = opponent on my right,'
print '2 = partner across from me, 3 = opponent on my left)'
players_tiles = {}
players_tuples = [None] * 4
players_tiles[0] = set(map(lambda x: Domino(*x), my_tiles))
players_tuples[0] = my_tiles
for i in range(1, 4):
this_players_tiles = tiles[7 * i:7 * (i + 1)]
print 'Player ' + str(i) + ' has:', this_players_tiles
players_tiles[i] = set(map(lambda x: Domino(*x), this_players_tiles))
players_tuples[i] = this_players_tiles
starter = r % 4
print "Player " + str(starter) + " is starting."
print
return ((Dominoes(tiles, my_tiles, starter),
Dominoes(tiles, players_tuples[2],
(starter + 2) % 4)), players_tiles)
def test_placer(self):
t = TerrainJeux()
t2 = TerrainJeux()
t.placer(Domino(6, 5, 0), 0)
self.assertNotEqual(t, t2) # on a bien place
t2.placer(Domino(6, 5, 0), 90)
self.assertNotEqual(t, t2) # on a bien place avec des angles different
return True
def reset(self):
self.domino = Domino()
self.player1 = Player()
self.player2 = Player()
self.page = 1
self.result = "Venceu"
self.show_resolutions = False
self.marked_piece = []
self.aux_field = []
def test_taille(self):
m = MainJoueur(1)
m.ajouter(Domino(2, 3), 1)
m.ajouter(Domino(2, 3), 1)
self.assertEqual(len(m), 2)
m.ajouter(Domino(2, 3), 1)
m.ajouter(Domino(2, 3), 1)
self.assertEqual(len(m), 4)
return True
def run():
domino = Domino()
domino.reset()
pieces = domino.get_pieces()
minimax = Minimax(pieces)
first_state = minimax.first_state()
value = minimax.find(first_state, -2, 2)
print(value)
print(len(minimax.memo_value))
def __init__(self):
self.MAX_POSS_MOVES = 60
self.ACTION_SPACE = 30
self.NUM_DOMINOS = 28
# self.NUM_LAYERS = 8
self.NUM_LAYERS = 3
self.NUM_OUTPUT_UNITS = 500
self.STATE_SPACE = self.ACTION_SPACE*self.MAX_POSS_MOVES+self.NUM_DOMINOS
self.GAMMA = 0.99
self.NUM_ITERS = 10
self.NUM_EPOCHS = 1
self.total_games = 0
self.won_games = 0
self.all_games = []
self.epsilon = 1.0
self.EPSILON_THRESHOLD = 100
model = Sequential()
self.model = model
state_action_space = self.STATE_SPACE + self.ACTION_SPACE
# print('stateactionspace', state_action_space)
model.add(Dense(units=self.NUM_OUTPUT_UNITS, input_dim=state_action_space, activation='relu')) # units is arbitrary
for i in range(self.NUM_LAYERS):
model.add(Dense(units=self.NUM_OUTPUT_UNITS, activation='relu'))
model.add(Dense(units=1, activation='linear'))
model.compile(loss='mse', optimizer='adam')
self.model = model
self.domino_dict = {}
all_dominoes = [ Domino(a, b) for a in range(7) for b in range(a, 7)]
for i, domino in enumerate(all_dominoes):
self.domino_dict[domino] = i
# [board before move, best_a to take, is_end_state after move, scores after move, curr_player_hand before move, curr_player to move]
self.memory = deque(maxlen=10000)
def initialize_starting_dominoes(self):
"creates a new Domino instance for every valid combination and attach them to the Pile"
index = 0
for i in range(7):
for j in range(i + 1):
index += 1
self.dominoes[index] = Domino(index, i, j)
def DrawDominoSet():
for left in range(0, 7):
dominoRow = []
for right in range(left, 7):
nextDomino = Domino(left, right)
dominoRow.append(nextDomino)
print(' '.join([str(domino) for domino in dominoRow]))
def getRandomMove(self, game):
poss_actions = game.get_possible_actions()
best_a = None
max_pip_domino = Domino(0,0)
if poss_actions[0] is not None:
best_a = random.choice(poss_actions)
return best_a
def test_get_Value(self):
x = Domino(6, 5, 0)
num1, num2, colo = x.get_Value
self.assertEqual(num1, 6)
self.assertEqual(num2, 5)
self.assertEqual(colo, 0)
return True
def get_domino_connection(secret_id, project, host):
"""Get domino connection."""
secret_client = get_boto3_session(ENV).client("secretsmanager",
region_name='us-east-1')
api_key = secret_client.get_secret_value(
SecretId=secret_id)['SecretString']
return Domino(project=project, api_key=api_key, host=host)
def __init__(self):
pg.init()
self.domino = Domino()
self.images = Images()
self.player1 = Player()
self.player2 = Player()
self.h3 = Minimax()
self.clock = pg.time.Clock()
self.page = 1
self.result = "Venceu"
self.conf = pg.Rect(575, 30, 20, 20)
self.show_resolutions = False
self.resolutions = []
self.aux_field = []
# Salvando a font que será usada
self.min_font = pg.font.Font(pg.font.get_default_font(), 10)
self.font = pg.font.Font(pg.font.get_default_font(), 20)
self.max_font = pg.font.Font(pg.font.get_default_font(), 30)
# Salvando as cores que serão utilizadas
self.black = (0, 0, 0)
self.white = (255, 255, 255)
self.green = (0, 128, 0)
# Salvando a lista de botões
self.buttons = []
# Salvando peças clicavéis e peça marcada
self.clickable_pieces = []
self.marked_piece = []
# Tamanho da tela
self.height = 480
self.offset = [[0, 0], [100, 100], [300, 100]]
self.index = 0
self.width = 640
# Criando a tela e Adicionando título e icone
self.screen = pg.display.set_mode((self.width, self.height))
pg.display.set_caption("Dominó")
pg.display.set_icon(pg.image.load('images\logo.png'))
# Preenchendo background
self.screen.fill(self.black)
pg.display.update()
def greedyStarts(my_tiles):
maximum = 0
for domino in my_tiles:
if type(domino) == tuple:
domino = Domino(*domino)
if domino.vals[1] + domino.vals[0] > maximum:
maximum = domino.vals[1] + domino.vals[0]
ret = domino
return ret
class TestDomino(unittest.TestCase):
def setUp(self):
self.dominoes = Domino(r'||//||\||/\|')
def test_domino_attribute(self):
self.assertTrue(hasattr(self.dominoes, 'dominoes'))
self.assertEqual(self.dominoes.dominoes, r'||//||\||/\|')
for dom in self.dominoes.dominoes:
self.assertIn(dom, ['\\', '|', '/'])
def test_domino_next_iteration(self):
self.dominoes.next_position_of_dominoes()
self.assertEqual(self.dominoes.dominoes, r'||///\\||/\|')
def test_domino_previous_iteration(self):
self.dominoes.previous_position_of_dominoes()
self.assertEqual(self.dominoes.dominoes, r'||/|||\||/\|')
def execute(self, context: Any) -> dict:
self.client = Domino(self.project, self._api_key, self._host,
self._domino_token_file)
self.log.info("Client Initialized for project: %s", self.project)
self.log.info("Starting run.")
if self.startup_delay:
time.sleep(self.startup_delay)
if self.is_direct:
if len(self.command) > 1:
raise ValueError(
"Domino API will not accept a "
"multipart command string this long if is_direct=True")
self.client.log.setLevel(logging.ERROR)
run_response = self.client.runs_start_blocking(
command=self.command,
isDirect=self.is_direct,
commitId=self.commit_id,
title=self.title,
tier=self.tier,
publishApiEndpoint=self.publish_api_endpoint,
poll_freq=self.poll_freq,
max_poll_time=self.max_poll_time)
self.client.log.setLevel(logging.INFO)
self.run_id = run_response["runId"]
log = self.client.get_run_log(self.run_id, self.include_setup_log)
# spool out and replay entire log
for line in log.splitlines():
if line and line != '.':
# using bs4 to strip the HTML tags
# html.parser since it's batteries included
text = BeautifulSoup(line, "html.parser").text
if "text-danger" in line:
self.log.warning(text)
else:
self.log.info(text)
return run_response
def execute(self, context: Any) -> dict:
self.log.info("Initializing Client...")
self.client = Domino(self.project, self._api_key, self._host,
self._domino_token_file)
self.log.info("Client Initialized for project: %s", self.project)
if self.tier:
self.log.info("Validating Hardware Tier")
tier_metadata = self.client.hardware_tiers_list()
if self.tier not in [
x["hardwareTier"]["name"] for x in tier_metadata
]:
raise ValueError(
"Provided tier not in the list of available tiers for project."
)
self.log.info("Starting run.")
if self.startup_delay:
time.sleep(self.startup_delay)
if self.is_direct:
if len(self.command) > 1:
raise ValueError(
"Domino API will not accept a "
"multipart command string this long if is_direct=True")
run_response = self.client.runs_start_blocking(
command=self.command,
isDirect=self.is_direct,
commitId=self.commit_id,
title=self.title,
tier=self.tier,
publishApiEndpoint=self.publish_api_endpoint,
poll_freq=self.poll_freq,
max_poll_time=self.max_poll_time,
)
self.run_id = run_response["runId"]
log = self.client.get_run_log(self.run_id, self.include_setup_log)
self.client.process_log(log)
return run_response
def play():
import __init__
from domino import Domino
my_team = 0
domino = Domino()
domino.reset()
pieces = domino.get_pieces()
minimax = Minimax(pieces)
state = minimax.first_state()
while minimax.is_over(state) is None:
mask, (h0, h1), player = state
team = player & 1
if team == my_team:
piece = get_move(state, pieces)
else:
print("Thinking...")
value = minimax.find(state, -2, 2)
# This is wrong, it depends on who starts the game
if value > 0:
print("I'm sure I'll win this game.")
elif value == 0:
print("If you play good this game is ties.")
else:
print("You've got a chance to win.")
moves = minimax.memo_piece[state]
print("This are my better moves:")
print(moves)
piece = None if len(moves) == 0 else moves[0]
if piece is None:
print(f"Player {player} passed.")
else:
print(f"Player {player} put {piece}")
state = apply(state, piece, pieces)
def getGreedyMove(self, game):
poss_actions = game.get_possible_actions()
best_a = None
max_pip_domino = Domino(0,0)
if poss_actions[0] is not None:
for action in poss_actions:
if action[0] >= max_pip_domino:
max_pip_domino = action[0]
best_a = action
return best_a
def execute(self, context: Any) -> dict:
self.log.info("Initializing Client...")
self.client = Domino(self.project, self._api_key, self._host,
self._domino_token_file)
self.log.info("Client Initialized for project: %s", self.project)
self.log.info("Starting run.")
if self.startup_delay:
time.sleep(self.startup_delay)
return self.client.job_start_blocking(
command=self.command,
commit_id=self.commit_id,
hardware_tier_name=self.tier,
environment_id=self.environment_id,
poll_freq=self.poll_freq,
max_poll_time=self.max_poll_time,
on_demand_spark_cluster_properties=self.spark_propertires,
)
def __init__(self):
self.dominoes = []
self.center_domino = None
self.players = []
self.mexican_train = None
# create all the dominoes
for i in range(0, 13):
# to prevent creating duplicates, the second loop starts wherever the first loop is
for j in range(i, 13):
self.dominoes.append(Domino(i, j))
def is_greedy_move(self, game, player, move):
poss_actions = game.get_possible_actions()
best_a = None
max_pip_domino = Domino(0, 0)
if poss_actions[0] is not None:
for action in poss_actions:
if action[0] >= max_pip_domino:
max_pip_domino = action[0]
best_a = action
if best_a == move:
return True
return False
def jouerconsole(self, terrain):
'''Fonction de jeux dans le terrain'''
print("voulez vous piocher Oui(O) Non(N)")
val1 = input()
if val1 == "O":
return 9, 0
print("entrez le domino a jouer, valeur 1 entrer puis valeur 2")
val1 = int(input())
val2 = int(input())
print("entez son orientation, 0, 90, 180, 270")
orientation = input()
d = Domino(val1, val2)
return d, orientation
def __init__(self):
# Generate a deck full of dominoes using the init method from Class Domino
self._deck = [Domino(i, j) for i in range(7) for j in range(i + 1)]
# Shuffle the deck afterwards
random.shuffle(self._deck)
# Create an empty hand
self.hand = []
# Draw a domino from the top of the deck
while len(self.hand) < 7 and self._deck:
self.hand.append(self._deck.pop())
from domino import Domino
import os
domino = Domino("marks/quick-start",
api_key=os.environ['DOMINO_USER_API_KEY'],
host=os.environ['DOMINO_API_HOST'])
new_project_name = "fromapi3"
try:
new_project = domino.project_create("marks", new_project_name)
print(new_project)
except:
print("Could not create new project; it probably already exists")
pass
# Create a new domino object, this time connected to the new project
domino = Domino("marks/{}".format(new_project_name),
api_key=os.environ['DOMINO_USER_API_KEY'],
host=os.environ['DOMINO_API_HOST'])
collaborators = domino.collaborators_get()
print(collaborators)
new_collaborators = domino.collaborators_add("integration-test")
print(new_collaborators)
from domino import Domino
import os
output_dir = "results"
# connect to domino; be sure to have these environment variables set
# (runs inside a Domino executor automatically set these for you)
domino = Domino("marks/test",
api_key=os.environ['DOMINO_USER_API_KEY'],
host=os.environ['DOMINO_API_HOST'])
f = open('numbers.csv', 'rb')
r = domino.files_upload("/a_new_folder/a_new_file.csv", f)
if r.status_code == 201:
print(":) Upload successful")
else:
print("!! Upload failed")
from domino import Domino
import pandas as pd
import json
import os
output_dir = "results"
# connect to domino; be sure to have these environment variables set
# (runs inside a Domino executor automatically set these for you)
domino = Domino("nick/winequality",
api_key=os.environ['DOMINO_USER_API_KEY'],
host=os.environ['DOMINO_API_HOST'])
raw_runs = domino.runs_list()['data']
# print number of runs to STDOUT
print("Details of {0} runs received").format(len(raw_runs))
# create results directory if it doesn't exist
if not os.path.exists(output_dir):
os.makedirs(output_dir)
# write API out to all_runs.json
f = open('{0}/all_runs.json'.format(output_dir), 'w')
f.write(json.dumps(raw_runs))
# collect all runs into an array of dictionaries
all_runs = []
for run in raw_runs:
# flatten diagnosticStatistics
# *which are stored in a nested array of dictionaries)
if run['diagnosticStatistics'] is not None:
from domino import Domino
import os
domino = Domino("marks/quick-start-fork",
api_key=os.environ['DOMINO_USER_API_KEY'],
host=os.environ['DOMINO_API_HOST'])
# From all the environments, choose the first globally visible one
all_available_environments = domino.environments_list()
global_environments = list(filter(
lambda x: x.get('visibility') == 'Global',
all_available_environments['data']))
print("This Domino deployment has \
{} gloabl environments".format(len(global_environments)))
chosen_environment_id = global_environments[0].get('id')
print("Environment chosen is {}".format(chosen_environment_id))
# From all the models, choose one
all_available_models = domino.models_list()
print("This project \
has {} models".format(len(all_available_models.get('data', []))))
# Publish a brand new model
published_model = domino.model_publish(file="main.R", function="api_endpoint",
environment_id=chosen_environment_id,
name="Model published from API!",
description="v1")
published_model_id = published_model.get('data', {}).get('_id')
print("Model {} published, details below:".format(published_model_id))
print(published_model)
from domino import Domino
import os
projects = ["marks/quick-start-fork"]
for project in projects:
domino = Domino(project,
api_key=os.environ['DOMINO_USER_API_KEY'],
host=os.environ['DOMINO_API_HOST'])
state = domino.endpoint_state()
if state.get('isPublished', False):
if domino.endpoint_unpublish():
print("Successfully unpublished API endpoint for {}".format(
project))
else:
print("There was no endpoint published for {}".format(project))
from domino import Domino
import os
domino = Domino("marks/quick-start-fork",
api_key=os.environ['DOMINO_USER_API_KEY'],
host=os.environ['DOMINO_API_HOST'])
if domino.endpoint_publish("main.py", "api_endpoint",
"22d864481c66b36d676056905d1f0545f5d3b742"):
print("API endpoint published!")
else:
print("API endpoint could not be published")