def test_breed(self): client = SimulationClient('sqlite:///:memory:') grid = SimulationGrid(persistence=client, simulation_parameters=sim_config_empty) a_list = [(Animal.Fish, SquareGridCoordinate(x=1, y=1)), (Animal.Fish, SquareGridCoordinate(x=2, y=1)), (Animal.Fish, SquareGridCoordinate(x=3, y=1)), (Animal.Fish, SquareGridCoordinate(x=1, y=3)), (Animal.Fish, SquareGridCoordinate(x=3, y=2)), (Animal.Shark, SquareGridCoordinate(x=2, y=2))] # adding some food and a shark for t, c in a_list: client.init_animal(sim_id=grid._sid, current_turn=0, animal_type=t, coordinate=c) # updating grid turn grid._sim_turn = 4 shark_update = grid._eat() assert len(shark_update) == 1, 'Shark should have fed' breed_moved = grid._breed_and_move(fed_sharks=shark_update) assert len( breed_moved ) == 5, '4 fishes and one shark should have moved due to breeding' assert len(breed_moved) == (len(a_list) - 1) grid_df = grid.get_simulation_grid_data() assert len(grid_df[grid_df['animal_type'] == Animal.Shark]) == 2, 'Should be 2 Sharks' assert len(grid_df[grid_df['animal_type'] == Animal.Fish]) == 8, 'Should be 8 fishes'
def test_topology_agnostic_eating(self): ''' Check the topology-agnostic behavior, i.e. that the shark from one corner will eat the fish from the opposite corner ''' # set fish breeding probability to 0 sim_config_empty_local = copy.deepcopy(sim_config_empty) sim_config_empty_local['fish_breed_probability'] = 0 client = SimulationClient('sqlite:///:memory:') grid = SimulationGrid(persistence=client, simulation_parameters=sim_config_empty_local) a_list = [(Animal.Fish, SquareGridCoordinate(x=0, y=0)), (Animal.Shark, SquareGridCoordinate(x=9, y=9))] # adding some food and a shark for t, c in a_list: client.init_animal(sim_id=grid._sid, current_turn=0, animal_type=t, coordinate=c) # updating grid turn grid._sim_turn = 6 # AM: the latest two rows to allow optimized 'occupied coordinates' check grid.animals = grid.get_simulation_grid_data() grid.occupied_coord = set( zip(grid.animals.coord_x, grid.animals.coord_y)) shark_update = grid._eat() # shark has eaten shark = grid._persistence.get_animals_by_type( sim_id=grid._sid, animal_type=Animal.Shark).iloc[0] # the shark is in update list assert len( shark_update) == 1, 'There should be one shark in update list' assert shark.last_fed == 6, 'Shark last fed value should have updated' assert shark_update[shark.oid] == SquareGridCoordinate( x=9, y=9), 'Shark previous coordinate in shark update' # Fish is dead animal_in_square = client.get_animal_in_position( sim_id=grid._sid, coordinate=SquareGridCoordinate(int(shark.coord_x), int(shark.coord_y)), live_only=False) assert len( animal_in_square) == 2, 'there shoud be two animals in that square' # check that there is no fish fish = grid._persistence.get_animals_by_type(sim_id=grid._sid, animal_type=Animal.Fish) assert len( fish ) == 0, 'there should be no fish alive' # there is no fish (since we put 0 breeding probability)
def test_simulation_init(self): client = SimulationClient('sqlite:///:memory:') grid = SimulationGrid(persistence=client, simulation_parameters=sim_config) # Should have spawned the fishes and sharks nb_fish = sim_config['init_nb_fish'] nb_sharks = sim_config['init_nb_shark'] grid_table = grid._persistence.get_animals_df(grid._sid) assert len(grid_table) == (nb_fish + nb_sharks), 'Missing some animals!'
def test_starving(self): client = SimulationClient('sqlite:///:memory:') grid = SimulationGrid(persistence=client, simulation_parameters=sim_config) turn_to_starve = sim_config['shark_starving'] # set turn to more... grid._sim_turn = turn_to_starve + 1 grid._check_deads() assert len( grid._persistence.get_animals_by_type(grid._sid, Animal.Shark)) == 0
def test_eating(self): client = SimulationClient('sqlite:///:memory:') grid = SimulationGrid(persistence=client, simulation_parameters=sim_config_empty) a_list = [(Animal.Fish, SquareGridCoordinate(x=1, y=1)), (Animal.Fish, SquareGridCoordinate(x=2, y=1)), (Animal.Fish, SquareGridCoordinate(x=3, y=1)), (Animal.Fish, SquareGridCoordinate(x=1, y=3)), (Animal.Fish, SquareGridCoordinate(x=3, y=2)), (Animal.Shark, SquareGridCoordinate(x=2, y=2))] # adding some food and a shark for t, c in a_list: client.init_animal(sim_id=grid._sid, current_turn=0, animal_type=t, coordinate=c) # updating grid turn grid._sim_turn = 4 # AM: the next two rows are to allow optimized 'occupied coordinates' check grid.animals = grid.get_simulation_grid_data() grid.occupied_coord = set( zip(grid.animals.coord_x, grid.animals.coord_y)) shark_update = grid._eat() # shark has eaten shark = grid._persistence.get_animals_by_type( sim_id=grid._sid, animal_type=Animal.Shark).iloc[0] # the shark is in update list assert len( shark_update) == 1, 'There should be one shark in update list' assert shark.last_fed == 4, 'Shark last fed value should have updated' assert shark_update[shark.oid] == SquareGridCoordinate( x=2, y=2), 'Shark previous coordinate in shark update' # Fish is dead animal_in_square = client.get_animal_in_position( sim_id=grid._sid, coordinate=SquareGridCoordinate(int(shark.coord_x), int(shark.coord_y)), live_only=False) assert len( animal_in_square) == 2, 'there shoud be two animals in that square'
def test_check_if_occupied(self): ''' Test the modified function ''' client = SimulationClient('sqlite:///:memory:') grid = SimulationGrid(persistence=client, simulation_parameters=sim_config_empty) a_list = [(Animal.Fish, SquareGridCoordinate(x=1, y=1)), (Animal.Shark, SquareGridCoordinate(x=2, y=2))] # adding some food and a shark for t, c in a_list: client.init_animal(sim_id=grid._sid, current_turn=0, animal_type=t, coordinate=c) grid.animals = grid.get_simulation_grid_data() grid.occupied_coord = set( zip(grid.animals.coord_x, grid.animals.coord_y)) assert grid.check_if_occupied(SquareGridCoordinate( x=1, y=1)) == True, 'should be occupied' assert grid.check_if_occupied(SquareGridCoordinate( x=2, y=2)) == True, 'should be occupied' assert grid.check_if_occupied(SquareGridCoordinate( x=1, y=2)) == False, 'should be spare' # repeat the same for 1x1 case with initialization of 1 Fish del client, grid, a_list sim_config_empty_local = copy.deepcopy(sim_config_empty) sim_config_empty_local['init_nb_fish'] = 1 sim_config_empty_local['grid_size'] = 1 client = SimulationClient('sqlite:///:memory:') grid = SimulationGrid(persistence=client, simulation_parameters=sim_config_empty_local) assert grid.check_if_occupied(SquareGridCoordinate( x=0, y=0)) == True, 'should be occupied'
def test_empty(self): ''' Tests that an empty grid throws an exception of no sharks ''' client = SimulationClient('sqlite:///:memory:') grid = SimulationGrid(persistence=client, simulation_parameters=sim_config_empty) with pytest.raises(EndOfSimulatioError): grid._check_deads() with pytest.raises(EndOfSimulatioError): grid.play_turn()
def test_starving(self): client = SimulationClient('sqlite:///:memory:') grid = SimulationGrid(persistence=client, simulation_parameters=sim_config) turn_to_starve = sim_config['shark_starving'] # set turn to more... grid._sim_turn = turn_to_starve + 1 grid._check_deads() assert len( grid._persistence.get_animals_by_type(grid._sid, Animal.Shark)) == 0 # amend this test by adding further checks # after the first turn we should have killed the sharks with pytest.raises(EndOfSimulatioError): grid.check_simulation_ends() with pytest.raises(EndOfSimulatioError): grid._check_deads() with pytest.raises(EndOfSimulatioError): grid.play_turn()
def test_fish_only(self): ''' Test if non-empty, but fish only: the simulation should end Make two cases: (1) add manually the fish to empty grid (2) use the config with updated value for corresponding key ''' # No. 1 client = SimulationClient('sqlite:///:memory:') grid = SimulationGrid(persistence=client, simulation_parameters=sim_config_empty) a_list = [ (Animal.Fish, SquareGridCoordinate(x=1, y=1)), ] for t, c in a_list: client.init_animal(sim_id=grid._sid, current_turn=0, animal_type=t, coordinate=c) with pytest.raises(EndOfSimulatioError): grid._check_deads() with pytest.raises(EndOfSimulatioError): grid.play_turn() # repeat the same for No. 2 del client, grid, a_list sim_config_empty_local = copy.deepcopy(sim_config_empty) sim_config_empty_local['init_nb_fish'] = 1 client = SimulationClient('sqlite:///:memory:') grid = SimulationGrid(persistence=client, simulation_parameters=sim_config_empty_local) with pytest.raises(EndOfSimulatioError): grid._check_deads() with pytest.raises(EndOfSimulatioError): grid.play_turn()
def test_position_functions(self): client = SimulationClient('sqlite:///:memory:') # init DB sid = client.init_simulation(**sim_config) # add a bunch of animals for t, c in animal_list: client.init_animal(sim_id=sid, current_turn=0, animal_type=t, coordinate=c) # check animal in square coord = SquareGridCoordinate(x=1, y=3) animals_in_square = client.get_animal_in_position(sim_id=sid, coordinate=coord) assert len(animals_in_square) == 1 # kill that animal client.kill_animal(sim_id=sid, animal_ids=[animals_in_square[0].oid]) animals_in_square = client.get_animal_in_position(sim_id=sid, coordinate=coord) assert len(animals_in_square) == 0 # adding a live one in coord client.init_animal(sim_id=sid, current_turn=0, animal_type=Animal.Fish, coordinate=coord) animals_in_square = client.get_animal_in_position(sim_id=sid, coordinate=coord, live_only=False) assert len(animals_in_square) == 2
help='Maximum number of turns for the simulation') cmd_parser.add_argument('--config_path', default=None, type=str, help=""" Configuration file path. If specified, configuration file will be loaded from this path """) args = cmd_parser.parse_args() if args.config_path is not None: raise NotImplementedError( 'Code for directing to an alternative configuration' ' repository has not been implemented yet') # Load simulation configuration sim_config = read_simulation_config(args.config_name) # Instantiate client client = SimulationClient(get_database_string()) # display initial grid grid = SimulationGrid(persistence=client, simulation_parameters=sim_config) print( display_simple_grid(client.get_animals_df(grid._sid), grid_size=sim_config['grid_size'])) for turn in range(args.max_turn): start_time = current_milli_time() grid.play_turn() print(''.join(['*'] * sim_config['grid_size'] * 2)) print('Turn: {turn: ^{size}}'.format(turn=grid._sim_turn, size=sim_config['grid_size'])) print() print( display_simple_grid(grid.get_simulation_grid_data(), sim_config['grid_size']))
def test_database_init(self): client = SimulationClient('sqlite:///:memory:') # init DB sid = client.init_simulation(**sim_config) assert len( client.get_all_simulations()) == 1, 'Should be only one simulation' assert isinstance(client.get_simulation(sid), Simulation) # check exception raised in init when adding animal on non-existent sim with pytest.raises(ValueError): client.init_animal(sim_id=10, current_turn=0, animal_type=Animal.Fish, coordinate=SquareGridCoordinate(x=0, y=1)) # init some animals client.init_animal(sim_id=sid, current_turn=0, animal_type=Animal.Fish, coordinate=SquareGridCoordinate(x=0, y=1)) assert client.coordinate_is_occupied(sim_id=sid, coordinate=SquareGridCoordinate( x=0, y=1)) # check exception for adding animal to an already occupied square with pytest.raises(NonEmptyCoordinate): client.init_animal(sim_id=sid, current_turn=0, animal_type=Animal.Fish, coordinate=SquareGridCoordinate(x=0, y=1)) # but should be fine in a new simulation sid_2 = client.init_simulation(**sim_config) client.init_animal(sim_id=sid_2, current_turn=0, animal_type=Animal.Fish, coordinate=SquareGridCoordinate(x=0, y=1)) # spawn outside the grid with pytest.raises(TopologyError): client.init_animal(sim_id=sid_2, current_turn=0, animal_type=Animal.Fish, coordinate=SquareGridCoordinate(x=10, y=1))
import logging from fish_bowl.dataio.persistence import SimulationClient, get_database_string from fish_bowl.common.config_reader import read_simulation_config, save_simulation_config _logger = logging.getLogger(__name__) if __name__ == '__main__': logging.basicConfig( level=logging.INFO, format="%(asctime)s [%(levelname)s] %(filename)s:%(lineno)d:%(message)s" ) client = SimulationClient(get_database_string()) for config in ['simulation_config_1', 'simulation_config_2']: sim_config = read_simulation_config(config) client.init_simulation(**sim_config)
from fish_bowl.dataio.persistence import SimulationClient, get_database_string from fish_bowl.process.topology import SquareGridCoordinate from fish_bowl.process.simple_display import display_simple_grid client = SimulationClient(get_database_string()) print(display_simple_grid(client.get_animals_df(sim_id=1), 10)) coord_1 = SquareGridCoordinate(6, 8) coord_2 = SquareGridCoordinate(7, 9) print( client.get_animal_in_position(sim_id=1, coordinate=coord_1, live_only=False)) print( client.get_animal_in_position(sim_id=1, coordinate=coord_2, live_only=False))
def test_moving_animals(self): client = SimulationClient('sqlite:///:memory:') # init DB sid = client.init_simulation(**sim_config) # add a bunch of animals for v in animal_list: client.init_animal(sim_id=sid, current_turn=0, animal_type=v[0], coordinate=v[1]) # test move assert not client.coordinate_is_occupied( sim_id=sid, coordinate=SquareGridCoordinate(5, 3)) client.move_animal(sim_id=sid, animal_id=4, new_position=SquareGridCoordinate(5, 3)) assert client.coordinate_is_occupied(sim_id=sid, coordinate=SquareGridCoordinate( 5, 3)) # trying to move dead animal client.kill_animal(sim_id=sid, animal_ids=[3]) with pytest.raises(ImpossibleAction): client.move_animal(sim_id=sid, animal_id=3, new_position=SquareGridCoordinate(3, 3)) # trying to move to an already occupied square with pytest.raises(NonEmptyCoordinate): client.move_animal(sim_id=sid, animal_id=5, new_position=SquareGridCoordinate(5, 3)) # but moving to a square occupied by a dead animal is possible assert not client.coordinate_is_occupied( sim_id=sid, coordinate=SquareGridCoordinate(3, 2)) client.move_animal(sim_id=sid, animal_id=1, new_position=SquareGridCoordinate(3, 2)) assert client.coordinate_is_occupied(sim_id=sid, coordinate=SquareGridCoordinate( 3, 2))
def test_animal_function(self): client = SimulationClient('sqlite:///:memory:') # init DB sid = client.init_simulation(**sim_config) # add a bunch of animals a_list = [(Animal.Fish, SquareGridCoordinate(x=1, y=1)), (Animal.Fish, SquareGridCoordinate(x=2, y=1)), (Animal.Fish, SquareGridCoordinate(x=3, y=1)), (Animal.Fish, SquareGridCoordinate(x=1, y=3)), (Animal.Fish, SquareGridCoordinate(x=3, y=2))] for t, c in a_list: client.init_animal(sim_id=sid, current_turn=0, animal_type=t, coordinate=c) coord_list = client.has_fish_in_square( sim_id=sid, coordinates=[SquareGridCoordinate(1, 1)]) assert len(coord_list) == 1, 'There should be a single fish' coord_list = client.has_fish_in_square( sim_id=sid, coordinates=[SquareGridCoordinate(1, 2)]) assert len(coord_list) == 0, 'There should be no fish here' neigh = square_grid_neighbours(grid_size=10, coordinate=SquareGridCoordinate(2, 2)) coord_list = client.has_fish_in_square(sim_id=sid, coordinates=neigh) assert len(coord_list) == 5, 'There should be 5 fishes here' # eating animals eaten = client.eat_animal_in_square(sim_id=sid, coordinate=SquareGridCoordinate( 1, 1)) assert eaten, 'Fish in 1, 1 should have been eaten' # can't eat dead Fish eaten = client.eat_animal_in_square(sim_id=sid, coordinate=SquareGridCoordinate( 1, 1)) assert not eaten, 'Should not be able to eat a dead Fish' client.init_animal(sim_id=sid, current_turn=0, animal_type=Animal.Shark, coordinate=SquareGridCoordinate(5, 5)) eaten = client.eat_animal_in_square(sim_id=sid, coordinate=SquareGridCoordinate( 5, 5)) assert not eaten, 'Should not be able to eat a Shark'
default=None, type=str, help=""" Configuration file path. If specified, configuration file will be loaded from this path """) args = cmd_parser.parse_args() if args.config_path is not None: raise NotImplementedError( 'Code for directing to an alternative configuration' ' repository has not been implemented yet') # Load simulation configuration sim_config = read_simulation_config(args.config_name) # Instantiate client # client = SimulationClient(get_database_string()) client = SimulationClient( 'sqlite:///:memory:' ) # use RAM, grids so far do not seem to be large; for extremely large need to change architecture as well # display initial grid grid = SimulationGrid(persistence=client, simulation_parameters=sim_config) print( display_simple_grid(client.get_animals_df(grid._sid), grid_size=sim_config['grid_size'])) for turn in range(args.max_turn): timer = time.time() # get occupied coord-s for quicker occupation-checks grid.animals = grid.get_simulation_grid_data() grid.occupied_coord = set( zip(grid.animals.coord_x, grid.animals.coord_y)) grid.play_turn() print(''.join(['*'] * sim_config['grid_size'] * 2)) print('Turn: {turn: ^{size}}'.format(turn=grid._sim_turn,
def test_animal_functions(self): client = SimulationClient('sqlite:///:memory:') # init DB sid = client.init_simulation(**sim_config) # add a bunch of animals for t, c in animal_list: client.init_animal(sim_id=sid, current_turn=0, animal_type=t, coordinate=c) # retrieve animals animals_df = client.get_animals_df(sim_id=1) assert isinstance(animals_df, pd.DataFrame), 'results is a DataFrame' assert len(animals_df) == 8, 'should be only 9 animals' # update animals # create update dict update_dict = { oid: { 'breed_count': 1, 'last_breed': 5, 'last_fed': 4 } for oid in animals_df.oid.values } client.update_animals(sim_id=sid, update_dict=update_dict) animals_df = client.get_animals_df(sim_id=1) assert animals_df.breed_count.unique( )[0] == 1, 'Breed count should be one now' client.update_animals(sim_id=sid, update_dict={1: {'alive': False}}) # this update should not work animal = client.get_animal(sim_id=sid, animal_id=1) assert animal.alive, 'Animal should still be alive' # but this should work client.kill_animal(sim_id=sid, animal_ids=[1, 2, 3]) animal = client.get_animal(sim_id=sid, animal_id=1) assert not animal.alive, 'This time alive was updates' # a dead animal does not occupy a square assert not client.coordinate_is_occupied( sim_id=sid, coordinate=SquareGridCoordinate(1, 3)) # test get animal by types shark_df = client.get_animals_by_type(sim_id=sid, animal_type=Animal.Shark) assert shark_df.animal_type.unique()[0] == Animal.Shark
sim_config_empty = { 'grid_size': 10, 'init_nb_fish': 0, 'fish_breed_maturity': 3, 'fish_breed_probability': 80, 'fish_speed': 2, 'init_nb_shark': 0, 'shark_breed_maturity': 5, 'shark_breed_probability': 100, 'shark_speed': 4, 'shark_starving': 4} if __name__ == '__main__': logging.basicConfig(level=logging.INFO, format="%(asctime)s [%(levelname)s] %(filename)s:%(lineno)d:%(message)s") # save_simulation_config(sim_config, 'simulation_config_1', overwrite=True) # sim_config = read_simulation_config('simulation_config_2') client = SimulationClient(get_database_string()) # sid = client.init_simulation(**sim_config) grid = SimulationGrid(persistence=client, simulation_parameters=sim_config) # for t, c in a_list: # client.init_animal(sim_id=grid._sid, current_turn=0, animal_type=t, coordinate=c) print(display_simple_grid(client.get_animals_df(grid._sid), grid_size=sim_config['grid_size'])) for turn in range(100): _logger.info('Turn: {}'.format(grid._sim_turn)) grid.play_turn() print(display_simple_grid(grid.get_simulation_grid_data(), grid.get_simulation_parameters().grid_size)) # _ = input('press key')