def __init__(self, dataset: Dataset, n_fes: int, np: int,
save_to_dir: str):
"""
Args:
dataset: Dataset of simulation.
n_fes Total number of evaluations.
np: Population size.
save_to_dir: Path to directory where simulation results will be stored.
"""
random.seed(n_fes + np + datetime.now().second)
self.logger = Logger(self.__class__.__name__)
self.n_fes = n_fes
self.logger.console_log('n_fes value set to {0}'.format(n_fes))
self.np = np
self.logger.console_log('np value set to {0}'.format(np))
self._dataset: Dataset = dataset
self.logger.console_log('dataset {0}'.format(dataset.title))
self._algorithms: list = []
self._save_options: list = []
self._save_option_kwargs = {
'dir_path': save_to_dir,
'dataset': dataset
}
def test_logger_file_handler_disabled(tc_unittest):
temp_file = tc_unittest.get_temp_file()
logger = Logger("UnitTest",
temp_file,
logging.DEBUG,
use_console_handler=True,
use_file_handler=False)
logger.info("TestMessage")
assert temp_file.exists() is False
def __init__(self, height, width, rooms_count):
self._log = Logger()
self._log.debug("Maze", "Object Init")
self._initMap(height, width)
self._markWalls()
self._initRooms(rooms_count)
self._initNodes()
self._initEdges()
self._connectRooms()
self._teams = []
def __init__(self, nodes, edges):
self._log = Logger()
self._nodes = nodes
self._edges = edges
self._last_analyzed = None
self._solved = False
self._start = None
self._target = None
self._pq = None
self.resetAlgorithm()
self._log.debug(
"Astar", "Init Object -- {} Nodes -- {} Edges".format(
len(nodes), len(edges)))
def getBoxes(amount):
# TODO: validate that the amount is a positive integer
Logger().debug("getBoxes", "Init -- {} boxes".format(amount))
result = []
while (amount > 0):
result.append(Box())
amount -= 1
return result
def test_logger_error_level(tc_unittest):
temp_file = tc_unittest.get_temp_file()
logger = Logger("UnitTest", temp_file, logging.ERROR)
logger.info("InfoMessage")
logger.debug("DebugMessage")
logger.error("ErrorMessage")
assert " - UnitTest - INFO - InfoMessage" not in temp_file.read_text()
assert " - UnitTest - ERROR - ErrorMessage" in temp_file.read_text()
assert " - UnitTest - DEBUG - DebugMessage" not in temp_file.read_text()
def getHealthPackages(units, restore_per_unit):
msg = "Init -- {} health packages -- {} health restore per package"
msg = msg.format(units, restore_per_unit)
Logger().debug("getHealthPackages", msg)
result = []
while (units > 0):
result.append(HealthPackage(restore_per_unit))
units -= 1
return result
def __init__(self, view):
self.__view = view
self.__file_view = FileReader()
self.__database_view = DatabaseView()
self.__graph_view = Graph()
self.__query_creator = QueryCreator()
self.__logger = Logger()
with open('src\config.json') as json_data_file:
data = json.load(json_data_file)
self.__serial_file = data['pickle']['file']
self.__database_name = data['mysql']['db']
def __init__(self, max_health, team_id):
self._astar = None
self._at = None
self._bullets = []
self._came_from = None
self._edges = None
self._grenades = []
self._health = max_health
self._id = Soldier.count
Soldier.count += 1
self._log = Logger()
self._max_health = max_health
self._nodes = None
self._rooms = None
self._state = SoldierState.DISCOVERING
self._stuck = 0
self._team_id = team_id
self._visual_state = None
self._log.debug("Soldier #{}".format(str(self._id)),
"Object Initialization")
def placeTeams(maze, teams):
msg = "Distributing {} teams among the rooms".format(len(teams))
Logger().debug("placeTeams", msg)
for team in teams:
for soldier in team.soldiers:
nodes = maze.uniqueNodesSharedCells()
edges = maze.edges
soldier.initAstar(nodes, edges)
soldier.rooms = maze.rooms
maze.placeTeam(team)
def create_logger(self, logger_name, use_console_handler=None, use_file_handler=None):
if not use_console_handler:
use_console_handler = self.__use_console_handler
if not use_file_handler:
use_file_handler = self.__use_file_handler
return Logger(
logger_name=logger_name,
report_file=self.__report_file,
loglevel=self.__log_level,
use_console_handler=use_console_handler,
use_file_handler=use_file_handler,
)
def getGrenadePackages(packages, per_package, damage_per_grenade):
msg = "Init -- {} greanade packages -- {} grenades per package -- {} damage per grenade"
msg = msg.format(packages, per_package, damage_per_grenade)
Logger().debug("getGrenadePackages", msg)
result = []
while (packages > 0):
next_package = GrenadePackage()
count = per_package
while count > 0:
next_package.addUnit(Grenade(damage_per_grenade))
count -= 1
result.append(next_package)
packages -= 1
return result
def getBulletPackages(packages, per_package, damage_per_bullet):
msg = "Init -- {} bullet packages -- {} bullets per package -- {} damage per bullet"
msg = msg.format(packages, per_package, damage_per_bullet)
Logger().debug("getBulletPackages", msg)
result = []
while (packages > 0):
next_package = BulletPackage()
count = per_package
while count > 0:
next_package.addUnit(Bullet(damage_per_bullet))
count -= 1
result.append(next_package)
packages -= 1
return result
def getTeams(amount, soldier_health):
teams_count = 1
if amount > 1:
teams_count = amount / 2
Logger().debug("getTeams", "Init {} teams for {} soldiers".format(teams_count, amount))
result = []
while amount > 0:
next_team = Team()
result.append(next_team)
next_team.addSoldier(getOffensiveSoldier(soldier_health, next_team.id))
amount -= 1
if amount == 0:
break
next_team.addSoldier(getDefensiveSoldier(soldier_health, next_team.id))
amount -= 1
return result
class Soldier:
count = 1
max_stuck = 3
"""
- astar is Astar
- at is Cell
- bullets is List<Bullet>
- came_from is Cell
- edges is List<Edge>
- grenades is List<Grenade>
- health is Integer
- id is Integer
- max_health is Integer
- nodes is List<Node>
- rooms is List<Room>
- state is SoldierState
- stuck is Integer
- team_id is Integer
- visual_state is SoldierVisualState
"""
def __init__(self, max_health, team_id):
self._astar = None
self._at = None
self._bullets = []
self._came_from = None
self._edges = None
self._grenades = []
self._health = max_health
self._id = Soldier.count
Soldier.count += 1
self._log = Logger()
self._max_health = max_health
self._nodes = None
self._rooms = None
self._state = SoldierState.DISCOVERING
self._stuck = 0
self._team_id = team_id
self._visual_state = None
self._log.debug("Soldier #{}".format(str(self._id)),
"Object Initialization")
@property
def at(self):
return self._at
@property
def id(self):
return self._id
@property
def health(self):
return self._health
@property
def team_id(self):
return self._team_id
@property
def rooms(self):
return self._rooms
@at.setter
def at(self, val):
self._at = val
@rooms.setter
def rooms(self, val):
self._rooms = val
def blownWithGrenade(self, grenade):
self._log.debug(
"Soldier #{}".format(str(self._id)),
"Blown with a Grenade with damage {}".format(str(grenade.damage)))
updated_health = self._health - grenade.damage
if updated_health < 0:
self._health = 0
else:
self._health = updated_health
self._visual_state = SoldierVisualState.BLOWN_WITH_GRENADE
def initAstar(self, nodes, edges):
self._nodes = nodes
self._edges = edges
self._astar = Astar(self._nodes, self._edges)
def nextMove(self):
self._stuck = 0
self._log.debug("Soldier #{}".format(str(self._id)), "Next Move")
if self._lookNearbyAndThrowGrenade():
return
if self._lookAtCellsAndShoot():
return
while True and self._stuck < Soldier.max_stuck:
if self._astar.target == None:
self._noExistingTargetFlow()
if self._astar.noOptionsLeft():
self._noOptionsLeftFlow()
self._stuck += 1
self._astar.nextIterationNeighbourPriority()
last_analyzed = self._astar.last_analyzed
if last_analyzed.cell.isEmpty():
if self.mapTo(last_analyzed):
break
else:
if self._haveSpottedSoldier(last_analyzed):
self._spottedSoldierFlow(last_analyzed)
break
elif self._haveSpottedHealthPackage(last_analyzed):
if self._isLookingForHealth():
self._spottedHealthPackageFlow(last_analyzed)
break
elif self._haveSpottedBulletPackage(last_analyzed):
if self._isLookingForBullets():
self._spottedBulletPackageFlow(last_analyzed)
break
elif self._haveSpottedGrenadePackage(last_analyzed):
if self._isLookingForGrenades():
self._spottedGrenadePackageFlow(last_analyzed)
break
if self._astar.solved:
self._astar.resetAlgorithm()
self._resetState()
def mapTo(self, to):
at = self._nodeBy(self._at)
if at.isNeighbour(to) or to.isNeighbour(at):
if to.cell.isTraversable():
self._log.debug(
"Soldier #{}".format(str(self._id)),
"Moving from {} to {}".format(str(at.cell.point),
str(to.cell.point)))
self._at.removeObj()
to.cell.obj = self
self._at = to.cell
return True
return False
def removeFromGame(self):
self._at.removeObj()
def resetAstar(self):
self._astar.resetSolved()
self._astar.resetStates()
self._astar.resetManhattan()
self._astar.resetPriorityQueue()
self._astar.resetParents()
self._astar.resetTarget()
def resetVisualState(self):
self._visual_state = None
def shareTargetWith(self, other):
target = self.target()
self.resetAstar()
other.resetAstar()
self.updateAstarStart()
other.updateAstarStart()
self.updateAstarTarget(target.cell)
other.updateAstarTarget(target.cell)
self._log.debug(
"Soldier #{}".format(str(self._id)),
"Shared Target {} with Soldier #{}".format(str(target.cell.point),
str(other.id)))
def shotWith(self, bullet):
self._log.debug(
"Soldier #{}".format(str(self._id)),
"Shot with Bullet with damage {}".format(str(bullet.damage)))
updated_health = self._health - bullet.damage
if updated_health < 0:
self._health = 0
else:
self._health = updated_health
self._visual_state = SoldierVisualState.SHOT_AT
def showVisualState(self):
return not self._visual_state == None
def start(self):
return self._astar.start
def target(self):
return self._astar.target
def updateAstarStart(self):
self._astar.updateNodeToStateStartBy(self._at)
def updateAstarTarget(self, cell):
self._astar.updateNodeToStateTargetBy(cell)
def _areNoBullets(self):
return len(self._bullets) == 0
def _areNoGrenades(self):
return len(self._grenades) == 0
def _bulletPackage(self):
room = self._currentRoom()
if room == None:
return None
for cell in room.floor:
if cell.containsBulletPackage():
return cell
return None
def _enemySoldierAt(self):
for room in self._rooms:
for cell in room.floor:
if cell.containsSoldier():
if not self._teamMates(cell.obj):
return cell
return None
def _friendlySoldierAt(self):
for room in self._rooms:
for cell in room.floor:
if cell.containsSoldier():
if self._teamMates(cell.obj):
return cell
return None
def _grenadePackage(self):
room = self._currentRoom()
if room == None:
return None
for cell in room.floor:
if cell.containsGrenadePackage():
return cell
return None
def _lookAtCellsAndShoot(self):
self._log.debug(
"Soldier #{}".format(str(self._id)),
"Looking for a Possible Enemy to Shoot At in the Room")
if self._areNoBullets():
self._log.debug("Soldier #{}".format(str(self._id)),
"No Bullets left")
return False
room = self._currentRoom()
if room == None:
self._log.debug("Soldier #{}".format(str(self._id)),
"Not in a Room")
return False
return self._shootIfPossible(room, self._at.point.x, self._at.point.y)
def _lookNearbyAndThrowGrenade(self):
self._log.debug("Soldier #{}".format(str(self._id)),
"Looking for a Possible Enemy to throw a Grenade at")
if self._areNoGrenades():
self._log.debug("Soldier #{}".format(str(self._id)),
"No Grenades left")
return False
room = self._currentRoom()
if room == None:
self._log.debug("Soldier #{}".format(str(self._id)),
"Not in a Room")
return False
return self._throwGrenadeIfPossible(room, self._at.point.x,
self._at.point.y)
def _currentRoom(self):
result = None
for room in self._rooms:
if room.partOfRoom(self._at):
result = room
break
return result
def _isLookingForBullets(self):
return self._state == SoldierState.LOOKING_FOR_BULLETS
def _isLookingForGrenades(self):
return self._state == SoldierState.LOOKING_FOR_GRENADES
def _isLookingForHealth(self):
return self._state == SoldierState.LOOKING_FOR_HEALTH
def _isNoAmmunition(self):
return self._areNoBullets() and self._areNoGrenades()
def _nodeBy(self, cell):
for node in self._nodes:
if node.cell.samePosition(cell):
return node
def _noExistingTargetFlow(self):
self._log.debug("Soldier #{}".format(self._id), "No Existing Target")
self._pickTarget()
def _noOptionsLeftFlow(self):
self._log.debug(
"Soldier #{}".format(self._id),
"Reaching Target {} is not possible".format(
str(self.target().cell.point)))
self._astar.resetAlgorithm()
self._state = SoldierState.DISCOVERING
target = self._randomCellAtRoom()
self._came_from = self._at
self._astar.updateNodeToStateStartBy(self._at)
self._astar.updateNodeToStateTargetBy(target)
self._log.debug("Soldier #{}".format(self._id),
"The picked target is {}".format(str(target.point)))
def _haveSpottedBulletPackage(self, node):
at = self._nodeBy(self._at)
if at.isNeighbour(node) or node.isNeighbour(at):
return node.cell.containsBulletPackage()
return False
def _haveSpottedGrenadePackage(self, node):
at = self._nodeBy(self._at)
if at.isNeighbour(node) or node.isNeighbour(at):
return node.cell.containsGrenadePackage()
return False
def _haveSpottedHealthPackage(self, node):
at = self._nodeBy(self._at)
if at.isNeighbour(node) or node.isNeighbour(at):
return node.cell.containsHealthPackage()
return False
def _haveSpottedSoldier(self, node):
at = self._nodeBy(self._at)
if at.isNeighbour(node) or node.isNeighbour(at):
if not self._at.point == node.cell.point:
return node.cell.containsSoldier()
return False
def _healthPackage(self):
for room in self._rooms:
for cell in room.floor:
if cell.containsHealthPackage():
return cell
return None
def _pickTarget(self):
target = None
self._decideOnState()
if self._state == SoldierState.LOOKING_FOR_HEALTH:
self._log.debug("Soldier #{}".format(str(self._id)),
"Looking for a Health Package")
target = self._healthPackage()
if target == None:
self._state = SoldierState.DISCOVERING
if self._state == SoldierState.LOOKING_FOR_BULLETS:
self._log.debug("Soldier #{}".format(str(self._id)),
"Looking for a Bullets Package")
target = self._bulletPackage()
if target == None:
self._state = SoldierState.DISCOVERING
if self._state == SoldierState.LOOKING_FOR_GRENADES:
self._log.debug("Soldier #{}".format(str(self._id)),
"Looking for a Grenades Package")
target = self._grenadePackage()
if target == None:
self._state = SoldierState.DISCOVERING
if self._state == SoldierState.DISCOVERING:
self._log.debug("Soldier #{}".format(str(self._id)),
"Looking for the next Room to Discover")
target = self._randomRoomCenter()
self._came_from = self._at
self._astar.updateNodeToStateStartBy(self._at)
self._astar.updateNodeToStateTargetBy(target)
self._log.debug("Soldier #{}".format(self._id),
"The picked target is {}".format(str(target.point)))
def _randomCellAtRoom(self):
result = None
seed()
room_index = randint(0, len(self._rooms) - 1)
room = self._rooms[room_index]
while result == None:
cell_index = randint(0, len(room.floor) - 1)
cell = room.floor[cell_index]
if cell.isTraversable():
result = cell
return result
def _randomRoomCenter(self):
result = None
seed()
while result == None:
room_index = randint(0, len(self._rooms) - 1)
room = self._rooms[room_index]
if self._came_from == None:
result = room.center
elif not room.partOfRoom(self._came_from):
result = room.center
return result
def _resetState(self):
self._state = SoldierState.DISCOVERING
def _reverseTarget(self):
self._log.debug("Soldier #{}".format(str(self._id)),
"Reversing the Target")
start = self.start()
self._astar.resetAlgorithm()
self._astar.updateNodeToStateStartBy(self._at)
self._astar.updateNodeToStateTargetBy(start.cell)
def _shootAt(self, other):
self._log.debug("Soldier #{}".format(str(self._id)),
"Shooting at Enemy #{}".format(str(other.id)))
bullet = self._bullets.pop()
other.shotWith(bullet)
def _shootIfPossible(self, room, x, y):
increment_x = x + 1
while True:
look_at = room.cellBy(increment_x, y)
if look_at == None:
break
if not look_at.isEmpty():
if look_at.containsSoldier():
other = look_at.obj
if not self._teamMates(other):
self._shootAt(other)
return True
break
increment_x += 1
increment_y = y + 1
while True:
look_at = room.cellBy(x, increment_y)
if look_at == None:
break
if not look_at.isEmpty():
if look_at.containsSoldier():
other = look_at.obj
if not self._teamMates(other):
self._shootAt(other)
return True
break
increment_y += 1
decrement_x = x - 1
while True:
look_at = room.cellBy(decrement_x, y)
if look_at == None:
break
if not look_at.isEmpty():
if look_at.containsSoldier():
other = look_at.obj
if not self._teamMates(other):
self._shootAt(other)
return True
break
decrement_x -= 1
decrement_y = y - 1
while True:
look_at = room.cellBy(x, decrement_y)
if look_at == None:
break
if not look_at.isEmpty():
if look_at.containsSoldier():
other = look_at.obj
if not self._teamMates(other):
self._shootAt(other)
return True
break
decrement_y += 1
return False
def _spottedEnemyFlow(self, other):
if other._at.isPath():
if self._isNoAmmunition() or self._isLowHealth():
self._reverseTarget()
else:
if not self._areNoGrenades():
self._throwGrenadeAt(other)
else:
self._shootAt(other)
def _spottedFriendFlow(self, other):
if other._at.isPath():
if not self.target():
other.shareTargetWith(self)
else:
self.shareTargetWith(other)
def _spottedBulletPackageFlow(self, node):
self._log.debug("Soldier #{}".format(str(self._id)),
"Spotted a Bullet Package")
for bullet in node.cell.obj.units:
self._bullets.append(bullet)
if self._areNoBullets():
self._log.info(
"Soldier #{}".format(str(self._id)),
"Bullets can not be empty after picking a Bullet Package")
exit(1)
node.cell.removeObj()
self._astar.resetAlgorithm()
self._resetState()
self._log.debug("Soldier #{}".format(str(self._id)),
"Used a Bullets Package")
def _spottedGrenadePackageFlow(self, node):
self._log.debug("Soldier #{}".format(str(self._id)),
"Spotted a Grenades Package")
for grenade in node.cell.obj.units:
self._grenades.append(grenade)
if self._areNoGrenades():
self._log.info(
"Soldier #{}".format(str(self._id)),
"Grenades can not be empty after picking a Grenade Package")
exit(1)
node.cell.removeObj()
self._astar.resetAlgorithm()
self._resetState()
self._log.debug("Soldier #{}".format(str(self._id)),
"Used a Grenades Package")
def _spottedHealthPackageFlow(self, node):
self._log.debug("Soldier #{}".format(str(self._id)),
"Spotted a Health Package")
restored_health = self._health + node.cell.obj.restore
if restored_health > self._max_health:
self._health = self._max_health
else:
self._health = restored_health
node.cell.removeObj()
self._resetState()
self._astar.resetAlgorithm()
self._log.debug("Soldier #{}".format(str(self._id)),
"Used a Health Package")
def _spottedSoldierFlow(self, node):
other = node.cell.obj
if self._teamMates(other):
self._log.debug("Soldier #{}".format(str(self._id)),
"Spotted a Friend #{}".format(str(other.id)))
self._spottedFriendFlow(other)
else:
self._log.debug("Soldier #{}".format(str(self._id)),
"Spotted an Enemy #{}".format(str(self._id)))
self._spottedEnemyFlow(other)
def _teamMates(self, other):
return self._team_id == other.team_id
def _throwGrenadeAt(self, other):
self._log.debug(
"Soldier #{}".format(str(self._id)),
"Throwing Grenade at the Enemy #{}".format(str(other.id)))
grenade = self._grenades.pop()
other.blownWithGrenade(grenade)
def _throwGrenadeIfPossible(self, room, x, y):
increment_x = x + 1
while increment_x < x + 3:
look_at = room.cellBy(increment_x, y)
if look_at == None:
break
if not look_at.isEmpty():
if look_at.containsSoldier():
other = look_at.obj
if not self._teamMates(other):
self._throwGrenadeAt(other)
return True
break
increment_x += 1
increment_y = y + 1
while increment_y < y + 3:
look_at = room.cellBy(x, increment_y)
if look_at == None:
break
if not look_at.isEmpty():
if look_at.containsSoldier():
other = look_at.obj
if not self._teamMates(other):
self._throwGrenadeAt(other)
return True
break
increment_y += 1
decrement_x = x - 1
while decrement_x < x - 3:
look_at = room.cellBy(decrement_x, y)
if look_at == None:
break
if not look_at.isEmpty():
if look_at.containsSoldier():
other = look_at.obj
if not self._teamMates(other):
self._throwGrenadeAt(other)
return True
break
decrement_x -= 1
decrement_y = y - 1
while decrement_y < y - 3:
look_at = room.cellBy(x, decrement_y)
if look_at == None:
break
if not look_at.isEmpty():
if look_at.containsSoldier():
other = look_at.obj
if not self._teamMates(other):
self._throwGrenadeAt(other)
return True
break
decrement_y += 1
return False
def __str__(self):
if self._visual_state == SoldierVisualState.SHOT_AT:
return "!"
if self._visual_state == SoldierVisualState.BLOWN_WITH_GRENADE:
return "?"
return str(self._id)
specific env runtime mapped by the environment variable: ENV_DEPLOYMENT_TYPE
where the ["Core"]["Envs"][ENV_DEPLOYMENT_TYPE] is defined in:
https://github.com/jay-johnson/datanode/blob/master/configs/jupyter.json
and also mapped to a specific env file on disk or in the container:
https://github.com/jay-johnson/datanode/blob/master/src/common/env_loader.py
"""
load_env_for_specific_runtime()
core = PyCore(core_config)
now = datetime.datetime.now()
ra_name = "CACHE"
ra_key = "NODB_PERFORM_THIS_WORK"
logger = None
if str(lg_enabled) == "1" or str(lg_enabled).lower() == "true":
logger = Logger(logger_name, "/dev/log", logging.DEBUG)
if debug:
lg("Loading Redis Apps", 6)
if str(rd_enabled) == "1" or str(rd_enabled).lower() == "true":
core.load_redis_apps()
core.m_log = logger
core.m_name = logger_name
if str(db_enabled) == "1" or str(db_enabled).lower() == "true":
if debug:
lg("Loading Database Apps", 6)
core.load_db_apps()
def __init__(self):
super().__init__()
Logger().info("GrenadePackage", "Object Initialization")
def __init__(self, restore):
super().__init__()
self._restore = restore
Logger().info("HealthPackage", "Object Initialization")
class Astar():
"""
- edges is List<Edge>
- last_analyzed is Boolean
- log is Logger
- nodes is List<Node>
- pq is PriorityNodes
- solved is Boolean
- start is Node
- target is Node
"""
def __init__(self, nodes, edges):
self._log = Logger()
self._nodes = nodes
self._edges = edges
self._last_analyzed = None
self._solved = False
self._start = None
self._target = None
self._pq = None
self.resetAlgorithm()
self._log.debug(
"Astar", "Init Object -- {} Nodes -- {} Edges".format(
len(nodes), len(edges)))
@property
def last_analyzed(self):
return self._last_analyzed
@property
def solved(self):
return self._solved
@property
def start(self):
return self._start
@property
def target(self):
return self._target
def nextIteration(self):
current = self._pq.pop()
self._last_analyzed = current
if current.state == NodeState.TARGET:
self._solved = True
return
if not current.state == NodeState.START:
current.state = NodeState.BLACK
for node in current.neighbours:
if node.state == NodeState.BLACK:
continue
edge = self._edgeBy(current, node)
if edge == None:
self._log.info("Astar",
"EXPECTED AN EDGE, BUT NONE WAS RETURNED")
exit(1)
left_to_target = self._target.cell.point.distance(node.cell.point)
manhattan_value = current.manhattan + left_to_target + edge.cost
if node.state == NodeState.WHITE or node.state == NodeState.TARGET:
node.manhattan = manhattan_value
node.parent = current
node.state = NodeState.GRAY
self._emplace(node.cell.point)
elif node.state == NodeState.GRAY or node.state == NodeState.TARGET:
if node.manhattan > manhattan_value:
node.manhattan = manhattan_value
node.parent = current
if self._target == node:
self._solved = True
return
def nextIterationNeighbourPriority(self):
current = self._pq.pop()
if not self._last_analyzed == None:
is_neighbour = current.isNeighbour(self._last_analyzed)
if not is_neighbour or not self._last_analyzed.isNeighbour(
current):
return
if current == None:
self._target = None
return
self._last_analyzed = current
if current.state == NodeState.TARGET:
self._solved = True
return
if not current.state == NodeState.START:
current.state = NodeState.BLACK
for node in current.neighbours:
if node.state == NodeState.BLACK:
continue
edge = self._edgeBy(current, node)
if edge == None:
self._log.info("Astar",
"EXPECTED AN EDGE, BUT NONE WAS RETURNED")
exit(1)
left_to_target = self._target.cell.point.distance(node.cell.point)
manhattan_value = current.manhattan + left_to_target + edge.cost
if node.state == NodeState.WHITE or node.state == NodeState.TARGET:
node.manhattan = manhattan_value
node.parent = current
node.state = NodeState.GRAY
self._emplace(node.cell.point)
elif node.state == NodeState.GRAY or node.state == NodeState.TARGET:
if node.manhattan > manhattan_value:
node.manhattan = manhattan_value
node.parent = current
if self._target == node:
self._solved = True
return
def noOptionsLeft(self):
if not self._target == None:
return self._pq.empty()
return False
def noSolution(self):
return self._pq.empty()
def resetLastAnalysed(self):
self._last_analyzed = None
def resetManhattan(self):
for node in self._nodes:
node.resetManhattan()
def resetParents(self):
for node in self._nodes:
node.resetParent()
def resetPriorityQueue(self):
self._pq = PriorityNodes()
def resetSolved(self):
self._solved = False
def resetStart(self):
self._start = None
def resetStates(self):
for node in self._nodes:
node.resetState()
def resetTarget(self):
self._target = None
def resetAlgorithm(self):
self.resetSolved()
self.resetStates()
self.resetManhattan()
self.resetPriorityQueue()
self.resetParents()
self.resetStart()
self.resetTarget()
self.resetLastAnalysed()
def updateNodeToStateStartBy(self, cell):
self._updateStateOf(cell.point, NodeState.START)
self._updateManhattanOf(cell.point, 0)
self._emplace(cell.point)
self._start = self._nodeByCoordinate(cell.point)
def updateNodeToStateTargetBy(self, cell):
self._updateStateOf(cell.point, NodeState.TARGET)
self._target = self._nodeByCoordinate(cell.point)
def _edgeBy(self, node, neighbour):
for edge in self._edges:
if edge.src.cell.point == node.cell.point and edge.dst.cell.point == neighbour.cell.point:
# self._log.debug("Astar", "Returning the edge {}".format(str(edge)))
return edge
if edge.dst.cell.point == node.cell.point and edge.src.cell.point == neighbour.cell.point:
# self._log.debug("Astar", "Returning the edge {}".format(str(edge)))
return edge
return None
def _emplace(self, coord):
node = self._nodeByCoordinate(coord)
self._pq.insert(node)
def _nodeByCoordinate(self, coord):
for node in self._nodes:
if node.cell.point == coord:
return node
return None
def _updateManhattanOf(self, coord, val):
current = self._nodeByCoordinate(coord)
current.manhattan = val
def _updateStateOf(self, coord, val):
node = self._nodeByCoordinate(coord)
node.state = val
def placePackages(maze, packages):
msg = "Distributing {} packages among the rooms".format(len(packages))
Logger().debug("placePackages", msg)
for package in packages:
maze.placePackage(package)
def placeBoxes(maze, boxes):
msg = "Distributing {} boxes among the rooms".format(len(boxes))
Logger().debug("placeBoxes", msg)
for box in boxes:
maze.placeBox(box)
class Simulation:
"""
This class is responsible to run genetic algorithms simulation. It's limited to n_fes and np parameters.
"""
def __init__(self, dataset: Dataset, n_fes: int, np: int,
save_to_dir: str):
"""
Args:
dataset: Dataset of simulation.
n_fes Total number of evaluations.
np: Population size.
save_to_dir: Path to directory where simulation results will be stored.
"""
random.seed(n_fes + np + datetime.now().second)
self.logger = Logger(self.__class__.__name__)
self.n_fes = n_fes
self.logger.console_log('n_fes value set to {0}'.format(n_fes))
self.np = np
self.logger.console_log('np value set to {0}'.format(np))
self._dataset: Dataset = dataset
self.logger.console_log('dataset {0}'.format(dataset.title))
self._algorithms: list = []
self._save_options: list = []
self._save_option_kwargs = {
'dir_path': save_to_dir,
'dataset': dataset
}
def add_algorithm(self, name: str) -> None:
"""Adds new genetic algorithm to simulation.
Args:
name: A string representing algorithm name.
"""
if name is None or len(name) < 1:
raise InvalidAlgorithmName(
'Invalid algorithm name "{0}"'.format(name))
try:
alg_type = globals()[str(name)]
alg_obj = alg_type(seed=random.randint(1, 9999),
task=Task(
D=self._dataset.total_packages,
nFES=self.n_fes,
benchmark=BenchmarkC(dataset=self._dataset),
optType=OptimizationType.MINIMIZATION),
NP=self.np)
self._algorithms.append(alg_obj)
self.logger.console_log('added algorithm {0}'.format(name))
except Exception:
raise InvalidAlgorithmName(
'Invalid algorithm name "{0}"'.format(name))
def algorithms(self) -> list:
"""Returns all algorithm names in simulation.
"""
return [type(i).__name__ for i in self._algorithms]
def add_save_option(self, config: OutputOptionConfig):
""" Adds new simulation result save option.
Args:
config: SaveOptionConfig object.
Returns: Void
"""
if config.class_name is None or len(config.class_name) < 1:
raise InvalidSaveOptionName(
'Invalid save option name "{0}"'.format(config.class_name))
try:
save_option_type = globals()[str(config.class_name)]
kwargs_dict = {}
for kwargs_name in config.included_kwargs:
param = self._save_option_kwargs[kwargs_name]
if param is not None:
kwargs_dict[kwargs_name] = param
save_option = save_option_type(**kwargs_dict)
self._save_options.append(save_option)
self.logger.console_log('{0} save option added'.format(
config.class_name))
except Exception:
raise InvalidSaveOptionName(
'Invalid save option name "{0} or kwargs {1}"'.format(
config.class_name, config.included_kwargs))
def run(self, sort_by_best: SortAttribute) -> None:
"""Starts simulation.
Args:
sort_by_best: Results are ordered by this attribute, from best to worst.
Returns: void
"""
self.logger.console_log('Validating state')
self._validate_initial_state()
self.logger.console_log("Starting optimization tasks")
self.logger.console_log("Waiting tasks")
pool = Pool()
opt_res = pool.map(Runner.run, self._algorithms)
pool.close()
pool.join()
self.logger.console_log("Tasks finished")
sorted_res = sorted(
opt_res,
key=lambda item: item.result.best_fitness
if sort_by_best == SortAttribute.fitness else item.execution_time)
if any(res_info.has_error for res_info in sorted_res):
self.logger.console_log('Not all simulation tasks were successful')
else:
self.logger.console_log('All simulation tasks were successful')
self.logger.console_log("Starting save options")
for option in self._save_options:
option.save(sorted_res)
self.logger.console_log("Done, stopping execution")
def _validate_initial_state(self):
if len(self._algorithms) < 1:
raise InvalidSimulationInitialState(
'Cannot start simulation with empty list of algorithms')
if len(self._save_options) < 1:
raise InvalidSimulationInitialState(
'Cannot start simulation with empty list of save options')
if self.n_fes < 1:
raise InvalidSimulationInitialState(
'Cannot start simulation with n_fes prop value less than 1')
if self.np < 1:
raise InvalidSimulationInitialState(
'Cannot start simulation with np prop value less than 1')
if self._dataset is None or len(self._dataset.packages) != self._dataset.total_packages \
or self._dataset.total_packages == 0 or len(self._dataset.title) < 1:
raise InvalidSimulationInitialState(
'Cannot start simulation with invalid dataset')
stat_count = self._dataset.total_stations
for package in self._dataset.packages:
if package.station_in < 1 or package.station_out > stat_count \
or not package.station_in < package.station_out:
raise InvalidSimulationInitialState(
'Cannot start simulation with invalid dataset')
dir_path = self._save_option_kwargs['dir_path']
if dir_path is None or len(dir_path) < 1 or not os.path.isdir(
dir_path):
raise InvalidSimulationInitialState(
'Cannot start simulation with invalid results dir path')
def setLogger():
level = LoggerLevel.INFO
if len(argv) > 1:
if argv[1] == "debug" or argv[1] == "Debug" or argv[1] == "DEBUG":
level = LoggerLevel.DEBUG
Logger(level)
def drawMaze(maze):
Logger().debug("drawMaze", "Started to draw the Maze")
# TODO: graphical implementation
Logger().debug("drawMaze", "Finished to draw the Maze")
class Maze:
"""
- edges is List<Edge>
- log is Logger
- map is List<List<Cell>>
- nodes is List<List<Nodes>>
- rooms is List<Room>
"""
def __init__(self, height, width, rooms_count):
self._log = Logger()
self._log.debug("Maze", "Object Init")
self._initMap(height, width)
self._markWalls()
self._initRooms(rooms_count)
self._initNodes()
self._initEdges()
self._connectRooms()
self._teams = []
@property
def edges(self):
return self._edges
@property
def rooms(self):
return self._rooms
@property
def teams(self):
return self._teams
def height(self):
return len(self._map)
def placeBox(self, box):
# TODO
# validate the box exists
# place randomly box in one of the rooms
pass
def placePackage(self, package):
room = self._randomRoom()
free_cell = self._randomFreeFloorCell(room)
free_cell.obj = package
def placeTeam(self, team):
room = self._roomWithoutSoldiers()
if room == None:
self._log.info("Maze", "NO ROOM FOR TEAM PLACEMENT")
exit(1)
for soldier in team.soldiers:
self._mapSoldierToCell(soldier, room)
self._teams.append(team)
def uniqueNodesSharedCells(self):
result = []
for row in self._map:
for cell in row:
if cell.isPassable():
result.append(Node(cell))
for node in result:
for other in result:
if node.cell.point.distance(other.cell.point) == 1:
node.addNeighbour(other)
return result
def updateTeamsState(self):
to_remove = []
for team in self._teams:
if team.isEmpty():
to_remove.append(team)
for team in to_remove:
self._teams.remove(team)
def width(self):
return len(self._map[0])
def _cellBy(self, point):
for row in self._map:
for cell in row:
if cell.point == point:
return cell
return None
def _connectRooms(self):
self._log.debug("Maze", "Connect {} Rooms".format(len(self.rooms)))
nodes = []
connected = dict()
for room in self._rooms:
connected[room] = []
for row in self._nodes:
for node in row:
nodes.append(node)
astar = Astar(nodes, self._edges)
for room in self._rooms:
for other in self._rooms:
if not room == other and not other in connected[room]:
self._log.debug(
"Maze",
"Connecting room center {} to room center {}".format(
str(room.center.point), str(other.center.point)))
astar.resetAlgorithm()
astar.updateNodeToStateStartBy(room.center)
astar.updateNodeToStateTargetBy(other.center)
while not astar.solved:
if astar.noSolution():
self._log.info(
"Maze", "NO PATH WAS FOUND BETWEEN THE ROOMS")
exit(1)
astar.nextIteration()
target = astar.target
if target == None or target.parent == None:
self._log.info(
"Maze", "EXPECTED A PATH, BUT NONE WAS RETURNED")
exit(1)
self._markPathAndEntrances(target)
connected[room].append(other)
connected[other].append(room)
def _initEdges(self):
self._edges = []
i = 1
while i < len(self._nodes):
j = 1
while j < len(self._nodes[i]):
node = self._nodes[i][j]
if i - 1 >= 0:
self._registerNeighbours(node, self._nodes[i - 1][j])
if j - 1 >= 0:
self._registerNeighbours(node, self._nodes[i][j - 1])
if j + 1 < len(self._nodes[i]):
self._registerNeighbours(node, self._nodes[i][j + 1])
if i + 1 < len(self._nodes):
self._registerNeighbours(node, self._nodes[i + 1][j])
j += 1
i += 1
self._log.info("Maze",
"Init -- {} Edges".format(str(len(self._edges))))
def _initMap(self, height, width):
self._log.info("Maze",
"Init Map -- {} x {} Cells".format(height, width))
result = []
i = 0
while i < height:
row = []
j = 0
while j < width:
row.append(Cell(CellType.SPACE, i, j))
j += 1
result.append(row)
i += 1
self._map = result
def _initNodes(self):
result = []
for row in self._map:
row_of_nodes = []
for cell in row:
row_of_nodes.append(Node(cell))
result.append(row_of_nodes)
self._nodes = result
self._log.info(
"Maze", "Init -- {} x {} Nodes".format(str(self.height()),
str(self.width())))
def _initRoom(self):
max_size = self.height() - 1
height = self._roomHeight(max_size)
width = self._roomWidth(max_size)
result = Room(height, width,
self._roomCenter(height, max_size, width, max_size))
return result
def _initRooms(self, count):
self._log.info("Maze", "Init {} Rooms".format(count))
seed()
result = []
while count > 0:
candidate = self._initRoom()
if self._roomSizeIllegal(candidate):
continue
rooms_overlap = False
i = 0
while i < len(result) and not rooms_overlap:
rooms_overlap = self._roomsOverlap(result[i], candidate)
if rooms_overlap:
break
i += 1
if rooms_overlap:
continue
else:
self._markFloor(candidate)
result.append(candidate)
count -= 1
self._rooms = result
def _mapSoldierToCell(self, soldier, room):
self._log.debug("Maze", "Map Soldier to Cell")
for cell in room.floor:
if cell.isTraversable():
soldier.at = cell
cell.obj = soldier
return
def _markFloor(self, room):
i = int(room.center.point.x - room.width / 2)
while i < int(room.center.point.x + room.width / 2):
j = int(room.center.point.y - room.height / 2)
while j < int(room.center.point.y + room.height / 2):
cell = self._map[i][j]
cell.kind = CellType.FLOOR
room.appendCell(cell)
j += 1
i += 1
def _markPathAndEntrances(self, target):
last_cell = None
while not target.parent == None:
cell = self._cellBy(target.cell.point)
if cell == None:
self._log.info(
"Maze", "EXPECTED A CELL OBJECT FOR PATH MARK, GOT NONE")
exit(1)
if cell.kind == CellType.SPACE:
cell.kind = CellType.PATH
if not last_cell == None:
if last_cell.kind == CellType.FLOOR and cell.kind == CellType.PATH:
last_cell.kind = CellType.ENTRANCE
elif cell.kind == CellType.FLOOR and last_cell.kind == CellType.PATH:
cell.kind = CellType.ENTRANCE
last_cell = cell
target = target.parent
def _markWalls(self):
self._log.debug("Maze", "Mark Walls")
for row in self._map:
next_cell = row[0]
next_cell.kind = CellType.WALL
next_cell = row[self.width() - 1]
next_cell.kind = CellType.WALL
for c in self._map[0]:
c.kind = CellType.WALL
for c in self._map[self.height() - 1]:
c.kind = CellType.WALL
def _randomFreeFloorCell(self, room):
seed()
while True:
cell_index = randint(0, len(room.floor) - 1)
cell = room.floor[cell_index]
if cell.isFloor() and cell.isEmpty():
neighbour = room.cellBy(cell.point.x + 1, cell.point.y)
if not neighbour == None and not cell.isEmpty():
continue
neighbour = room.cellBy(cell.point.x + 1, cell.point.y + 1)
if not neighbour == None and not cell.isEmpty():
continue
neighbour = room.cellBy(cell.point.x + 1, cell.point.y - 1)
if not neighbour == None and not cell.isEmpty():
continue
neighbour = room.cellBy(cell.point.x, cell.point.y + 1)
if not neighbour == None and not cell.isEmpty():
continue
neighbour = room.cellBy(cell.point.x, cell.point.y - 1)
if not neighbour == None and not cell.isEmpty():
continue
neighbour = room.cellBy(cell.point.x - 1, cell.point.y)
if not neighbour == None and not cell.isEmpty():
continue
neighbour = room.cellBy(cell.point.x - 1, cell.point.y - 1)
if not neighbour == None and not cell.isEmpty():
continue
neighbour = room.cellBy(cell.point.x - 1, cell.point.y + 1)
if not neighbour == None and not cell.isEmpty():
continue
return cell
def _randomRoom(self):
seed()
room_index = randint(0, len(self._rooms) - 1)
return self._rooms[room_index]
def _registerNeighbours(self, node, other):
node.addNeighbour(other)
self._edges.append(
Edge(node, other, node.cell.point.distance(other.cell.point)))
def _roomCenter(self, height, max_height, width, max_width):
y = int(1 + (height / 2) + randint(0, max_height) %
(max_height - height - 2))
x = int(1 + (width / 2) + randint(0, max_width) %
(max_width - width - 2))
result = self._map[x][y]
return result
def _roomHeight(self, size):
result = 7 + randint(0, size) % (size / 5)
return int(result)
def _roomWidth(self, size):
return self._roomHeight(size)
def _roomsOverlap(self, room, other):
result = False
vertical_dist = abs(room.center.point.x - other.center.point.x)
horizontal_dist = abs(room.center.point.y - other.center.point.y)
h_overlap = room.height / 2 + other.height / 2 > horizontal_dist - 4
v_overlap = room.width / 2 + other.width / 2 > vertical_dist - 4
result = h_overlap and v_overlap
return result
def _roomSizeIllegal(self, room):
cx = room.center.point.x
cy = room.center.point.y
height = room.height
width = room.width
if (cx + width / 2 > self.width() - 3) or (cx - width / 2 < 2):
return True
if (cy + height / 2 > self.height() - 3) or (cy - height / 2 < 2):
return True
return False
def _roomWithoutSoldiers(self):
for room in self._rooms:
hasSoldiers = False
for cell in room.floor:
if cell.kind == CellType.FLOOR and isinstance(
cell.obj, Soldier):
hasSoldiers = True
break
if not hasSoldiers:
return room
return None
def __str__(self):
result = ""
rows = self.height() - 1
while rows >= 0:
cells = self.width() - 1
while cells >= 0:
result += str(self._map[rows][cells]) + "|"
cells -= 1
result = result + "\n"
rows -= 1
return result
