def convert(self, string):
string = location.Location.resolve_alias(string,
constants.location_aliases)
if string == constants.country:
return location.Location(string, 'stato')
elif string in constants.regions:
return location.Location(string, 'regione')
elif string in constants.provinces:
return location.Location(string, 'provincia')
else:
raise Parser.ConversionError(string)
def __init__(self, area_in_square_meters = 0, price_in_USD = 0, location = location.Location(),\
district = "Shwadchack", balcony_count = 0, area_of_land_in_squareMeters = 0, entrance_door_count = 0, other_buildings_in_area = False):
super().__init__(area_in_square_meters, price_in_USD, location, district, balcony_count)
self.area_of_land_in_squareMeters = area_of_land_in_squareMeters
self.entrance_door_count = entrance_door_count
self.other_buildings_in_area = other_buildings_in_area
def get(self, *args, **kwargs):
"""
Retrieve information about a city.
:param args:
:param kwargs:
:return:
"""
# retrieve city name from URL
url_components = [x for x in self.request.path.split("/") if x]
city_name = url_components[-1]
# create a location object for the specified city
try:
city = location.Location(city_name)
response = {
'city_name': city.name,
'current_temperature': city.temp,
'current_weather_description': city.weather_desc,
'population': city.population,
'bars': city.num_bars,
'public_transport': city.public_transport,
'city_score': city.score
}
self.set_status(HTTPStatus.OK)
self.write(json.dumps(response))
except (csv.Error, tornado.httpclient.HTTPError, socket.gaierror,
TypeError, IndexError, KeyError, ValueError):
response = {
'error': 'Unable to retrieve details for your specified city.'
}
self.set_status(HTTPStatus.INTERNAL_SERVER_ERROR)
self.write(json.dumps(response))
def getTheSilentForest():
def enter():
output.proclaim(
"The Silent Forest: Great oaks sway endlessly to the southerly winds. The air's oppression is lifted but briefly at the occasional rustle. Trees obscure the view to Trainee Valley."
)
def exit():
output.proclaim("You have left the Silent Forest.")
monsters = fList.FrequencyList([[ProwlingFox(), 0.4], [Owl(), 0.35],
[SorcererOutcast(), 0.2],
[SkeletonScout(), 0.04],
[DoomPanda(), 0.01]])
def getMonster():
return monsters.getOption(
condition=lambda monster: monster.canRespawn())
theSilentForestActions = [
actions.RestHeal(player),
actions.Scavenge(
player,
[
[actions.ScavengeGold(player, 0, 4), 0.99],
# health, armor, strength, spirit, criticalChance, criticalStrike, dodge
[shrine.StatShrine([20, 10, 10, 10, 0.1, 1, 0.2], 50), 0.01]
])
]
theSilentForestInteractions = [[actions.Nothing(), 0.8],
[fight.Fight(getMonster), 0.2]]
return location.Location("The Silent Forest", enter, exit,
theSilentForestActions,
theSilentForestInteractions)
def __init__ (self, area_in_square_meters = 0, price_in_USD = 0, location = location.Location(),\
district = "Shwadchack", balcony_count = 0):
self.area_in_square_meters = area_in_square_meters
self.price_in_USD = price_in_USD
self.location = location
self.district = district
self.balcony_count = balcony_count
def add_location(self, path):
r = location.Location(path)
if path == self.base:
#r.inventory.append(inventory.FuryArmor(location = r))
r.inventory.append(inventory.ChainArmor(location=r))
r.inventory.append(inventory.LongSword(location=r))
#r.inventory.append(inventory.GreatAxe(location = r))
# r.inventory.append(inventory.BeltOfGiants(location = r))
r.inventory.append(inventory.HelmOfContinency(location=r))
r.inventory.append(inventory.JacksonHelm(location=r))
r.inventory.append(inventory.JacksonBelt(location=r))
r.inventory.append(inventory.JacksonBoots(location=r))
r.dream_stone = True
r.dimensional_warp = True
else: #here everything should be folder dependent: monsters are file, depending on the type you get different monsters, maybe objects as well. size of files give monsters strength. should make more allies and passive monsters.
r.dream_stone = random.randint(0, 1)
r.dimensional_warp = random.randint(0, 1)
for i in xrange(random.randint(0, 2)):
v = self.quick_villain()
v.location = r
v.master_location_path = v.location.path
v.world = self
r.characters.append(v)
self.locations.append(r)
def generate_points_gauss(num_points, k):
print(
f"Randomly generating {k} gaussian clusters with {num_points} total points:"
)
group_num = float(num_points) / k
locations = []
for i in range(k):
c = (random.uniform(-90, 90), random.uniform(-180, 180))
s = random.uniform(3.0, 18.0)
x = []
print(f"Randomly Generated Center {i}: [{c[0]}, {c[1]}]")
while len(x) < group_num:
a, b = np.array(
[np.random.normal(c[0], s),
np.random.normal(c[1], s)])
if b < -180:
b += 360
elif b > 180:
b -= 360
row = {
"Name": f"TestPoint [{i}]",
"Latitude": a,
"Longitude": b,
"Attribute1": random.random() > 0.999,
"Attribute2": random.random() > 0.999
}
x.append(location.Location(row))
locations.extend(x)
return locations
def load_pages(self):
# misc.set_cursor(Gdk.CursorType.WATCH)
self.pages["location"] = location.Location(self.params)
self.pages["check"] = check.Check(self.params)
self.pages["keymap"] = keymap.Keymap(self.params)
self.pages["timezone"] = timezone.Timezone(self.params)
self.pages["installation_ask"] = installation_ask.InstallationAsk(self.params)
self.pages["installation_automatic"] = installation_automatic.InstallationAutomatic(self.params)
if self.settings.get("enable_alongside"):
self.pages["installation_alongside"] = installation_alongside.InstallationAlongside(self.params)
else:
self.pages["installation_alongside"] = None
self.pages["installation_advanced"] = installation_advanced.InstallationAdvanced(self.params)
self.pages["user_info"] = user_info.UserInfo(self.params)
self.pages["slides"] = slides.Slides(self.params)
# misc.set_cursor(Gdk.CursorType.ARROW)
diff = 2
num_pages = len(self.pages) - diff
if num_pages > 0:
self.progressbar_step = 1.0 / num_pages
def read_location_csv(filename, header):
"""
Converts every row in the file into a location object and appends all objects
to the _locations list.
:param filename: str, the name of the csv with all the necessary stops. File
columns need to be in the following order:
location_name, address (doesn't need to be populated), latitude, longitude.
:param header: boolean, True if the file has a header. Columns still need to
be in the above prescribed order.
:return: list, a list of every location object that was created, including
origin if add_origin() was run.
"""
with open(filename, newline='') as csvfile:
if header == True:
next(csvfile)
file_reader = csv.reader(csvfile, delimiter=',', quotechar='"')
for row in file_reader:
name = row[0]
lat = row[2]
lon = row[3]
place = location.Location(name, lat, lon)
_locations.append(place)
return _locations
def getFortMorning():
def enter():
output.proclaim(
"Fort Morning: Rough cobblestones pattern the streets of Fort Morning. The din of the market carries loudly to the Southern gate, whose wall protrudes ten feet from the earth below. Merchants frequent the fort, but the eastern wizards rarely visit."
)
def exit():
output.proclaim("You have left the Fort Morning.")
monsters = fList.FrequencyList([[GiantSewerRat(), 0.8],
[UnholyOoze(), 0.2]])
def getMonster():
return monsters.getOption(
condition=lambda monster: monster.canRespawn())
fortMorningActions = [
actions.RestHeal(player),
actions.Scavenge(player, [[actions.ScavengeGold(player, 0, 3), 1]]),
actions.Talk(player, [captainJorna]),
actions.Shop(player, [morningWares, villageArmory])
]
fortMorningInteractions = [[actions.Nothing(), 0.93],
[fight.Fight(getMonster), 0.07]]
return location.Location("Fort Morning", enter, exit, fortMorningActions,
fortMorningInteractions)
def getTraineeValley():
def enter():
output.proclaim(
"Trainee Valley: Sparse trees occupy rolling expanses of lush grass. Fort Morning is barely visible in the distant north, while the Silent Forest looms to the east."
)
def exit():
output.proclaim("You have left Trainee Valley.")
monsters = fList.FrequencyList([[Wolf(), 0.8], [DrunkenTrainee(), 0.2],
[GraglisTheGremlin(), 0.008]])
def getMonster():
return monsters.getOption(
condition=lambda monster: monster.canRespawn())
traineeValleyActions = [
actions.RestHeal(player),
actions.Scavenge(
player,
[
[actions.ScavengeGold(player, 0, 2), 0.98],
# health, armor, strength, spirit, criticalChance, criticalStrike, dodge
[shrine.StatShrine([20, 10, 10, 10, 0.1, 1, 0.2], 50), 0.02]
]),
actions.Talk(player, [oldHermit])
]
traineeValleyInteractions = [[actions.Nothing(), 0.8],
[fight.Fight(getMonster), 0.2]]
return location.Location("Trainee Valley", enter, exit,
traineeValleyActions, traineeValleyInteractions)
def walk(currentLocation, facing, numberOfBlocks, locationSet, repeatFound):
locationToReturn = location.Location(currentLocation.getx(),
currentLocation.gety())
if (facing == Facing.NORTH):
locationToReturn.moveYAxis(numberOfBlocks)
elif (facing == Facing.SOUTH):
locationToReturn.moveYAxis(numberOfBlocks * -1)
elif (facing == Facing.WEST):
locationToReturn.moveXAxis(numberOfBlocks * -1)
elif (facing == Facing.EAST):
locationToReturn.moveXAxis(numberOfBlocks)
else:
raise ValueError('Incorrect Facing seen.')
locationsVisited = location.Location.getAllMidpoints(
currentLocation, locationToReturn)
for locationVisited in locationsVisited:
if not locationVisited in locationSet:
locationSet.add(locationVisited)
elif (locationVisited in locationSet
and repeatFound.getrepeatFound() == False):
repeatFound.setrepeatFound(True)
print "First Repeat Distance from Origin: %i" % distanceFromOrigin(
locationVisited)
#print "locationSet"
#for l in locationSet:
# print l.display()
return locationToReturn
def test_creation(self):
raised = False
try:
loc = location.Location(0, 0)
except:
raised = True
self.assertFalse(raised, 'Exception raised')
def __init__(self):
self.url = ""
self.location = location.Location()
self.units = {}
self.forecasts = []
self.numfcasts = 0
self.jsondata = {}
def set_student(job):
"""
This function sets a job to the preset values of student occupation.
* fixed shift of 08:00 - 15:00
* Monday through Friday
* wage of $0
* 30 minute commute to school
* 60 minute commute from school
:param occupation.Occupation job: the job to set
:return: None
"""
# the number of minutes in 1 day, the number of minutes in 1 hour
DAY_2_MIN, HOUR_2_MIN = temporal.DAY_2_MIN, temporal.HOUR_2_MIN
# job identifier
job.id = STUDENT
# set the occupation type to a fixed shift
job.category = FIXED_SHIFT
job.t_start = START_MEAN_SCHOOl
job.t_end = END_MEAN_SCHOOL
# occupation duration 8:00 hours
job.dt = (job.t_end - job.t_start) % DAY_2_MIN
# set the end time
job.set_t_end()
# set the flag indicating that the job starts and ends on the same day
job.set_is_same_day()
# set the work days
job.work_days = (temporal.MONDAY, temporal.TUESDAY, temporal.WEDNESDAY,
temporal.THURSDAY, temporal.FRIDAY)
# set the wage in U.S. dollars
job.wage = 0.0
# set the is_employed flag
job.is_employed = True
# set the job location
job.location = location.Location(location.NORTH, location.OFF_SITE)
# set the commute
job.commute_to_work_dt_mean = COMMUTE_TO_WORK_DT_MEAN
job.commute_from_work_dt_mean = COMMUTE_TO_WORK_DT_MEAN
job.commute_to_work_dt = job.commute_to_work_dt_mean
job.commute_from_work_dt = job.commute_from_work_dt_mean
job.set_commute_distribution()
job.set_work_distribution()
return
def set_standard_job(job):
"""
This function sets the Occupation to the standard job.
* fixed shift of 9:00 - 17:00
* Monday through Friday
* wage $40,000
* 30 minute commute to work
* 60 minute commute from work
:param occupation.Occupation job: the job of which to set the attributes
:return: None
"""
DAY_2_MIN, HOUR_2_MIN = temporal.DAY_2_MIN, temporal.HOUR_2_MIN
# identifier
job.id = STANDARD_JOB
# set the occupation type to a fixed shift
job.category = FIXED_SHIFT
# start at 9:00
job.t_start = 9 * HOUR_2_MIN
job.t_end = 17 * HOUR_2_MIN
# occupation duration 8:00 hours
job.dt = (job.t_end - job.t_start) % DAY_2_MIN
# set the end time
job.set_t_end()
# set the flag indicating that the job starts and ends on the same day
job.set_is_same_day()
# set the work days
job.work_days = (temporal.MONDAY, temporal.TUESDAY, temporal.WEDNESDAY,
temporal.THURSDAY, temporal.FRIDAY)
# set the wage in U.S. dollars
job.wage = 40000.0
# set the is_employed flag
job.is_employed = True
# set the job location
job.location = location.Location(location.NORTH, location.OFF_SITE)
# set the commute
job.commute_to_work_dt_mean = COMMUTE_TO_WORK_DT_MEAN
job.commute_from_work_dt_mean = COMMUTE_TO_WORK_DT_MEAN
job.commute_to_work_dt = job.commute_to_work_dt_mean
job.commute_from_work_dt = job.commute_from_work_dt_mean
job.set_commute_distribution()
job.set_work_distribution()
return
def getDampLair():
monsters = fList.FrequencyList([[AricneaTheSly(), 1]])
def enter():
sequel = ""
if monsters[0].canRespawn(): # if Aricnea is alive...
sequel = "A faint light glows in distance. A huge skeleton turns to face you."
else: # if Aricnea is dead...
sequel = "Aricnea's bones lie untouched, scattered across the floor."
output.proclaim(
"Damp Lair: Cave moss grows on the arched ceiling of the cavern. "
+ sequel)
def exit():
output.proclaim("You have left Damp Lair.")
def getMonster():
return monsters.getOption(
condition=lambda monster: monster.canRespawn())
skeletonCaveActions = [actions.RestHeal(player)]
skeletonCaveInteractions = [
[fight.Fight(getMonster), 1],
]
return location.Location("Damp Lair", enter, exit, skeletonCaveActions,
skeletonCaveInteractions)
def _add_location(self, event=None):
'''Make the user's input a Location and add to the list of locations
'''
# The details of the new location
user_input = self.entry_box.get()
new_location = location.Location(user_input)
self.locations.append(new_location)
precise = new_location.location
# goompy loading a new tile as per the location
self.goompy.lat = float(precise[:precise.find(",")])
self.goompy.lon = float(precise[precise.find(",")+1:])
self._reload()
# Differnt actions depending on how many locations currently exist
if len(self.locations) > self.VIEW_SIZE:
# Configure the movement buttons is not configured
if not self.showing_movement_buttons:
self.up_button.grid(row=1, column=0, columnspan=2, sticky="w")
self.down_button.grid(
row=self.VIEW_SIZE+10,
column=0,
columnspan=2,
sticky="w"
)
# Ensures the latest location is displayed at the bottom
while len(self.locations)-self.location_view > self.VIEW_SIZE:
self._move_boxes(1)
else:
# Move the entry box, and its button, down on space
self.entry_box.grid_configure(
row=self.entry_box.grid_info()["row"]+1
)
self.entry_button.grid_configure(
row=self.entry_box.grid_info()["row"]
)
# The row the the entry box moved from
row = self.entry_box.grid_info()["row"]-1
# Create a Label and a Button for the new location
tk.Label(
self.frame,
text=user_input,
bg="white",
anchor="w"
).grid(row=row, column=0, sticky="ew", columnspan=4)
tk.Button(
self.frame,
text="X",
bg="red",
command=lambda: self._remove_location(len(self.locations))
).grid(row=row, column=4, sticky="ew")
# Reset the text in the entry box
self.entry_box.delete(0, "end")
self.entry_box.insert("end", "Add Location")
def location(cls):
"""Return 'location.Location' of a web page related to the test.
"""
if cls._url:
loc = location.Location(cls._url)
else:
loc = None
return loc
def add_distance(mLocation, distance, angle):
y = distance * math.sin(angle)
x = distance * math.cos(angle)
new_latitude = mLocation.latitude + (y / EATRH_RADIUS) * (180 / math.pi)
new_longitude = mLocation.longitude + (x / EATRH_RADIUS) * (
180 / math.pi) / math.cos(mLocation.latitude * math.pi / 180)
# print("Location: %f, %f" % (new_latitude, new_longitude))
return location.Location(float(new_longitude), float(new_latitude))
def set_no_job(self):
"""
Set the Occupation to having no job.
:param occupation.Occupation job: the job of which to set the attributes
:return: None
"""
self.id = NO_JOB
# set the job category
self.category = NO_TIME
self.commute_to_work_dt_mean = 0
self.commute_to_work_dt_std = 0
self.commute_to_work_dt = 0
self.commute_from_work_dt_mean = 0
self.commute_from_work_dt_std = 0
self.commute_from_work_dt = 0
self.set_commute_distribution()
# the start time of the job [time of day, minutes]
self.t_start_mean = 0
self.t_start_std = 0
self.t_start = 0
self.t_end_mean = 0
self.t_end_std = 0
self.t_end = 0
self.set_work_distribution()
# for easy recall
self.commute_to_work_start = 0
# set job duration
self.dt = 0
# set the flag indicating whether or not the job starts and end on the same day
self.is_same_day = True
# set work days to none
self.work_days = ()
# set to no wage
self.wage = 0.0
# set employment flag
self.is_employed = False
# set the location to home
self.location = location.Location(location.NORTH, location.HOME)
return
def set_grave_shift(job):
"""
This function sets the Occupation to a grave shift.
* shift job from 22:00 to 6:00
* Monday through Friday
* 30 minute commute to work
* 60 minute commute from work
* wage of $40,0000.
:param occupation.Occupation job: the job of which to set the attributes
:return: None
"""
HOUR_2_MIN = temporal.HOUR_2_MIN
# identifier
job.id = GRAVE_SHIFT
# set the job category
job.category = FIXED_SHIFT
# set the start time to be 22:00
job.t_start = 22 * HOUR_2_MIN
# set the job duration
job.dt = 8 * HOUR_2_MIN
# set the end time
job.set_t_end()
# set the flag indicating whether or not the job starts and ends on the same day
job.set_is_same_day()
# set the work days
job.work_days = (temporal.MONDAY, temporal.TUESDAY, temporal.WEDNESDAY,
temporal.THURSDAY, temporal.FRIDAY)
# set the wage in U.S dollars
job.wage = 40000.0
# set the employment flag
job.is_employed = True
# set the location
job.location = location.Location(location.NORTH, location.OFF_SITE)
# set the commute
job.commute_to_work_dt_mean = COMMUTE_TO_WORK_DT_MEAN
job.commute_from_work_dt_mean = COMMUTE_TO_WORK_DT_MEAN
job.commute_to_work_dt = job.commute_to_work_dt_mean
job.commute_from_work_dt = job.commute_from_work_dt_mean
job.set_commute_distribution()
job.set_work_distribution()
return
def max_reachable_location(self, heading):
ttfh = self.time_to_face_heading(heading)
max_reachable_dist = self.get_reachable_distance(ttfh)
rad_angle = math.pi/2.0 - math.radians(heading)
l = self.get_location()
retLoc = loc.Location(l.x + 5.0*max_reachable_dist*math.cos(rad_angle),
l.y + 5.0*max_reachable_dist*math.sin(rad_angle),
l.z)
return retLoc
def get_az_el(self, utc_date, lat, lon, alt):
s = sun.Sun()
loc = location.Location(lat, lon, alt=alt)
ra, decl = s.radec(utc_date)
_el, _az = loc.equatorial_to_horizontal(utc_date, ra,decl)
el, az = np.round([_el.to_degrees(), _az.to_degrees()], decimals=6)
ret = []
ret.append({'name': 'sun', 'r': 1e10, 'el':el, 'az':az, 'jy':10000.0})
return ret
def get(self, *args, **kwargs):
"""
Retrieves information about multiple cities, rates them and returns a ranking and score for each city.
:param args:
:param kwargs:
:return:
"""
# retrieve URL "cities" param
city_names = args[0].split(",")
# check that more than one city has been specified
if (len(city_names) == 1):
response = {'error': 'At least two cities must be specified.'}
self.set_status(HTTPStatus.INTERNAL_SERVER_ERROR)
self.write(json.dumps(response))
else:
found_cities = []
not_found = []
# attempt to source data for each city
for city_name in city_names:
try:
city = location.Location(city_name)
found_cities.append({
'city_name': city.name,
'city_score': city.score
})
except (csv.Error, tornado.httpclient.HTTPError,
socket.gaierror, TypeError, IndexError, KeyError,
ValueError):
not_found.append(city_name)
# if all cities are found, compare them
if len(found_cities) == len(city_names):
response = self.compare(found_cities)
self.set_status(HTTPStatus.OK)
self.write(json.dumps(response))
# if one or more cities have not been found, let the user know which ones
elif len(found_cities) > 0:
response = {
'error':
'Unable to retrieve details for the following cities: ' +
(' ,'.join(not_found))
}
self.set_status(HTTPStatus.INTERNAL_SERVER_ERROR)
self.write(json.dumps(response))
else:
response = {
'error':
'Unable to retrieve details for any of the cities specified.'
}
self.set_status(HTTPStatus.INTERNAL_SERVER_ERROR)
self.write(json.dumps(response))
def record_wall(self, loc, direction):
"We bumped into a wall"
# 1. If we don't have the current location, create it
if loc not in self.area:
self.area[loc] = location.Location(loc=loc)
# 2. Record the wall
self.area[loc].set_dir(direction, location.IS_WALL)
def __init__(self, origin, path, json):
"""
初始化Route和Location
"""
self.route = route.Route(origin, path, json)
self.name = path.split('/')[-1]
self.destination_loc = self.route.next_loc()
self.next_destination_loc = self.route.next_loc()
self.location = location.Location()
def record_move(self, loc, direction, new_loc, oxygen):
"We managed to move"
# 1. If we don't have the current location, create it
if loc not in self.area:
self.area[loc] = location.Location(loc=loc)
if new_loc not in self.area:
self.area[new_loc] = location.Location(loc=new_loc)
# 2. Move forward
if oxygen:
at_fwd = location.IS_OXYGEN
else:
at_fwd = location.IS_FWD
self.area[loc].set_dir(direction, at_fwd)
# 3. Record the reverse movement
self.area[new_loc].set_back(direction)
def read_csv(csv_path):
locs = []
with open(csv_path, newline='') as csv_file:
csv_reader = csv.DictReader(csv_file)
for row in csv_reader:
locs.append(location.Location(row))
return locs
def add_origin():
"""
Adds the origin as a location that needs to be included in the distance
matrix.
"""
place = location.Location(_origin_name, _origin_lat, _origin_lon)
place.origin = True
_locations.append(place)
return place
