def __init__(self, loader, parentFSM, doneEvent): self.parentFSM = parentFSM Place.__init__(self, loader, doneEvent) self.fsm = ClassicFSM('Street', [ State( 'start', self.enterStart, self.exitStart, ['walk', 'doorOut', 'teleportIn', 'tunnelOut', 'elevatorIn']), State('walk', self.enterWalk, self.exitWalk, ['stop', 'tunnelIn', 'shtickerBook', 'teleportOut']), State('shtickerBook', self.enterShtickerBook, self.exitShtickerBook, ['teleportOut', 'walk']), State('teleportOut', self.enterTeleportOut, self.exitTeleportOut, ['teleportIn', 'stop']), State('tunnelOut', self.enterTunnelOut, self.exitTunnelOut, ['walk']), State('tunnelIn', self.enterTunnelIn, self.exitTunnelIn, ['stop']), State('stop', self.enterStop, self.exitStop, ['walk', 'died', 'teleportOut', 'doorIn']), State('doorIn', self.enterDoorIn, self.exitDoorIn, ['stop']), State('doorOut', self.enterDoorOut, self.exitDoorOut, ['walk']), State('teleportIn', self.enterTeleportIn, self.exitTeleportIn, ['walk', 'stop']), State('elevatorIn', self.enterElevatorIn, self.exitElevatorIn, ['walk', 'stop']), State('final', self.enterFinal, self.exitFinal, ['final']) ], 'start', 'final')
def find_places_in_lyrics(lyrics, song_title, song_artist): st = StanfordNERTagger( '/Users/yuvalhering/Desktop/stanford-ner-2018-10-16/classifiers/english.all.3class.distsim.crf.ser.gz', '/Users/yuvalhering/Desktop/stanford-ner-2018-10-16/stanford-ner.jar', encoding='utf-8') tokenized_text = word_tokenize(lyrics) classified_text = st.tag(tokenized_text) ner_places = [] for classification in classified_text: if classification[1] == 'LOCATION': ner_places.append(classification[0]) extracted_places = list(set(ner_places)) places = [] for new_place_name in extracted_places: exists = False for place in places: if place.name == new_place_name: place.add_song(song_title, song_artist) exists = True break if not exists: p = Place(new_place_name) p.add_song(song_title, song_artist) places.append(p) json_places = [] for p in places: place_dict = p.to_json() json_places.append(place_dict) with open('places.json', 'w', encoding='utf-8') as places_file: json.dump(json_places, places_file, indent=2)
def test_removing_user(self): self.db.set_user_stage(1, Stage.START) self.db.add_place(1, Place("Good restaurant", 65.13, 66.14)) self.db.add_place(1, Place("Very Good restaurant", 62.12, 66.14)) self.assertTrue(self.db.has_user(1)) self.db.reset_user(1) self.assertFalse(self.db.has_user(1))
def exit(self, vis=1): if vis: self.visibilityOff() self.loader.geom.reparentTo(hidden) self.loader.hood.stopSky() self.loader.music.stop() Place.exit(self)
def exit(self, vis = 1): if vis: self.visibilityOff() self.loader.geom.reparentTo(hidden) self.loader.hood.stopSky() self.loader.music.stop() Place.exit(self)
def run_tests(): """Test Place class.""" # Test empty place (defaults) print("Test empty place:") default_place = Place("Townsville", "Australia", 0, "v") print(default_place) assert default_place.name == "Townsville" assert default_place.country == "Australia" assert default_place.priority == 0 assert default_place.is_visited # Test initial-value place print("Test initial-value place:") new_place = Place("Malagar", "Spain", 2, False) # TODO: Write tests to show this initialisation works print(new_place) print(new_place.name) print(new_place.country) print(new_place.priority) print(new_place.visited) print(f"Dict: {new_place.__dict__}") # TODO: Add more tests, as appropriate, for each method print("Is important: {}".format(new_place.is_important())) print("Visited? {}".format(new_place.is_visited()))
def unload(self): self.parentFSM.getStateNamed('street').removeChild(self.fsm) del self.fsm del self.parentFSM self.enterZone(None) self.ignoreAll() Place.unload(self) return
def test_places(self): self.db.add_place(1, Place("Good restaurant", 65.13, 66.14)) self.db.add_place(1, Place("Very Good restaurant", 62.12, 66.14)) places = self.db.get_places(1) self.assertIn(Place("Good restaurant", 65.13, 66.14), places) self.assertIn(Place("Very Good restaurant", 62.12, 66.14), places) self.assertEqual(self.db.get_place_by_name(1, "Good restaurant"), Place("Good restaurant", 65.13, 66.14))
def addToken(self, token): assert token.__class__.__name__ == 'TimeToken' Place.addToken(self, token) if self.withoutTime: token.placeClocks = {} token.pclock = 0.0 token.addPlaceClock(self, token.placeClocks.get(self)) token.pclock = token.placeClocks[self]
def enter(self, requestStatus, visibilityFlag=1): Place.enter(self) self.fsm.enterInitialState() base.playMusic(self.loader.music, volume=0.8, looping=1) self.loader.geom.reparentTo(render) if visibilityFlag: self.visibilityOn() self.loader.hood.startSky() self.enterZone(requestStatus['zoneId']) self.fsm.request(requestStatus['how'], [requestStatus])
def enter(self, requestStatus, visibilityFlag = 1): Place.enter(self) self.fsm.enterInitialState() base.playMusic(self.loader.music, volume=0.8, looping=1) self.loader.geom.reparentTo(render) if visibilityFlag: self.visibilityOn() self.loader.hood.startSky() self.enterZone(requestStatus['zoneId']) self.fsm.request(requestStatus['how'], [requestStatus])
def load_places(self, filename): self.filename = filename with open(filename) as file: for line in file: parts = line.strip().split(',') place = Place(parts[0], parts[1], parts[2], parts[3]) if parts[3] == 'v' or parts[3] == True: place.is_visited = True else: place.is_visited = False self.file_places.append(place)
def simulatedAnnealing(data, hotel, maxIterations = 10): finalBestOrdering = {} finalBestTime = 0 hotelObj = Place(None, None, None, None, None) hotelObj.pos = hotel foodLists = {} entertainLists = {} #get all food places out #edited this block for key in data: foodLists[key], entertainLists[key] = [], [] for attraction in data[key]: if attraction.category == 'FOOD_BEVERAGE': foodLists[key].append(attraction) else: entertainLists[key].append(attraction) for key in data: if len(data[key]) == 0: finalBestOrdering[key] = data[key] continue elif len(data[key]) == 1: finalBestOrdering[key] = data[key] finalBestTime += getTime(hotelObj, data[key][0]) + getTime(data[key][0], hotelObj) continue ##edited these 2 lines curr = [hotelObj] + getInitialOrdering(foodLists[key], entertainLists[key]) + [hotelObj] foodIndeces, entertainIndeces = getIndeces(curr) bestOrdering = curr bestTime = getTime(curr) for i in range(maxIterations): curr = randomizeOrdering(curr, foodIndeces, entertainIndeces) val = getTime(curr) if val < bestTime: bestTime = val bestOrdering = curr else: rand = random.random() if rand < temperature(i): bestTime = val bestOrdering = curr finalBestOrdering[key] = bestOrdering[1:-1] finalBestTime += bestTime return finalBestOrdering, finalBestTime
def getAllTweets(dbm): """Regresa una lista de objetos Tweet con todos los elementos de la tabla""" allTweets = [] if dbm is not None: res = dbm.runQuery( "SELECT tweetID, from_user_id, tweet, created_at, placeId, source, favorite_count, coordinates, userId, \ geo, lang, filter_level, in_reply_to_status_id_str FROM Tweets") for row in res: tweetRes = Tweet() tweetRes.set(tweetID=row[0], from_user=User.searchUserById(dbm, row[1]), tweet=row[2], created_at=row[3], place=Place.searchPlaceById(dbm, row[4]), source=row[5], favorite_count=row[6], coordinates=row[7], geo=row[9], lang=row[10], filter_level=row[11], in_reply_to_status_id_str=row[12]) tweetRes.dbm = dbm allTweets.append(tweetRes) return allTweets else: raise Exception("No DBM declared")
def searchTweetById(dbm, tweetID): """Regresa un objeto Tweet para la id buscada""" tweetRes = Tweet(dbm) if dbm is not None: res = dbm.runQuery( "SELECT tweetID, from_user_id, tweet, created_at, placeId, source, favorite_count, coordinates, userId, geo, lang, filter_level, in_reply_to_status_id_str FROM Tweets WHERE tweetID={}" .format(tweetID)) try: if res is not None: row = res[0] tweetRes.set(tweetID=row[0], from_user=User.searchUserById(dbm, row[1]), tweet=row[2], created_at=row[3], place=Place.searchPlaceById(dbm, row[4]), source=row[5], favorite_count=row[6], coordinates=row[7], geo=row[9], lang=row[10], filter_level=row[11], in_reply_to_status_id_str=row[12]) except: pass return tweetRes else: raise Exception("No DBM declared")
def __init__(self, config_places, config_crowd, config_isolation, config_preventions, medicalModel): self.config_places = config_places self.config_crowd = config_crowd self.config_isolation = dict(config_isolation.items()) self.enableIsolation = self.config_isolation['enable'] if not self.enableIsolation: self.config_isolation['agreeIsolationRate'] = 0 self.config_preventions = config_preventions self.medicalModel = medicalModel self.flexPlaces = {} self.day = 0 # step 1: create citizens self.crowd = [] for config in config_crowd: for i in range(config['number']): healthStage = self.medicalModel.initIllnessStage if i < config[ 'patient'] else self.medicalModel.healthStage prevention = [ preventionType for preventionType, config in config_preventions.items() if random.random() < config['applicationRatio'] ] newPerson = Person( config, healthStage, prevention, random.random() < config_isolation['agreeIsolationRate'], config_isolation['selfDiscipline']) self.crowd.append(newPerson) self.population = self.crowd.copy() random.shuffle(self.crowd) # step 2: create (fixed) locations self.fixedPlaces = {} for config in config_places: if config['number'] is None: continue self.fixedPlaces[config['type']] = [ Place(config) for i in range(config['number']) ] # step 3: randomly link people with fixed locations according to the 'fixedActivity' allPossibleDefaultPlaceTypes = [ person.defaultActivity for person in self.crowd ] allPossibleFixedPlaceTypes = itertools.chain( *[person.fixedActivityTypes() for person in self.crowd], allPossibleDefaultPlaceTypes) allPossibleFixedPlaceTypes = set(allPossibleFixedPlaceTypes) for placeType in allPossibleFixedPlaceTypes: people = [ person for person in self.crowd if placeType in person.fixedActivityTypes() or placeType == person.defaultActivity ] places = [place for place in self.fixedPlaces[placeType]] # randomly link the remaining people with places allocation = self.randomlyAllocate(people, places) for place, person in allocation: person.linkedPlace[placeType] = place place.linkedPeople.append(person)
def CrossStreet(CrossStreetName=None, StreetName=None, StreetType=None, City=None, State=None, Zip=None): try: return Place(city=City, state=State, zip=Zip, street_name=StreetName, street_type=StreetType, cross_street=CrossStreetName) except ValueError: return None
def Add_New_Place(): Location = Location_Error_Checking() Country = Country_Error_Checking() Priority_Input = Integer_Error_Checking() print( f"{Location} in {Country} (priority {Priority_Input}) added to Travel Tracker" ) file_entry.insert(0, Place(Location, Country, Priority_Input, 'n'))
def add_place_location(message): print(f"Adding place location with {message.chat.id}") lat, lon = message.location.latitude, message.location.longitude name = db.get_staged_place_name(message.chat.id) db.add_place(message.chat.id, Place(name, lat, lon)) db.clean_staged_place_name(message.chat.id) memorizer.send_message(message.chat.id, "Новое место успешно добавлено") db.set_user_stage(message.chat.id, Stage.START)
def simulatedAnnealing(data, hotel, maxIterations=100): finalBestOrdering = {} finalBestTime = 0 hotelObj = Place(None, None, None, None) hotelObj.pos = hotel for key in data: if len(data[key]) == 0: finalBestOrdering[key] = data[key] continue elif len(data[key]) == 1: finalBestOrdering[key] = data[key] finalBestTime += getTime(hotelObj, data[key][0]) + getTime( data[key][0], hotelObj) continue curr = [hotelObj] + data[key] + [hotelObj] #numAttractions = len(data[key]) # for _ in range(numAttractions): # rand = random.randint(0, len(data[key])) # curr.append(data[key][rand]) # data[key].remove(data[key][rand]) #curr.append(hotelObj) bestOrdering = curr bestTime = getTime(curr) for i in range(maxIterations): curr = randomizeOrdering(curr) val = getTime(curr) if val < bestTime: bestTime = val bestOrdering = curr else: rand = random.random() if rand < temperature(i): bestTime = val bestOrdering = curr finalBestOrdering[key] = bestOrdering[1:-1] finalBestTime += bestTime return finalBestOrdering, finalBestTime
def generate_map(self): #for x in range(0, 20): # for y in range(0, 20): # if(x == 1 and y == 1): # self.map_locations[x][y] = Place(1) # else: # self.map_locations[x][y] = Place(0) for x in range(0, 19): for y in range(0, 13): self.map_locations[x][y] = Place(self.temp_map[y][x], self, x, y)
def BasicAddress(StreetNumber=None, UnitLetter=None, StreetDirection=None, StreetName=None, StreetType=None, City=None, State=None, Zip=None): try: return Place(city=City, state=State, zip=Zip, street_number=StreetNumber, street_name=StreetName, street_direction=StreetDirection, street_type=StreetType, unit_letter=UnitLetter) except ValueError: return None
def filter_by_popularity(self, center, attractions): ''' Filters attractions using knapsack. weights = a weighted average of estimated time spent at location and distance from center values = a weighted average of num checkins and overall star rating ''' places, weights, values = [], [], [] for attraction in attractions: place = \ Place(attraction["name"], \ attraction["location"]["latitude"], \ attraction["location"]["longitude"], \ attraction) val = place.calculate_value(attraction["checkins"], attraction["overall_star_rating"]) weight = place.calculate_weight(center) values.append(val) weights.append(weight) places.append(place) return self.knapsack(5000000, weights, values, len(places), places)
def movePeople(self, hourId): flexPlaceBuffers = {} for person in self.crowd: if hourId > 0 and person.schedule[hourId] == person.schedule[hourId - 1]: continue # don't need to move the person if person.currentPlace is not None: person.currentPlace.removePerson(person) activity, type = person.schedule[hourId] if type == 'isolating': person.currentPlace = None elif type == 'fixed': newPlace = person.linkedPlace[activity] newPlace.addPerson(person) person.currentPlace = newPlace else: # type==flex buffer = flexPlaceBuffers.setdefault(activity, []) buffer.append(person) pass for placeType, people in flexPlaceBuffers.items(): if placeType in self.fixedPlaces: # if people visit a fixed place as a flex activity, just put them in existing fixed places. (ignore the place capacity) currentPlaces = self.fixedPlaces[placeType] allocation = self.randomlyAllocate(people, currentPlaces) else: # people visit flex places currentPlaces = self.flexPlaces.setdefault(placeType, []) # remore the empty places currentPlaces = [ place for place in currentPlaces if len(place.currentPeople) == 0 ] self.flexPlaces[placeType] = currentPlaces placeConfig = [ placeConfig for placeConfig in self.config_places if placeConfig['type'] == placeType ][0] singleCapacity = placeConfig['capacity'] currentPopulation = sum( [len(place.currentPeople) for place in currentPlaces]) + len(people) number_newPlaceRequired = math.ceil( currentPopulation / (singleCapacity * 0.75)) - len(currentPlaces) if number_newPlaceRequired > 0: # create new places currentPlaces += [ Place(placeConfig) for _ in range(number_newPlaceRequired) ] allocation = self.randomlyAllocate(people, currentPlaces) for place, person in allocation: place.addPerson(person) person.currentPlace = place
def test_removing_place(self): self.db.add_place(1, Place("Good restaurant", 65.13, 66.14)) self.db.add_place(1, Place("Very Good restaurant", 62.12, 66.14)) self.db.add_place(2, Place("Very Good restaurant", 62.12, 66.14)) self.db.remove_place(1, Place("Very Good restaurant", 62.12, 66.14)) places = self.db.get_places(1) self.assertIn(Place("Good restaurant", 65.13, 66.14), places) self.assertNotIn(Place("Very Good restaurant", 62.12, 66.14), places) self.assertIn(Place("Very Good restaurant", 62.12, 66.14), self.db.get_places(2))
def __init__(self, **kwargs): pygame.init() self.screen_info = pygame.display.Info() self.screen_size = kwargs.get("screen_size", (0, 0)) self.resizable = kwargs.get("resizable", True) if self.resizable: self.screen = pygame.display.set_mode(self.screen_size, RESIZABLE) else: self.screen = pygame.display.set_mode(self.screen_size) self.rect = Rect((0, 0), self.screen.get_size()) self.layout = kwargs.get("layout", None) if self.layout == "grid": Grid.__init__(self) self.layout = Grid elif self.layout == "flow": Flow.__init__(self) self.layout = Flow elif self.layout == "place" or self.layout is None: Place.__init__(self) self.layout = Place self.fullscreen = kwargs.get("fullscreen", False) self.last_screen_size = self.rect.size
def simulatedAnnealing(data, hotel, maxIterations=10): finalBestOrdering = {} finalBestTime = 0 hotelObj = Place(None, None, None, None, None) hotelObj.pos = hotel for key in data: if len(data[key]) == 0: finalBestOrdering[key] = data[key] continue elif len(data[key]) == 1: finalBestOrdering[key] = data[key] finalBestTime += getTime([hotelObj] + [data[key][0]]) + getTime([data[key][0]] + [hotelObj]) continue curr = [hotelObj] + data[key] + [hotelObj] bestOrdering = curr bestTime = getTime(curr) for i in range(maxIterations): curr = randomizeOrdering(curr) val = getTime(curr) if val < bestTime: bestTime = val bestOrdering = curr else: rand = random.random() if rand < temperature(i): bestTime = val bestOrdering = curr finalBestOrdering[key] = bestOrdering[1:-1] finalBestTime += bestTime return finalBestOrdering, finalBestTime
def __init__(self, loader, parentFSM, doneEvent): self.parentFSM = parentFSM Place.__init__(self, loader, doneEvent) self.fsm = ClassicFSM('Street', [State('start', self.enterStart, self.exitStart, ['walk', 'doorOut', 'teleportIn', 'tunnelOut']), State('walk', self.enterWalk, self.exitWalk, ['stop', 'tunnelIn', 'shtickerBook', 'teleportOut']), State('shtickerBook', self.enterShtickerBook, self.exitShtickerBook, ['teleportOut', 'walk']), State('teleportOut', self.enterTeleportOut, self.exitTeleportOut, ['teleportIn', 'stop']), State('tunnelOut', self.enterTunnelOut, self.exitTunnelOut, ['walk']), State('tunnelIn', self.enterTunnelIn, self.exitTunnelIn, ['stop']), State('stop', self.enterStop, self.exitStop, ['walk', 'died', 'teleportOut', 'doorIn']), State('doorIn', self.enterDoorIn, self.exitDoorIn, ['stop']), State('doorOut', self.enterDoorOut, self.exitDoorOut, ['walk']), State('teleportIn', self.enterTeleportIn, self.exitTeleportIn, ['walk', 'stop']), State('final', self.enterFinal, self.exitFinal, ['final'])], 'start', 'final')
def run_tests(): """Test PlaceCollection class.""" # Test empty PlaceCollection (defaults) print("Test empty PlaceCollection:") place_collection = PlaceCollection() print(place_collection) assert not place_collection.file_places # an empty list is considered False # Test loading places print("Test loading places:") place_collection.load_places('places.csv') print(place_collection) assert place_collection.file_places # assuming CSV file is non-empty, non-empty list is considered True # Test adding a new Place with values print("Test adding new place:") place_collection.add_place(Place("Smithfield", "Australia", 5, False)) print(place_collection) # Test sorting places print("Test sorting - priority:") place_collection.sort("priority") print(place_collection) # TODO: Add more sorting tests place_collection.sort("country") print(place_collection) # TODO: Test saving places (check CSV file manually to see results) place_collection.save_places() print(place_collection) place_collection.add_place(Place("Townsville", "Australia", 7, True)) print(f"Updated: {place_collection}") # TODO: Add more tests, as appropriate, for each method print(place_collection.total_unvisited_places())
def getGeo(s): s.lat = None s.lon = None s.place_id = None s.place = None s.geo_type = "not" if 'place' in s.json and s.json['place'] is not None: s.geo_type = 'place' s.place_id = s.json['place']['id'] s.place = Place(s.place_id) s.place.loadJSON(s.json['place']) if 'coordinates' in s.json and s.json['coordinates'] is not None: s.geo_type = 'precise' s.lat = s.json['coordinates']['coordinates'][1] s.lon = s.json['coordinates']['coordinates'][0]
def query_potential_locations(self, center_lat, center_lon, interests = ["FOOD_BEVERAGE"], categories = ['ARTS_ENTERTAINMENT','SHOPPING_RETAIL'], num_locations=50, dist=500): ''' Queries num_locations near the center (lat, lon) using Facebook Places API_KEY ''' center = center_lat + ", " + center_lon API_KEY = "MyhhJX525dvRwSUWpKHNOTKDjJaK59WX" access_token = "2210087485905915|vSCL_c4XqrU_ABMFWOdzbyhh_jk" FB_URL = "https://graph.facebook.com/search?type=place" cat = 'FOOD_BEVERAGE' FB_PARAMS = {'categories' : str([cat]), \ 'fields': ['name,checkins,overall_star_rating,location, category_list, price_range'], \ 'center': center, \ 'distance': 2000, \ 'access_token': access_token} res = requests.get(url = FB_URL, params = FB_PARAMS) all_locations = res.json()['data'] all_locations.sort(key = lambda place: -place['checkins']) attractions_with_rating = [a for a in all_locations if 'overall_star_rating' in a] places = [] attractions = [] price_mapping = {"$": 10, "$$": 20, "$$$": 40, "$$$$": 200, "Unspecified": 15} for category in categories: FB_PARAMS = {'categories' : str([category]), \ 'fields': ['name,checkins,overall_star_rating,location, price_range'], \ 'center': center, \ 'distance': 2000, \ 'access_token': access_token} res = requests.get(url = FB_URL, params = FB_PARAMS) all_locations = res.json()['data'] all_locations.sort(key = lambda place: -place['checkins']) attractions_with_rating = [a for a in all_locations if 'overall_star_rating' in a] for attraction in attractions_with_rating: if 'price_range' in attraction.keys(): price = price_mapping[str(attraction['price_range'])] else: price = 10 place = \ Place(attraction["name"], \ attraction["location"]["latitude"], \ attraction["location"]["longitude"], \ attraction, attraction["checkins"], \ attraction["overall_star_rating"], category, price) places.append(place) filtered_places = self.filter_user_interests(interests, places) #need to get user input return filtered_places[:num_locations]
def searchTweetById(dbm, tweetID): """Regresa un objeto Tweet para la id buscada""" tweetRes = Tweet(dbm) if dbm is not None: res = dbm.runQuery("SELECT tweetID, from_user_id, tweet, created_at, placeId, source, favorite_count, coordinates, userId, geo, lang, filter_level, in_reply_to_status_id_str FROM Tweets WHERE tweetID={}".format(tweetID)) try: if res is not None: row = res[0] tweetRes.set(tweetID = row[0], from_user = User.searchUserById(dbm, row[1]), tweet = row[2], created_at = row[3], place = Place.searchPlaceById(dbm, row[4]), source = row[5], favorite_count = row[6], coordinates = row[7], geo = row[9], lang = row[10], filter_level = row[11], in_reply_to_status_id_str = row[12]) except: pass return tweetRes else: raise Exception("No DBM declared")
def press_add(self, name_input, country_input, priority_input): # if any text_input boxes on app.kv are empty, display message if self.root.ids.name_input.text == '' or self.root.ids.country_input.text == '' or self.root.ids.priority_input.text == '': self.root.ids.location_clicked_status.text = "All fields must be completed" # if priority input is less than 0, display message elif int(self.root.ids.priority_input.text) < 0: self.root.ids.location_clicked_status.text = "Priority must be > 0" else: # append new entry to main list and create widget place = Place(name_input, country_input, priority_input, False) location_button = Button(text=str(place)) location_button.place = place location_button.bind(on_release=self.press_entry) self.root.ids.locations_box.add_widget(location_button) self.place_collection.add_place(place)
def getAllTweets(dbm): """Regresa una lista de objetos Tweet con todos los elementos de la tabla""" allTweets = [] if dbm is not None: res = dbm.runQuery("SELECT tweetID, from_user_id, tweet, created_at, placeId, source, favorite_count, coordinates, userId, \ geo, lang, filter_level, in_reply_to_status_id_str FROM Tweets") for row in res: tweetRes = Tweet() tweetRes.set(tweetID = row[0], from_user = User.searchUserById(dbm, row[1]), tweet = row[2], created_at = row[3], place = Place.searchPlaceById(dbm, row[4]), source = row[5], favorite_count = row[6], coordinates = row[7], geo = row[9], lang = row[10], filter_level = row[11], in_reply_to_status_id_str = row[12]) tweetRes.dbm = dbm allTweets.append(tweetRes) return allTweets else: raise Exception("No DBM declared")
def save(): nazwa = nazwa_input.get() opis = opis_input.get(1.0, END) miasto = miasto_input.get() adres = adres_input.get() fb = fb_input.get() ig = ig_input.get() email = email_input.get() tel = tel_input.get() web = web_input.get() if fb and nazwa and miasto and adres: place = Place(nazwa, opis, miasto, adres, fb, ig, email, tel, web) Ins.insert(place, inserter) else: fb_input.delete(0, END) fb_input.insert(INSERT, "Brak inforamcji.")
def init_graph(self): # read venue (node) data # node_data = {} self.pos_dict = { } # will be used to draw the nodes in the graph with geographic topology for l in open('./shared_data/newyork_anon_locationData_newcrawl.txt'): splits = l.split('*;*') venue_id = int(splits[0]) venue_info = eval(splits[1]) # add place to graph self.NYC_graph.add_node(venue_id) self.NYC_graph.nodes[venue_id][ 'info'] = venue_info # (40.760265, -73.989105, 'Italian', '217', '291', 'Ristorante Da Rosina') # initialise placee and within place, population information self.places[venue_id] = Place(venue_info) # this will be used for drawing the network self.pos_dict[venue_id] = (venue_info[1], venue_info[0])
def gen_specified_locations(self, user_locs): """ Generate data for a list of user specified locations of interests, which will be combined with the generic list of attractions. Will be passed into k-means. """ API_KEY = "AIzaSyC2Sixwd61MWgbL6qxCrX1JTAEotj5RWDs" URL = "https://maps.googleapis.com/maps/api/place/findplacefromtext/json?" #change output and parameters fields = 'name,rating,geometry,formatted_address' places = [] for l in user_locs: r = requests.get(URL + 'input=' + l + \ '&inputtype=textquery' + '&fields=' + fields + \ '&key=' + API_KEY) attraction = r.json()['candidates'][0] place = \ Place(attraction["name"], \ attraction["geometry"]["location"]["lat"], \ attraction["geometry"]["location"]["lng"], \ attraction, attraction['formatted_address']) places.append(place) return places
def __init__(self, name='no name', logger=logging, time=0.0, withoutTime=False, withoutPriority=False, tokName=None, exit=False): TimeNode.__init__(name=name, logger=logger, time=time) Place.__init__(self, name=name, logger=logger, withoutPriority=withoutPriority, tokName=tokName, exit=exit) self.withoutTime = withoutTime """ If True, the token arriving on this place have to reinitialize
def load(self): Place.load(self) self.parentFSM.getStateNamed('street').addChild(self.fsm)
def __init__(self, parent, **kwargs): Widget.__init__(parent) Place.__init__()
from Place import Place from Being import Being as Being from Atom import Atom as Atom from InternalMind import InternalMind as InternalMind from ExternalMind import ExternalMind as ExternalMind from Eye import Eye as Eye # Being : nom, dictin, size, elasticity, visibility, opacity, mind world = Place('world', { 'dark room': Place('dark room', { 'goblin': Being('goblin', { 'body': Atom("body", 5, 5, 0, 5, 0) }, 5, 20, 10, 10, InternalMind(1)), 'cell': Place('cell', { 'rat': Being('rat', {'body': Atom("body", 5, 5, 0, 5, 0)}, 5, 20, 10, 10, InternalMind(1)), 'you': Being('you', {'eye': Eye('eye', 1, 1, 0, 1, 0), 'body': Atom("body", 9, 10, 1, 10, 1)}, 10, 20, 10, 7, ExternalMind()), 'rock': Atom('rock', 1, 10, 1, 10, 10) }, 100, 10, 0) }, 300, 10, 10) }, 1000000000000, 0, 0) you = world.lookfor('you') while you.act(world) != 'sleep': pass