def getQueenMove(self, state):
myInv = getCurrPlayerInventory(state)
me = state.whoseTurn
queen = myInv.getQueen()
enemy = 1 - me
attackers = getAntList(state, enemy, [SOLDIER, R_SOLDIER, DRONE])
# if there are no attackers move to a default location
if len(attackers) == 0:
return Move(MOVE_ANT, createPathToward(state, queen.coords, (4, 3), UNIT_STATS[QUEEN][MOVEMENT]), None)
# find the most worrying attacker
dist = 99
closest = None
for ant in attackers:
tmp = (ant.coords[1] - 3) / UNIT_STATS[ant.type][MOVEMENT]
if tmp < dist:
dist = tmp
closest = ant
if closest.coords[1] <= 4:
path = createPathToward(state, queen.coords, (closest.coords[0], min(3, closest.coords[1])), UNIT_STATS[QUEEN][MOVEMENT])
elif closest.type == R_SOLDIER:
path = createPathToward(state, queen.coords, (closest.coords[0], 0), UNIT_STATS[QUEEN][MOVEMENT])
else:
path = createPathToward(state, queen.coords, (closest.coords[0], 2), UNIT_STATS[QUEEN][MOVEMENT])
return Move(MOVE_ANT, path, None)
def move(self, state):
mark = None
if state.getState() == Const.STATE_TURN_O:
mark = Const.MARK_O
if state.getState() == Const.STATE_TURN_X:
mark = Const.MARK_X
if mark == None:
raise ValueError("state must be playable")
board = state.getBoard()
playable = []
for row in range(Const.ROWS):
for col in range(Const.COLS):
if board[row][col] == Const.MARK_NONE:
playable.append([row, col])
#Instead of just picking a random spot. First check if there is a winnable Move
tempMove = Move(0, 0, mark)
for i in range(len(playable)):
tempMove.play(playable[i][0], playable[i][0])
#if the spot makes X win then it returns the move
if self._state.getState() == Const.STATE_WIN_X:
tempMove.undo(state)
return tempMove
#otherwise undo and try the next on
playable[i].undo(state)
spot = random.randint(0, len(playable) - 1)
return Move(playable[spot][0], playable[spot][1], mark)
def minimax(board, player_name, depth, start_time):
if depth == MAX_SEARCH_DEPTH or is_out_of_time_for_move(
start_time) or game_over(board):
score = evaluate(board, player_name)
return Move(-1, -1, score)
best_move = Move(
-1, -1, -infinity if player_name == PLAYER_NAMES['P1'] else +infinity)
board_copy = board.get_cloned_board()
for correct_move in get_all_correct_moves(board, player_name,
board.fields):
x, y, piece_x, piece_y = correct_move.x, correct_move.y, correct_move.piece_x, correct_move.piece_y
move_single_piece(board, player_name, correct_move)
player_to_move = get_opponent_player(board, player_name)
potential_move = minimax(board, player_to_move, depth + 1, start_time)
potential_move.x = x
potential_move.y = y
potential_move.piece_x = piece_x
potential_move.piece_y = piece_y
if is_better_score(potential_move, best_move, player_name):
best_move.x = potential_move.x
best_move.y = potential_move.y
best_move.piece_x = potential_move.piece_x
best_move.piece_y = potential_move.piece_y
best_move.score = potential_move.score
board = board_copy.get_cloned_board()
return best_move
def getMove(self, currentState):
# Setup
if self.isFirstTurn:
self.firstTurn(currentState)
# Concede game if taking too long
elif self.turnsPlayed > STALEMATE_TURNS:
workers = getAntList(currentState, currentState.whoseTurn,
(WORKER, ))
for worker in workers:
if not worker.hasMoved:
return Move(
MOVE_ANT,
createPathToward(currentState, worker.coords,
self.enemyHill.coords,
UNIT_STATS[WORKER][MOVEMENT]))
return Move(END)
# Look ahead to each possible state and find the one with the lowest output
bestH = 100000000
bestMove = None
moves = listAllLegalMoves(currentState)
for move in moves:
features = self.extractFeatures(getNextState(currentState, move))
netH = self.network.eval(self.normalizeFeatures(features))[0]
if netH < bestH:
bestH = netH
bestMove = move
if ONLINE_LEARNING:
h = self.heuristicStepsToGoal(features)
self.network.adjustWeights((normalizeHeuristic(h), ))
if bestMove.moveType == END:
self.turnsPlayed += 1
return bestMove
def make_move(self, move):
self.moves_stack.append(move)
if self.stacks[move.to_stack].is_valid(move.disk):
if self.stacks[move.from_stack].peek() == move.disk:
self.stacks[move.from_stack].pop()
self.stacks[move.to_stack].push(move.disk)
print(
f' Stack {move.from_stack} latest position is : {self.stacks[move.from_stack].show()}'
)
print(
f' Stack {move.to_stack} latest position is : {self.stacks[move.to_stack].show()}'
)
this_move = self.moves_stack.pop(len(self.moves_stack) - 1)
if len(self.moves_stack) > 0:
next_move = self.moves_stack.pop(len(self.moves_stack) - 1)
self.make_move(next_move)
else:
dest_stack = self.get_dest_stack(move)
src_stack = move.from_stack
move_disk = self.stacks[src_stack].get_disk_before(move.disk)
new_move = Move(move_disk, src_stack, dest_stack)
self.make_move(new_move)
else:
to_stack_top = self.stacks[move.to_stack].last_disk()
dest_stack = self.get_dest_stack(move)
src_stack = move.to_stack
shuffle_move = Move(to_stack_top, src_stack, dest_stack)
self.make_move(shuffle_move)
def test_get_bar_moves(test_bar):
moves = [Move(0, 26, 24), Move(0, 26, 23)]
test_bar.dice.set_dice(1, 2)
assert test_bar.get_bar_moves() == moves
test_bar.dice.set_dice(6, 6)
assert test_bar.get_bar_moves() == []
def get_pawn_sq_moves(self, sq, color):
moves = []
attacks = Bitboard.pawn_attacks[color][sq]
while attacks:
end_sq = Bitboard.lsb(attacks)
# valid capture
if (abs(Bitboard.get_file(sq) - Bitboard.get_file(end_sq)) == 1
and self.get_square_piece(end_sq) != Piece.NONE
and self.get_square_color(end_sq) != color):
# promotion
if Bitboard.get_rank(end_sq) == 1 or Bitboard.get_rank(
end_sq) == 5:
moves.append(Move(sq, end_sq, Flags.KnightPromCap))
moves.append(Move(sq, end_sq, Flags.BishopPromCap))
moves.append(Move(sq, end_sq, Flags.RookPromCap))
moves.append(Move(sq, end_sq, Flags.QueenPromCap))
else:
moves.append(Move(sq, end_sq, Flags.Capture))
attacks = Bitboard.pop_lsb(attacks)
end_sq = sq + 5 if color == Color.White else sq - 5
if (Bitboard.is_valid_square(end_sq)
and self.get_square_piece(end_sq) == Piece.NONE):
if Bitboard.get_rank(end_sq) == 1 or Bitboard.get_rank(
end_sq) == 5:
moves.append(Move(sq, end_sq, Flags.KnightProm))
moves.append(Move(sq, end_sq, Flags.BishopProm))
moves.append(Move(sq, end_sq, Flags.RookProm))
moves.append(Move(sq, end_sq, Flags.QueenProm))
else:
moves.append(Move(sq, end_sq, Flags.Quiet))
return moves
def moveWorker(self, currentState, workerList):
inventory = getCurrPlayerInventory(currentState)
for ant in workerList:
if not ant.hasMoved:
if (
ant.carrying
): # has food, move toward hill/tunnell, whichever is closer
target = self.findClosestTo(
currentState, ant.coords,
((inventory.getAnthill()).coords,
(inventory.getTunnels())[0].coords))
path = createPathToward(currentState, ant.coords, target,
UNIT_STATS[WORKER][MOVEMENT])
return Move(MOVE_ANT, path, None)
else: # get food
foodCoords = []
for food in self.myFood:
foodCoords.append(food.coords)
target = self.findClosestTo(currentState, ant.coords,
foodCoords)
path = createPathToward(currentState, ant.coords, target,
UNIT_STATS[WORKER][MOVEMENT])
return Move(MOVE_ANT, path, None)
def generate_king_moves(start_sq: int, piece: Piece, b: Board) -> [Move]:
"""Generates moves for Kings"""
moves = []
dire = [-7, -8, -9, -1, 1, 7, 8, 9]
for i in dire:
if not is_check(b, piece):
target_sq = start_sq + i
if target_sq > -1 and target_sq < 64:
if not is_same_colour(piece, b.square[target_sq]):
moves.append(
Move(start_sq, target_sq,
get_move_notation(piece, start_sq, target_sq, b)))
if castle(piece, True, deepcopy(b)):
moves.append(
Move(start_sq,
start_sq - 2,
get_move_notation(piece, start_sq, start_sq - 2, b),
special_turn=SpecialTurn.CastlingLong))
if castle(piece, False, deepcopy(b)):
moves.append(
Move(start_sq,
start_sq + 2,
get_move_notation(piece, start_sq, start_sq + 2, b),
special_turn=SpecialTurn.CastlingShort))
return moves
def spawnAnts(self, currentState, myInv, me):
legalBuilds = listAllBuildMoves(currentState)
if len(legalBuilds) < 1:
return
ants = getAntList(currentState, me,
(WORKER, DRONE, SOLDIER, R_SOLDIER))
antNums = {
"WORKER": [0, any(a.buildType == WORKER for a in legalBuilds)],
"DRONE": [0, any(a.buildType == DRONE for a in legalBuilds)],
"SOLDIER": [0, any(a.buildType == SOLDIER for a in legalBuilds)],
"R_SOLDIER":
[0, any(a.buildType == R_SOLDIER for a in legalBuilds)]
}
for ant in ants:
antNums[antTypeToStr(ant.type)][0] += 1
if (antNums["WORKER"][0] <
self.antList["WORKER"]) and antNums["WORKER"][1]:
return Move(BUILD, [myInv.getAnthill().coords], WORKER)
elif (antNums["DRONE"][0] <
self.antList["DRONE"]) and antNums["DRONE"][1]:
return Move(BUILD, [myInv.getAnthill().coords], DRONE)
elif (antNums["SOLDIER"][0] <
self.antList["SOLDIER"]) and antNums["SOLDIER"][1]:
return Move(BUILD, [myInv.getAnthill().coords], SOLDIER)
else:
return None
def test_move_to_string():
move = Move(0, 24, 23)
assert move.move_to_string(
) == "BLACK checker moves from point 24 to point 23"
move = Move(1, 11, 10)
assert move.move_to_string(
) == "WHITE checker moves from point 11 to point 10"
def get_bar_moves(self):
bar_moves = []
move = Move(self.player.colour, 26, 25 - self.dice.die1)
if self.is_valid_move_from_bar(move):
bar_moves.append(move)
move = Move(self.player.colour, 26, 25 - self.dice.die2)
if self.is_valid_move_from_bar(move):
bar_moves.append(move)
return bar_moves
def getPossibleMoves(self):
# Function run to yield a group of all possible legal and illegal
# 'Move' objects to the calling function. Does this by running through
# a list of movements and testing for valid moves before yielding them.
# Also handles the promotion of pieces and the ability for a piece to
# move two spaces forward on its first move.
pos = self.position
movement = C(0, 1) if self.side == WHITE else C(0, -1)
advanceOnePos = pos + movement
if self.board.isValidPos(advanceOnePos):
if self.board.pieceAtPosition(advanceOnePos) is None:
col = advanceOnePos[1]
if col in [7, 0]:
piecesForPromotion = \
[Rook(self.board, self.side, advanceOnePos),
Knight(self.board, self.side, advanceOnePos),
Bishop(self.board, self.side, advanceOnePos),
Queen(self.board, self.side, advanceOnePos)]
for piece in piecesForPromotion:
move = Move(self, advanceOnePos)
move.promotion = True
piece.movesMade = self.movesMade
move.specialMovePiece = piece
yield move
else:
yield Move(self, advanceOnePos)
if self.movesMade == 0:
advanceTwoPos = pos + movement + movement
if self.board.isValidPos(advanceTwoPos):
if self.board.pieceAtPosition(advanceTwoPos) is None and \
self.board.pieceAtPosition(advanceOnePos) is None:
yield Move(self, advanceTwoPos)
movements = [C(1, 1), C(
-1, 1)] if self.side == WHITE else [C(1, -1), C(-1, -1)]
for movement in movements:
newPos = self.position + movement
if self.board.isValidPos(newPos):
pieceToTake = self.board.pieceAtPosition(newPos)
if pieceToTake and pieceToTake.side != self.side:
col = newPos[1]
if col in [7, 0]:
piecesForPromotion = \
[Rook(self.board, self.side, newPos),
Knight(self.board, self.side, newPos),
Bishop(self.board, self.side, newPos),
Queen(self.board, self.side, newPos)]
for piece in piecesForPromotion:
move = Move(self,
newPos,
pieceToCapture=pieceToTake)
move.promotion = True
move.specialMovePiece = piece
yield move
else:
yield Move(self, newPos, pieceToCapture=pieceToTake)
def execute(self, userdata):
status = 'Success'
sm = smach.StateMachine(outcomes=['Success', 'Failure'])
if userdata.search_object == 'Gate':
with sm:
sm.userdata.type = 'depth'
sm.userdata.args = {
'depth': .65,
'x': 2,
'y': -.8,
'obj': 'Gate',
'bboxWidth': .07,
'hold': True
}
smach.StateMachine.add('MOVE_DOWN',
Move(),
transitions={
'Success': 'Success',
'Failure': 'Failure'
},
remapping={
'type': 'type',
'args': 'args'
})
smach.StateMachine.add('ALIGN',
Align(),
transitions={
'Success': 'Success',
'Failure': 'Failure'
})
smach.StateMachine.add('DISTANCE',
Distance(),
transitions={
'Success': 'Success',
'Failure': 'Failure'
},
remapping={
'type': 'type',
'args': 'args'
})
smach.StateMachine.add('MOVE_AWAY',
Move(),
transitions={
'Success': 'Success',
'Failure': 'Failure'
},
remapping={
'type': 'type',
'args': 'args'
})
status = sm.execute()
else:
Logger.loginfo('object does not exist')
status = 'Failure'
return status
def list_possible_moves(self, pile: [Card]) -> [Move]:
occurrences = {}
move_id = 0
for card in self.cards:
if card.string_value in occurrences:
occurrences[card.string_value] += 1
else:
occurrences[card.string_value] = 1
possible_moves = []
if len(pile) > 1:
number_of_cards_to_draw = 3
if len(pile) - 1 < number_of_cards_to_draw:
number_of_cards_to_draw = len(pile) - 1
draw_move = Move(
action_type=ActionType.DRAW,
number_of_actionable_cards=number_of_cards_to_draw,
move_id=move_id)
move_id += 1
possible_moves.append(draw_move)
for k, v in occurrences.items():
if not self.can_throw_card_on_pile(
card_value=inverted_card_values[k], pile=pile):
continue
if v >= 1:
# throw one card
move = Move(action_type=ActionType.THROW,
number_of_actionable_cards=1,
card_value=k,
move_id=move_id)
move_id += 1
possible_moves.append(move)
if v >= 3:
# throw three cards
move = Move(action_type=ActionType.THROW,
number_of_actionable_cards=3,
card_value=k,
move_id=move_id)
move_id += 1
possible_moves.append(move)
if v == 4:
move = Move(action_type=ActionType.THROW,
number_of_actionable_cards=4,
card_value=k,
move_id=move_id)
move_id += 1
possible_moves.append(move)
for move in possible_moves:
move.print()
return possible_moves
def __init__(self):
self.all_moves = self.read_combos()
self.begin = Move("Begin Round")
self.rest = Move("Rest")
self.complete = Move("Complete")
self.create_file(self.begin.get_file_name(),self.begin.get_moves())
self.create_file(self.rest.get_file_name(),self.rest.get_moves())
self.create_file(self.complete.get_file_name(),self.complete.get_moves())
# Create all the files you need
for combo in self.all_moves:
self.create_file(combo.get_file_name(), combo.get_moves())
def test_next_move(monkeypatch, test_humanplayer):
board = Board()
dice = Dice()
dice.set_dice(2, 1)
monkeypatch.setattr('builtins.input', lambda x: '13 11')
assert test_humanplayer.next_move(board, dice) == Move(0, 13, 11)
monkeypatch.setattr('builtins.input', lambda x: '24 23')
assert test_humanplayer.next_move(board, dice) == Move(0, 24, 23)
monkeypatch.setattr('builtins.input', lambda x: '6 5')
assert test_humanplayer.next_move(board, dice) == Move(0, 6, 5)
def reset(self):
self.move = Move()
time.sleep(self.secs)
self.buildGrid()
self.move = Move()
self.snake = Snake(self.width, self.height, self.border)
self.food = Food(self.width, self.height, self.snake)
self.score = 0
self.reseting = True
def bestMoveTest():
state = getGameState()
move1 = Move(None,None,None)
node1 = SearchNode(move1,state,None)
node1.evaluation = 10
move2 = Move(None,None,None)
node2 = SearchNode(move2,state,None)
node2.evaluation = 5
actualMove = bestMove([node1, node2])
if actualMove is not move2:
print("Best Move Test error")
def movesInDirectionFromPos(self, pos, direction, side) :
for dis in range(1, 8) :
movement = C(dis * direction[X], dis * direction[Y])
newPos = pos + movement
if self.board.isValidPos(newPos) :
pieceAtNewPos = self.board.pieceAtPosition(newPos)
if pieceAtNewPos is None :
yield Move(self, newPos)
elif pieceAtNewPos is not None :
if pieceAtNewPos.side != side :
yield Move(self, newPos, pieceToCapture = pieceAtNewPos)
return
def get_piece_moves(self, sq, attacks, color):
moves = []
while attacks:
end_sq = Bitboard.lsb(attacks)
end_sq_color = self.get_square_color(end_sq)
if end_sq_color == Color.NONE:
moves.append(Move(sq, end_sq, Flags.Quiet))
elif end_sq_color != color:
moves.append(Move(sq, end_sq, Flags.Capture))
attacks = Bitboard.pop_lsb(attacks)
return moves
def getQueenMove(self, state):
myInv = getCurrPlayerInventory(state)
me = state.whoseTurn
queen = myInv.getQueen()
enemy = 1 - me
attackers = getAntList(state, enemy, [SOLDIER, R_SOLDIER, DRONE])
# if there are no attackers move to a default location
if len(attackers) == 0:
return Move(
MOVE_ANT,
createPathToward(state, queen.coords, (4, 1),
UNIT_STATS[QUEEN][MOVEMENT]), None)
#keep queen from going onto food
foods = getConstrList(state, None, (FOOD, ))
for food in foods:
if queen.coords == food.coords:
path = createPathToward(state, queen.coords, (7, 3),
UNIT_STATS[QUEEN][MOVEMENT])
return Move(MOVE_ANT, path, None)
# if health is lower than 6, run away and let defense do it's job
queenHealth = queen.health
queenCoords = queen.coords
dist = 99
closest = None
# find the most worrying attacker
for ant in attackers:
tmp = (ant.coords[1] - 3) / UNIT_STATS[ant.type][MOVEMENT]
if tmp < dist:
dist = tmp
closest = ant
if closest.coords[1] <= 4:
path = createPathToward(
state, queen.coords,
(closest.coords[0], min(3, closest.coords[1])),
UNIT_STATS[QUEEN][MOVEMENT])
elif closest.type == R_SOLDIER:
path = createPathToward(state, queen.coords,
(closest.coords[0], 0),
UNIT_STATS[QUEEN][MOVEMENT])
else:
path = createPathToward(state, queen.coords,
(closest.coords[0], 2),
UNIT_STATS[QUEEN][MOVEMENT])
return Move(MOVE_ANT, path, None)
def moveInDirection(self, direction, walls, teleports):
move = Move.initWithDirection(Enums.Direction(direction))
if self.canMove(move, pygame.Rect((self.x, self.y), (18,18)), walls):
teleport = self.recognizeTeleport(move, pygame.Rect((self.x, self.y), (18,18)), teleports)
if teleport != None:
if teleport.left == 0:
self.makeMove(Move(500, 0))
else:
self.makeMove(Move(-500, 0))
else:
self.makeMove(move)
else:
self.makeRandomMove(move, walls, teleports)
return
def moveQueen(self, currentState, myInv, me):
# if the queen is on the anthill move her off
myQueen = myInv.getQueen()
if myQueen.coords == myInv.getAnthill().coords and not myQueen.hasMoved \
or (myQueen.coords != (3,1) and not myQueen.hasMoved):
return Move(
MOVE_ANT,
createPathToward(currentState,
myInv.getQueen().coords, (3, 1),
UNIT_STATS[QUEEN][MOVEMENT]), None)
# move queen in place to attack
if (not myQueen.hasMoved):
return Move(MOVE_ANT, [myQueen.coords], None)
def updateNextAnt(self):
for ant in self.antList:
currentAnt = getAntAt(self.state, ant)
if currentAnt is not None:
if not currentAnt.hasMoved:
if currentAnt.carrying:
path = createPathToward(self.state, ant, self.deposit, UNIT_STATS[WORKER][MOVEMENT])
self.antList.append(path[len(path) - 1])
return Move(MOVE_ANT, path, None)
else:
path = createPathToward(self.state, ant, self.food, UNIT_STATS[WORKER][MOVEMENT])
self.antList.append(path[len(path) - 1])
return Move(MOVE_ANT, path, None)
return None
def getMove(self, currentState):
#Useful pointers
myInv = getCurrPlayerInventory(currentState)
me = currentState.whoseTurn
#the first time this method is called, the food and tunnel locations
#need to be recorded in their respective instance variables
if (self.myTunnel == None):
self.myTunnel = getConstrList(currentState, me, (TUNNEL, ))[0]
if (self.myFood == None):
foods = getConstrList(currentState, None, (FOOD, ))
self.myFood = foods[0]
#find the food closest to the tunnel
bestDistSoFar = 1000 #i.e., infinity
for food in foods:
dist = stepsToReach(currentState, self.myTunnel.coords,
food.coords)
if (dist < bestDistSoFar):
self.myFood = food
bestDistSoFar = dist
#if the hasn't moved, have her move in place so she will attack
myQueen = myInv.getQueen()
if (not myQueen.hasMoved):
return Move(MOVE_ANT, [myQueen.coords], None)
#if I don't have a worker, give up. QQ
numAnts = len(myInv.ants)
if (numAnts == 1):
return Move(END, None, None)
#if the worker has already moved, we're done
myWorker = getAntList(currentState, me, (WORKER, ))[0]
if (myWorker.hasMoved):
return Move(END, None, None)
#if the worker has food, move toward tunnel
if (myWorker.carrying):
path = createPathToward(currentState, myWorker.coords,
self.myTunnel.coords,
UNIT_STATS[WORKER][MOVEMENT])
return Move(MOVE_ANT, path, None)
#if the worker has no food, move toward food
else:
path = createPathToward(currentState, myWorker.coords,
self.myFood.coords,
UNIT_STATS[WORKER][MOVEMENT])
return Move(MOVE_ANT, path, None)
def test_mark_used_die(test_dice):
test_dice.set_dice(1, 2)
move = Move(0, 24, 22)
test_dice.mark_used_die(move)
assert test_dice.die2 == 0
test_dice.set_dice(4, 2)
move = Move(0, 24, 20)
test_dice.mark_used_die(move)
assert test_dice.die1 == 0
test_dice.set_dice(2, 3)
move = Move(0, 26, 23)
test_dice.mark_used_die(move)
assert test_dice.die1 == 0
def test_is_valid_move(test_rulebook):
move1 = Move(0, 6, 4)
move2 = Move(0, 13, 14)
move3 = Move(0, 12, 13)
test_rulebook.dice.set_dice(1, 2)
test_rulebook.move = move1
assert test_rulebook.is_valid_move(move1)
test_rulebook.move = move2
assert not test_rulebook.is_valid_move(move2)
test_rulebook.move = move3
assert not test_rulebook.is_valid_move(move3)
def readMoveFile(board):
with open(move_file) as fp:
line = fp.readline()
if line:
move = Move()
move.parseMove(line)
board.Click(move.x, move.y)
def __init__(self, engine, name, timeout=10):
"""
name: string
timeout: int (default 10)
name is the name of the player (individual/team)
timeout is the time limit for a move, in seconds
"""
self.timeout = timeout
self.name = name
game = engine
# start watching
self.observer = Observer()
self.observer.schedule(self.TurnFileHandler(name), '.', recursive=True)
self.observer.start()
try:
while True:
if myTurn == True:
readMoveFile(game.getBoard())
coords = ai.play(game.getBoard(), t=9.0)
move = Move(name, coords[0], coords[1])
game.getBoard().Click(coords[0], coords[1])
writeMoveFile(name, move)
time.sleep(1)
else:
print('Waiting turn...')
except Exception as err:
self.observer.stop()
print('Error: {0}'.format(err))
self.observer.join()
