def parseLatLong(self, topLeft, bottomRight):
minLat = min(topLeft.lat, bottomRight.lat)
maxLat = max(topLeft.lat, bottomRight.lat)
minLon = min(topLeft.lon, bottomRight.lon)
maxLon = max(topLeft.lon, bottomRight.lon)
return Location(minLat, minLon), Location(maxLat, maxLon)
def test_partial_value(self, lat, lon, expected):
with pytest.raises(Exception):
loc = Location("Test", lon)
with pytest.raises(Exception):
loc = Location("Test", lat)
with pytest.raises(Exception):
loc = Location(lon, lat)
def get_neighbors(self, state):
neighbors = []
# Wait action
n = State(state.time + 1, state.location)
if self.state_valid(n):
neighbors.append(n)
# Up action
n = State(state.time + 1,
Location(state.location.x, state.location.y + 1))
if self.state_valid(n) and self.transition_valid(state, n):
neighbors.append(n)
# Down action
n = State(state.time + 1,
Location(state.location.x, state.location.y - 1))
if self.state_valid(n) and self.transition_valid(state, n):
neighbors.append(n)
# Left action
n = State(state.time + 1,
Location(state.location.x - 1, state.location.y))
if self.state_valid(n) and self.transition_valid(state, n):
neighbors.append(n)
# Right action
n = State(state.time + 1,
Location(state.location.x + 1, state.location.y))
if self.state_valid(n) and self.transition_valid(state, n):
neighbors.append(n)
return neighbors
def test_getLongitude(self): # Test the parsing of latitude from -100 to 100 W; from 10 to 10 E; etc. l1 = Location([10, -100]) l2 = Location([10, 30]) l1_longitude = l1.get_longitude() l2_longitude = l2.get_longitude() self.assertAlmostEqual(l1_longitude, "100 W") self.assertAlmostEqual(l2_longitude, "30 E")
def test_getLatitude(self): # Test the parsing of latitude from -50 to 50 S; from 30 to 30 N; etc. l1 = Location([50, 0]) l2 = Location([-30, 0]) l1_latitude = l1.get_latitude() l2_latitude = l2.get_latitude() self.assertAlmostEqual(l1_latitude, "50 N") self.assertAlmostEqual(l2_latitude, "30 S")
def initRobotFromCfg(runtimeID):
done = False
index = 1
robots = []
thisRobot = None
srcDict = CFGReader.ReadConfig("swarm.cfg", "src")
dstDict = CFGReader.ReadConfig("swarm.cfg", "dst")
if not srcDict:
sys.exit("No [src] found in swarm.cfg")
if not dstDict:
sys.exit("No [dst] found in swarm.cfg")
srcFID = srcDict["fid"]
srcLoc = Location(float(srcDict["x"]), float(srcDict["y"]),
float(srcDict["z"]))
srcNode = Robot("-1", srcLoc, srcFID, None, 6666, 6666, isSrc=True)
robots.append(srcNode)
dstFID = dstDict["fid"]
dstLoc = Location(float(dstDict["x"]), float(dstDict["y"]),
float(dstDict["z"]))
dstNode = Robot("-2", dstLoc, dstFID, None, 6666, 6666, isDest=True)
robots.append(dstNode)
while done == False:
section = "R" + str(index)
robotDict = CFGReader.ReadConfig("swarm.cfg", section)
if not robotDict:
done = True
break
rID = robotDict['rid']
fID = robotDict['fid']
x = float(robotDict['x'])
y = float(robotDict['y'])
z = float(robotDict['z'])
loc = Location(x, y, z)
newRobot = Robot(rID, loc, fID, None, 6666, 6666)
robots.append(newRobot)
if rID == runtimeID:
thisRobot = newRobot
index += 1
if (thisRobot == None):
sys.exit("No [R%s] found in swarm.cfg" % runtimeID)
thisRobot.all_robots["-1"] = srcLoc
thisRobot.all_robots["-2"] = dstLoc
currFlow = Flow.Flow(thisRobot.fid, robots, srcNode, dstNode)
thisRobot.setFlowAndGraph(currFlow, robots)
thisRobot.establishConnections()
return robots
def __init__(self):
self.time = -1
self.type = -1
self.agent_1 = ''
self.agent_2 = ''
self.location_1 = Location()
self.location_2 = Location()
def test_distance_between_two_locations(self):
# Test distance when are two points at 0,0
location1 = Location([0, 0])
location2 = Location([0, 0])
self.assertAlmostEqual(get_distance_between_two_locations(location1, location2), 0)
# Test distance between two locations
location1 = Location([54, 30])
location2 = Location([50, -100])
self.assertAlmostEqual(get_distance_between_two_locations(location1, location2), 7546)
def __init__(self):
self._log = logging.getLogger(__class__.__name__) # noqa: F821
self._log.debug("Created board metrics class")
# Metrics
self.throne_occupied = True
# Lookup values
self._throne_loc = Location(3, 3)
self._corners = [Location(0, 0), Location(6, 0),
Location(0, 6), Location(6, 6)]
def make_agent_dict(self):
for agent in self.agents:
start_state = State(0,
Location(agent['start'][0], agent['start'][1]))
goal_state = State(0, Location(agent['goal'][0], agent['goal'][1]))
self.agent_dict.update(
{agent['name']: {
'start': start_state,
'goal': goal_state
}})
def initialize(self):
""" Initialize the game board, place pieces, and start the game """
for i in range(32):
self.__board.append(None)
for i in range(12):
self.addPiece(
GamePiece(PieceColor.Light, getPlayer[PlayerColor.Light],
self), Location(i))
self.addPiece(
GamePiece(PieceColor.Dark, getPlayer[PlayerColor.Dark], self),
Location(32 - i))
self.__currentTurn = PlayerColor.Light
def __init__(self, session, api_key, route_id):
route = Route(session, route_id)
self.__start_location = Location(session, route.get_start_location())
self.__end_location = Location(session, route.get_end_location())
maps_client = googlemaps.Client(key=api_key)
now = datetime.now()
self.__directions_result = maps_client.directions(
self.__start_location.get_full_address(),
self.__end_location.get_full_address(),
mode="driving",
departure_time=now)[0]
def initLogFileFromCfg(self):
done = False
index = 1
while done == False:
section = "R" + str(index)
robotDict = CFGReader.ReadConfig("swarm.cfg", section)
if not robotDict:
done = True
break
rID = robotDict['rid']
loc = Location(float(robotDict["x"]), float(robotDict["y"]),
float(robotDict["z"]))
self.nodes[rID] = self.xyzToLatLong(loc.getX(), loc.getY(),
loc.getZ())
index += 1
srcDict = CFGReader.ReadConfig("swarm.cfg", "src")
dstDict = CFGReader.ReadConfig("swarm.cfg", "dst")
if not srcDict:
sys.exit("No [src] found in swarm.cfg")
if not dstDict:
sys.exit("No [dst] found in swarm.cfg")
srcLoc = Location(float(srcDict["x"]), float(srcDict["y"]),
float(srcDict["z"]))
dstLoc = Location(float(dstDict["x"]), float(dstDict["y"]),
float(dstDict["z"]))
self.nodes[index] = self.xyzToLatLong(srcLoc.getX(), srcLoc.getY(),
srcLoc.getZ())
self.nodes[index + 1] = self.xyzToLatLong(dstLoc.getX(), dstLoc.getY(),
dstLoc.getZ())
for i in range(11):
self.currTimeInterval = i
for rID in sorted(self.nodes.iterkeys()):
nodeLoc = self.nodes[rID]
latLongLoc = self.xyzToLatLong(nodeLoc.getX(), nodeLoc.getY(),
nodeLoc.getZ())
logLine = str(i) + '.0 nem:' + str(
rID) + ' location gps ' + str(
latLongLoc.getX()) + ',' + str(
latLongLoc.getY()) + ',' + str(
latLongLoc.getZ()) + '\n'
self.logFile.write(logLine)
self.currTimeInterval += 1
def build(self):
objects = [TruckObject(Location(23.7, 90.4), 48)]
links = []
vertices = []
tempVertexData = []
objects.append(self.buildDhaka(self.startData))
for dataPoint in self.roadData:
if dataPoint.hasGap():
if dataPoint.gap == "BS":
startNodeData = dataPoint
if len(links) == 0:
road = StartSimioLink(startNodeData.road,
"Output@Dhaka",
startNodeData.lrp)
else:
road = SimioLink(startNodeData.road, objects[-1].lrp,
startNodeData.lrp)
links.append(road)
for vertexData in tempVertexData:
vertices.append(
SimioVertex(
road.linkName,
Location(vertexData.lat, vertexData.lon)))
tempVertexData = []
else:
(bridgeStart, bridgeEnd,
bridgeLink) = self.buildBridge(startNodeData, dataPoint)
objects.append(bridgeStart)
objects.append(bridgeEnd)
links.append(bridgeLink)
self.bridgeCount += 1
else:
tempVertexData.append(dataPoint)
sink = self.buildChittagong(self.endData)
lastLink = EndSimioLink(self.endData.road, objects[-1].lrp,
"Input@Chittagong")
objects.append(sink)
links.append(lastLink)
print('Added {} bridges with {} category E.'.format(
self.bridgeCount, self.categoryECount))
return (objects, links, vertices)
def __init__(self, data):
# name
self.instance_name = data['name']
# locations
self.locations = {
loc['id']: Location(loc)
for loc in data['locations']
}
# register exiting transitions to each location object
for t in data['transitions']:
tid = t['sid']
transition = Transition(t)
self.locations[tid].add_outgoing_transition(transition)
# current location setup
loc_id = data['initialLocation'] # initial location id
self.current_location = self.locations[loc_id]
# variable objects
self.I = {i['name']: float(i['initialValue']) for i in data['I']}
self.O = {o['name']: float(o['initialValue']) for o in data['O']}
self.X = {x['name']: float(x['initialValue']) for x in data['X_C']}
# Simulink has multiple options for initialization
# 1. reset on the first transition
for fx in data['initialization']:
if fx['LHS'] in self.X:
self.X[fx['LHS']] = fx['RHS']
elif fx['LHS'] in self.O:
self.O[fx['LHS']] = fx['RHS']
# 2. initial location entry actions
initLocID = data['initialLocation']
self.locations[initLocID].en(self.I, self.O,
self.X) # evaluate "en" of a location
self.update_O()
def copy_files_not_on_player(pc_folder: Location, player_playlist: Playlist):
"""
function copying songs from PC to Player Playlist
(in scope of currently investigated folder)
:param pc_folder: Location
:param player_playlist: Playlist
:return:
"""
player_curr_folder_song_list = []
# creating list of songs in Player twin of currently investigated PC Playlist folder
pc_folder_path = os.path.join(player_playlist.directory, pc_folder.path_relative_to_playlsit_location)
for _, _, player_file_names in os.walk(pc_folder_path):
for name in player_file_names:
player_curr_folder_song_list.append(name)
# copying music files to album folder on Player
for root, _, file_names in os.walk(pc_folder.full_path):
for name in file_names:
pc_file = os.path.join(root, name)
if name not in player_curr_folder_song_list:
player_folder = Location(full_path=os.path.join(player_playlist.directory,
pc_folder.path_relative_to_playlsit_location),
path_relative_to_playlist_location=player_playlist.directory)
copy_file(source_file=pc_file,
destination_folder=player_folder)
def initializeLocations(self):
locations = self.locationData
for location in locations:
item = locations[location]
locationObj = Location(location)
self.locations[location] = locationObj
if isinstance(item, dict):
itemName = item['item']
else:
itemName = item
# if itemName in self.items:
itemObj = self.items[itemName]
locationObj.addItem(item, itemObj)
# else:
# locationObj.addItem(item)
# itemObj = locationObj.item
# self.items[itemName] = itemObj
# if itemName in itemDictionary:
# itemObj.image = itemDictionary[itemName]
if location in self.wothData:
locationObj.isWOTH = True
for region in self.regions.values():
for search in region.search:
if search in location:
region.locations.append(locationObj)
locationObj.region = region
locationObj.isDungeon = region.isDungeon
break
def main():
rows, columns = eval(
input("Enter the number of rows and columns in the list: "))
location1 = Location()
a = location1.createMatrix(rows, columns)
location2 = location1.locateLargest(a)
print(location2.__str__())
def copy_folders_not_on_player(pc_folder: Location, pc_playlist: Playlist, player_playlist: Playlist):
"""
copying folders from PC to Player, before copying a folder function checks folder structure for non existent parents
e.g.
wnen copying album, fucntion checks if artist folder exist, and if not copies artist folder with all subfolders
:param pc_folder:
:param pc_playlist:
:param player_playlist:
:return:
"""
relative_parent = os.path.dirname(pc_folder.path_relative_to_playlsit_location)
# if parent of checked folder exists on player -> copying files into it
if os.path.isdir(os.path.join(player_playlist.directory, relative_parent)):
player_folder = Location(full_path=os.path.join(player_playlist.directory, pc_folder.path_relative_to_playlsit_location),
path_relative_to_playlist_location=player_playlist.directory)
copy_folder(source_folder=pc_folder,
destination_folder=player_folder)
# if parent of checked folder doesn't exists on player -> checking if it's parent exists
else:
check_tree_up_for_non_existent_folder(pc_playlist=pc_playlist,
player_playlist=player_playlist,
checked_folder=relative_parent)
def initialize_objects(self):
log.info("initialize_objects()")
args = {"GAME": self}
objects = json.load(open("GameObjects.json"))
for location in objects["locations"]:
z = objects["locations"][location].copy()
z.update(args)
self.locations[location] = Location(**z)
self.allObj[location] = self.locations[location]
for barrier in objects["barriers"]:
z = objects["barriers"][barrier].copy()
z.update(args)
self.barriers[barrier] = Barrier(**z)
self.allObj[barrier] = self.barriers[barrier]
for item in objects["items"]:
z = objects["items"][item].copy()
z.update(args)
self.items[item] = Item(**z)
self.allObj[item] = self.items[item]
z = objects["player"]["player"]
z.update(args)
self.player = Player(**z)
self.assemble_barriers()
self.assemble_inventories(self.items)
return True
def openFile(self):
self.newFile()
fileName = QtWidgets.QFileDialog.getOpenFileName(self, 'Open File', filter="Json files (*.json)")
if fileName.__len__() == 0:
return
f = open(fileName[0], "r")
file = f.read()
f.close()
itemArray = json.loads(file)
# load items
for item in itemArray[0]:
newItem = Item(item["name"])
newItem.basePrice = item["basePrice"]
newItem.groups = item["groups"]
self.items.append(newItem)
self.ui.itemEditView.addItem(newItem.name)
# load groups
for group in itemArray[1]:
self.groups.append(group)
self.ui.groupEditView.addItem(group)
# load locations
for location in itemArray[2]:
loc = Location(location["name"])
loc.loadModifiers(location["modifiers"], self.items, self.groups)
self.locations.append(loc)
self.ui.locationSelection.addItem(loc)
self.refreshEverything()
def getLocationForPlace(self, country, state, county, city, url, id):
location = Location(country, state, county, city, 0, 0, -1, False)
if self.locationToId.has_key(location):
return self.idToLocation[self.locationToId[location]]
location.setUrl(url)
location.setTwitterId(id)
return location
def get_folder_list(self):
"""
Creates lists of folders by tree search from root specified by directory
then sorts it and filters to leave only leaves from the tree,
just the lowest children folders with audio files.
:return:
"""
for root, dirs, files in os.walk(self.directory): # searching tree with root in 'directory'
for name in dirs: # creating list of folders and subfolders
self.locations_list.append(os.path.join(root, name))
self.locations_list.sort()
"""
when list of folders is sorted, parent directories
can be discovered and deleted by checking if next
position on the list contains the entirety of
current position. Then marking parent directory
for deletion
"""
for index in range(len(self.locations_list) - 1):
if self.locations_list[index + 1].startswith(self.locations_list[index]):
self.locations_list[index] = 'clear'
# erasing marked positions
self.locations_list = list((filter(lambda element: element != 'clear', self.locations_list)))
self.locations_list = list(Location(full_path=item,
path_relative_to_playlist_location=get_path_relative_to_directory(item, self.directory)) for item in self.locations_list)
def get_terminal_string(self, indicies=False):
# pragma: nocover
ret = ""
if indicies is True:
ret += " X "
for i in range(self.max_x):
ret += "{:<2}".format(i)
ret += "\n"
for y in range(self.max_y):
if indicies is True:
if y == 0:
ret += "Y "
else:
ret += " "
ret += "+-" * self.max_x + "+\n"
if indicies is True:
ret += "{:<2}".format(y)
for x in range(self.max_x):
currLoc = Location(x=x, y=y)
piece = self.pieces.get_piece_at(currLoc)
draw = " "
if currLoc in KING_TILES: # Really, a total hack
draw = chr(0x2318)
if piece:
draw = piece.get_terminal_string()
ret += "|" + draw
ret += "|\n"
if indicies is True:
ret += " "
ret += "+-" * self.max_x + "+\n"
return ret
def run(self):
""" Method which shows a menu and allows the user to do inputs for selecting what action he or she wants to do """
try:
user_input = input(
"Where do you wish to fight?"
) #The user decides where he or she wants to fight
location = Location(user_input)
while True:
print("Welcome to the Star Wars battle simulator!")
print("1. Add a duelist! ")
print("2. List all duelists! ")
print("3. Duel! ")
print("0. Exit")
menu_input = input("What do you wish to do?")
if menu_input == "1":
location.add_duelists()
elif menu_input == "2":
location.list_duelists()
elif menu_input == "3":
duelist1 = location.choose_jedi()
duelist2 = location.choose_sith()
Duel(duelist1, duelist2).duel()
elif menu_input == "0":
print("-" * 40)
print(" May the force be with you!")
print("-" * 40)
quit()
except KeyboardInterrupt: # removes the error text when the user uses keyboard shortcuts to exit the program
print("\n", "-" * 40)
print(" May the force be with you!")
print("-" * 40)
quit()
def CreateLocation(locationlist):
locationname = input("\nEnter Location Name:")
locationlatitude = float(input("\nEnter Location Latitude:"))
locationlongitude = float(input("\nEnter Location Longitude:"))
locationlist.append(
Location(locationname, locationlatitude, locationlongitude, 0))
def fetchLocation(self):
loc = Location(
Helper.ReadConfig("model/location.cfg", "Location")['x'],
Helper.ReadConfig("model/location.cfg", "Location")['y'],
Helper.ReadConfig("model/location.cfg", "Location")['z'])
#print ("Location x %d y %d z %d " %(loc.x, loc.y, loc.z))
self.setLocation(loc)
def create_delayed_rules(self):
for region_name, node, subrule_name in self.delayed_rules:
region = self.world.get_region(region_name)
event = Location(subrule_name,
type='Event',
parent=region,
internal=True)
event.world = self.world
self.current_spot = event
# This could, in theory, create further subrules.
access_rule = self.make_access_rule(self.visit(node))
if access_rule is self.rule_cache.get('NameConstant(False)'):
event.access_rule = None
event.never = True
logging.getLogger('').debug(
'Dropping unreachable delayed event: %s', event.name)
else:
if access_rule is self.rule_cache.get('NameConstant(True)'):
event.always = True
event.set_rule(access_rule)
region.locations.append(event)
MakeEventItem(subrule_name, event)
# Safeguard in case this is called multiple times per world
self.delayed_rules.clear()
def processSingleDataPoint(self, latitude, longitude):
location = Location(latitude, longitude)
try:
data = self._gmaps.reverse_geocode(
(location.latitude, location.longitude))
for addressItem in data[0]['address_components']:
if 'street_number' in addressItem['types']:
location.number = addressItem['long_name']
elif 'sublocality_level_1' in addressItem['types']:
location.district = addressItem['long_name']
elif 'administrative_area_level_2' in addressItem['types']:
location.city = addressItem['long_name']
elif 'country' in addressItem['types']:
country = Country(addressItem['long_name'])
elif 'administrative_area_level_1' in addressItem['types']:
state = State(addressItem['long_name'],
addressItem['short_name'])
elif 'postal_code' in addressItem['types']:
location.zipcode = addressItem['long_name']
elif 'route' in addressItem['types']:
location.address = addressItem['long_name']
state.country = country
location.state = state
return location
except Exception as e:
print(e)
return []
class Inset(object):
width = BoundedFloat("width", minimum=0.0, maximum=1.0)
height = BoundedFloat("height", minimum=0.0, maximum=1.0)
location = Location("location")
def __init__(self,
plot,
width=0.3,
height=0.3,
location="best",
padding=0.05):
self.plot = plot
self.width = width
self.height = height
self.location = location
self.padding = padding
def draw(self, fig, axes):
if not BOOMSLANG_INSET_LOCATOR_LOADED:
print >>sys.stderr, "Plotting insets requires " \
"mpl_toolkits.axes_grid.inset_locator, which " \
"your version of matplotlib doesn't appear to " \
"have."
sys.exit(1)
insetAxes = mpl_toolkits.axes_grid.inset_locator.inset_axes(
axes,
width="%.2f%%" % (self.width * 100.0),
height="%.2f%%" % (self.height * 100.0),
loc=self.location)
self.plot.drawPlot(fig, insetAxes)
return insetAxes
