def get_location_data(lat, lon):

    # Nominatim takes combined lat and lon in one argument
    input_location = str(lat + ', ' + lon)

    # user_agent can be any email address
    geolocator = Nominatim(user_agent="*****@*****.**")

    # actual call to get location data
    location = geolocator.reverse(input_location)

    # the location includes a ton of data - getting the raw data to provide
    # more generic information
    address = location.raw['address']
    display_location = ", ".join([
        address.get('city', ''),
        address.get('state', ''),
        address.get('country', '')
    ])

    # timezone processing requires lat and lon to be separate floats, though
    latitude, longitude = float(lat), float(lon)
    tz = pytz.timezone(TimezoneFinder().timezone_at(lng=longitude,
                                                    lat=latitude))

    return display_location, tz
예제 #2
0
def coordi(message):
    if message.text == 'Get location':
        x = round(uniform(51.262, 56.172), 4)
        y = round(uniform(23.178, 32.777), 4)
        x, y = str(x), str(y)
        coord = '{},{}'.format(x, y)
        geolocator = Nominatim(user_agent='geobot')
        location = geolocator.reverse(coord)
        r = location.raw
        adr = r.get('address')
        cc = adr.get('country_code')
        loc = location.address
        dist = distance.distance(MINSK, coord)
        dist = str(dist)
        dist = dist.split(' ')
        dist = round(float(dist[0]), 2)
        dist = 'Distance between Minsk and this place: {} km.\nIf you want to know distance between you and this place ' \
            'send your location to bot'.format(dist)
        link = 'https://www.google.com/maps/place/{}'.format(coord)
        if cc == 'by':
            place.clear()
            place.append(coord)
            bot.send_message(message.chat.id,
                             "Why don't you go to:\n{}".format(loc))
            bot.send_message(message.chat.id, link)
            bot.send_message(message.chat.id, dist)
        else:
            print('None BY')
            coordi(message)
예제 #3
0
    def create(self, validated_data):
        print(validated_data)
        geolocator = Nominatim()
        # location_id = int(validated_data.pop('location_id', None))
        lng = validated_data.pop('lng', None)
        lat = validated_data.pop('lat', None)
        street_address = validated_data.pop('street_address', None)
        #owner_id = int(validated_data.pop('user_id', None))

        if lat > 0:
            location = geolocator.reverse("{}, {}".format(lng, lat))
            street_address = location.address
            street_address = street_address.split(', ')[0] + ", " + street_address.split(', ')[1]
            print(street_address)
        else:
            location = geolocator.geocode(street_address)
            lat = location.latitude
            lng = location.longitude

        data = {'lat': lat, 'lng': lng, 'street_address': street_address}
        location = Location.objects.create(**data)

        # limitations_serializer = LimitationSerializer(data={'authority_id':10,'reason':'smth','location_id':location._get_pk_val()}, many=True)
        # print(limitations_serializer.initial_data)
        #
        # if limitations_serializer.is_valid():
        #
        #     print(1)
        #     limitations = limitations_serializer.save()
        #     print(limitations)
        # else:
        #     print(limitations_serializer.errors)
        #     #limitations_data = self.context.get('view').request.FILES
        # print(limitations.__dir__)
        return location
예제 #4
0
def recover_adress(df, year):
    locator = Nominatim(user_agent="myGeocoder")
    address_dict = {}
    add = []
    for latitude, longitude in df[df["address_known"] == False][[
            "latitude", "longitude"
    ]].itertuples(index=False):
        if not math.isnan(latitude):
            add.append((latitude, longitude))
    add = set(add)
    with tqdm(total=len(add)) as bar:
        for latitude, longitude in add:
            bar.set_description(
                f"processing addresses lat={str(latitude)}, lon={longitude}")
            try:
                addresse = str(latitude) + ", " + str(longitude)
                address_dict[(latitude, longitude)] = locator.reverse(addresse)
            except Exception as e:
                print(
                    "Could not find addresse for coordinates ",
                    str(latitude),
                    str(longitude),
                    e,
                )
            bar.update(1)
    for k, v in address_dict.items():
        try:
            address_dict[k] = v.raw
        except:
            print("There was an issue with:", k, v)
    with open(f"address_{year}.pickle", "wb") as f:
        pickle.dump(address_dict, f)
    return address_dict
 def getAlpha2Countries(self):
     geolocator = Nominatim(timeout=60)
     for location in self.locations:
         geo = geolocator.geocode(location)
         if geo is not None:
             loc = geolocator.reverse("{}, {}".format(
                 geo.latitude, geo.longitude))
             self.alpha2Countries.append(
                 loc.raw['address']['country_code'].upper())
def get_city_on_coord(lat, lon):
    geolocator = Nominatim(user_agent='test/1')
    location = geolocator.reverse(f'{lat},{lon}', language='en')
    loc_dict = location.raw

    if 'city' in loc_dict['address'].keys():
        return loc_dict['address']['city']
    else:
        return loc_dict['address']['municipality']
예제 #7
0
def coordi(message):
    if message.text == 'Куда отправиться?':  # случайные координаты в приблизительных границах Беларуси
        lon = round(uniform(51.262, 56.172), 4)
        lat = round(uniform(23.178, 32.777), 4)
        lon, lat = str(lon), str(lat)
        coord = '{},{}'.format(lon, lat)
        geolocator = Nominatim(user_agent='geobot')
        location = geolocator.reverse(
            coord)  # получаем место на карте по координатам
        r = location.raw  # получаем json
        adr = r.get('address')  # из json берем адрес
        cc = adr.get('country_code')  # из адреса берем код страны
        if cc == 'by':
            place.clear()
            loc = location.address  # строка с человекочитаемым адресом
            place.append(coord)  # переписываем значение координат места
            place.append(loc)
            dist = distance.distance(
                MINSK, coord)  # вычисление расстояния между Минском и адресом
            dist = str(dist)
            dist = dist.split(' ')
            dist = round(float(dist[0]), 2)  # округленное значение расстояния
            dist = 'Растояние от Октябрьской площади Минска до этого места: {} km.\nЧто бы узнать расстояние от ' \
                   'твоего местонахождения до {} пришли боту свою геолокацию или проложи свой маршрут с ' \
                   'использованием одного из сервисов'.format(dist, loc.split(',')[0])
            links.clear()
            links.append(
                'Это место на картах Google":\nhttps://www.google.com/maps/place/{}'
                .format(coord))
            links.append(
                'Это место на картах Yandex:\nhttps://yandex.com/maps/?text={}'
                .format(coord))
            links.append(
                'Это место на картах архитектурного наследия Беларуси:\nhttps://orda.of.by/.map/?{}'
                .format(coord))
            links.append(
                'Это место на картах MapsMe:\nmaps.google.com/{}'.format(
                    coord))
            keyboard = telebot.types.InlineKeyboardMarkup()
            key_ya = telebot.types.InlineKeyboardButton(text='Yandex',
                                                        callback_data='ya')
            key_gg = telebot.types.InlineKeyboardButton(text='Google',
                                                        callback_data='gg')
            key_globus = telebot.types.InlineKeyboardButton(
                text='карты Globus.tut.by', callback_data='globus')
            key_maps = telebot.types.InlineKeyboardButton(
                text='приложение Maps.me', callback_data='maps')
            keyboard.add(key_ya, key_gg)
            keyboard.add(key_globus, key_maps)
            bot.send_message(message.chat.id,
                             "Почему бы сегодня не отправится:\n{}".format(
                                 loc))  #.split(',')[0]))
            bot.send_message(message.chat.id, dist, reply_markup=keyboard)
        else:
            print('None BY')
            coordi(message)
예제 #8
0
def get_content(lon=None, lat=None):
    log.info(f"Pharmacy map creator started [{lon}][{lat}]")

    locator = Nominatim(user_agent='bot')
    radius = 1000

    # read full dataset
    raw = requests.get(
        "http://overpass-api.de/api/interpreter?data=<query type='node'><around lat='"
        + str(lat) + "' lon='" + str(lon) + "' radius='" + str(radius) +
        "'/></query><print/>").text

    data = BeautifulSoup(raw, features='xml')
    pharmacies = data.find_all('tag', {'k': 'amenity', 'v': 'pharmacy'})

    address = pd.Series([
        locator.reverse((pharmacy.parent['lat'], pharmacy.parent['lon']),
                        timeout=10000).address for pharmacy in pharmacies
    ],
                        dtype=str)
    latitude = pd.Series([pharmacy.parent['lat'] for pharmacy in pharmacies],
                         dtype=float)
    longitude = pd.Series([pharmacy.parent['lon'] for pharmacy in pharmacies],
                          dtype=float)

    data = pd.DataFrame({
        'address': address,
        'latitude': latitude,
        'longitude': longitude
    })
    data['distance'] = data.apply(lambda row: geopy.distance.distance(
        (row['latitude'], row['longitude']), (lat, lon)).km,
                                  axis=1)
    # getting area borders
    min_lat = data['latitude'].min()
    max_lat = data['latitude'].max()
    min_lon = data['longitude'].min()
    max_lon = data['longitude'].max()

    data = data.sort_values(by=['distance'])
    message = f"Ближайшие аптеки в радиусе {radius} метров \r\n \r\n"
    for index, point in data.head(min(10, len(data))).iterrows():
        message += f"⚕ [{round(point['distance'], 2)} км] {point['address']} \r\n"

    return map_extension.save_plot(log,
                                   data,
                                   min_lat,
                                   max_lat,
                                   min_lon,
                                   max_lon,
                                   pt_color='#00EB62FF',
                                   pt_size=1000,
                                   user_lat=lat,
                                   user_lon=lon), message
예제 #9
0
def set_city(df):
    geolocator = Nominatim(user_agent = 'test_1')
    cor = (df['lat'],df['lon'])
    location = geolocator.reverse(cor)
    address = location.raw['address']
    df['address'] = address
    try:
        df['city'] = address['city']
    except KeyError:
        df['city'] = "Null"
    return df
예제 #10
0
 def country(self, obj):
     """returns the country of the last recorded location for driver"""
     longitude = obj.live_location_longitude
     latitude = obj.live_location_latitude
     geolocator = Nominatim()
     try:
         location = geolocator.reverse("{}, {}".format(longitude, latitude),
                                       language='en')
         return location.raw.get('address', {}).get('country', '')
     except Exception:
         return ''
예제 #11
0
def get_geo_node(lat, lon):
    geolocator = Nominatim(user_agent="pieters-data-gatherer", timeout=2)
    geo_name = "%.6f, %.6f" % (lat, lon)
    location = geolocator.reverse(geo_name).raw
    address = location.get('address')

    geo = GeoCoordinate.get_or_create({
        "name": geo_name,
        "lat": lat,
        "lon": lon
    })[0]
    if address is not None and 'house_number' in address:
        country = Country.get_or_create({'name': address['country']})[0]

        states = country.states.filter(name=address['state']).all()
        if len(states) > 0:
            state = states[0]
        else:
            state = State(name=address['state']).save()
            country.states.connect(state)

        town_name = dict_get_first(address, ['town', 'city', 'village'])
        towns = state.towns.filter(name=town_name).all()
        if len(towns) > 0:
            town = towns[0]
        else:
            town = Town(name=town_name).save()
            state.towns.connect(town)

        road_name = dict_get_first(
            address, ['road', 'footway', 'pedestrian', 'cycleway', 'path'])
        roads = town.roads.filter(name=road_name).all()
        if len(roads) > 0:
            road = roads[0]
        else:
            try:
                road = Road(name=road_name).save()
                town.roads.connect(road)
            except:
                print(road_name)

        house_numbers = road.house_numbers.filter(
            name=address['house_number']).all()
        if len(house_numbers) > 0:
            house_number = house_numbers[0]
        else:
            house_number = HouseNumber(name=address['house_number']).save()
            road.house_numbers.connect(house_number)

        house_number.geos.connect(geo)

    return geo
예제 #12
0
 def doAction(self,r,sr,words,sensorList):
     os.system("espeak -s 120 'searching'")
     lastFix = sensorList['location'].getLastData()
     if lastFix["lastFix"] == None:
         return "I don't know where you are"
     if("how high up" in words or "altitude" in words):
         return "you are " + str(int(float(lastFix["lastFix"]["alt"]))) + " meters up."
     geoloc = Nominatim()
     coor = str(lastFix["lastFix"]['lat'])+", "+str(lastFix["lastFix"]['lon'])
     loc = geoloc.reverse(coor,timeout=10)
     loc1 = loc.address.split(", ")
     del loc1[-4:]
     return "you are at " + str(loc1)
예제 #13
0
def add_country_and_city(sender, **kwargs):
    """The receiver called before a user address is saved
    to get the country and city from location coordinates"""

    address = kwargs['instance']
    longitude = address.location_longitude
    latitude = address.location_latitude
    geolocator = Nominatim()
    try:
        location = geolocator.reverse("{}, {}".format(longitude, latitude),
                                      language='en')
        address.country = location.raw.get('address', {}).get('country', '')
        address.city = location.raw.get('address', {}).get(
            'state', '') or location.raw.get('address', {}).get('city', '')
    except GeocoderTimedOut:
        return add_country_and_city(sender, **kwargs)  # recursion
    except Exception:
        pass
예제 #14
0
 def doAction(self,r,sr,words,sensorList):
     if "how's the weather in" in words:
         location =  words.split("how's the weather in")[-1].strip(" ")
     else:
         os.system("espeak -s 120 'searching'")
         lastFix = sensorList['location'].getLastData()
         if lastFix["lastFix"] == None:
             return "I don't know where you are"
         geoloc = Nominatim()
         coor = str(lastFix["lastFix"]['lat'])+", "+str(lastFix["lastFix"]['lon'])
         loc = geoloc.reverse(coor,timeout=10)
         loc1 = loc.address
         location = loc1.split(", ")[-2]
     location = pywapi.get_location_ids(location)
     if len(location) == 0:
         return "location not found"
     locationId = next (iter (location.keys()))
     w = pywapi.get_weather_from_weather_com(locationId, units="imperial")
     return "It is " + w["current_conditions"]["temperature"] + "degrees and " + w["current_conditions"]["text"]
예제 #15
0
    def nearby(current_user_position=None):

        cordinat = request.args.get('data')
        geolocator = Nominatim(user_agent="jual_ikan")
        location = geolocator.reverse(cordinat)
        get_json_value = location.raw
        get_state_name = get_json_value['address']['state']

        # current_user_position = get_state_name
        current_user_position = 'Sumatera Selatan'

        urutan_ikan_dalam_tampilan_halamanerr = db.session.query(
            Ikan.id_ikan, Ikan.nama_ikan, Ikan.berat_ikan_dalam_Kg,
            Ikan.foto_ikan, Penjual).join(Penjual).filter(
                Penjual.domisili == current_user_position)

        return render_template("nearby_places.html",
                               IKANS=urutan_ikan_dalam_tampilan_halamanerr,
                               STATE=get_state_name)
예제 #16
0
def transform_zip(next_crime_raw):
    geolocator = Nominatim()
    location = geolocator.reverse(str(str(next_crime_raw['lat']) + ", " + str(next_crime_raw['lon'])))
    zip = location.raw['address']['postcode']
    location = geolocator.geocode(str(zip))
    boundingbox = location.raw['boundingbox']
    maxlat = float(boundingbox[1])
    minlat = float(boundingbox[0])
    maxlng = float(boundingbox[3])
    minlng = float(boundingbox[2])
    meanlat = (maxlat + minlat) / 2
    meanlng = (maxlng + minlng) / 2

    try:
        zip = re.search('^787d{2}$', zip).group(1)
        print('zip: ' + str(zip))
    except Exception:
        pass

    return Zip(zip_code=zip, lat=meanlat, lng=meanlng, pop=20000, family_income=50000)
예제 #17
0
    def get_location(self, latitude, longitude):

        # Nominatim takes combined lat and lon in one argument
        input_location = str(latitude + ', ' + longitude)

        # user_agent can be any email address
        geolocator = Nominatim(user_agent="*****@*****.**")

        # actual call to get location data
        location = geolocator.reverse(input_location)

        # the location includes a ton of data - getting the raw data to provide
        # more generic information
        address = location.raw['address']
        address_list = [
            address.get('city', ''),
            address.get('state', ''),
            address.get('country', '')
        ]

        display_location = ", ".join(filter(None, address_list))

        return display_location
예제 #18
0
def coordi(message):
    if message.text == 'Get location':
        x = round(uniform(51.262, 56.172), 4)
        y = round(uniform(23.178, 32.777), 4)
        x, y = str(x), str(y)
        coord = '{},{}'.format(x, y)
        geolocator = Nominatim(user_agent='geobot')
        location = geolocator.reverse(coord)
        r = location.raw
        adr = r.get('address')
        cc = adr.get('country_code')
        loc = location.address
        dist = distance.distance(MYPLACE, coord)
        dist = str(dist)
        dist = 'Distance from Minsk to this place: {} km'.format(dist[0:3:])
        link = 'https://www.google.com/maps/place/{}'.format(coord)
        if cc == 'by':
            bot.send_message(message.chat.id, loc)
            bot.send_message(message.chat.id, link)
            bot.send_message(message.chat.id, dist)
        else:
            print('None BY')
            coordi(message)
예제 #19
0
        print("SLEEP " + str(secs))
        time.sleep(secs)
    print("GEOCODING LOCATION:  " + str(counter))
    address = data.iloc[row]
    print(address)
    #print(address.to_string())
    locator = Nominatim(user_agent="myGeocoder")
    #geocode = RateLimiter(locator.geocode, min_delay_seconds=2)
    try:
        #location = address.apply(geocode)
        location = locator.geocode(address, timeout=30)
        print(location.raw)
        latitude = location.latitude
        longitude = location.longitude

        location = locator.reverse([latitude, longitude])

        display_name = location.raw['display_name']
        print(display_name)
        country = location.raw['address']['country']
        country_code = location.raw['address']['country_code']

    except AttributeError:

        latitude = None
        longitude = None

    except KeyError:
        country = None
        country_code = None
    except NameError:
예제 #20
0
파일: location.py 프로젝트: jami3/pictorial
def get_geo_location(lat, long):
    geo = Nominatim()
    string = "{0} , {1}".format(lat, long)
    geo_location = geo.reverse(string, timeout=5)

    return geo_location.address
예제 #21
0
# Converting coordinates to geographical locations

# pip install geopy

from geopy import Nominatim

lat = float(input('Enter lattitude : '))
lon = float(input('Enter longitude : '))

coord = (lat, lon)
# [Example] coord = (26.8393,80.9231)

try:
    geolocator = Nominatim(user_agent='test/1')
    location = geolocator.reverse(f'{coord[0]},{coord[1]}')
    print('Based on entered coordinates, the location is :', location.address)
except:
    print('looks like you are not connected with internet')
    print('or given coordinates may be wrong')
PAYMENTS_CSV_PATH = '~/Downloads/payments.csv'

columns = ['id', 'Card Address Country', 'Card Address City']
df = pd.read_csv(PAYMENTS_CSV_PATH, encoding="ISO-8859-1")[columns].set_index('id')
geolocator = Nominatim()

for reg in models.Registration.query.all():
    order = models.Order.query.join(models.OrderProduct, aliased=False). \
        join(models.order_product_registrations_mapping, aliased=False). \
        filter_by(registration_id=reg.id).first()
    if order and order.payments:
        for payments in order.payments:
            if payments.stripe_charge_id in df.index:
                location_str = ' '.join(list(df.loc[payments.stripe_charge_id].dropna().values))
                # print(reg.name, '-', location_str)
                geolocator_reverse_data = geolocator.reverse(geolocator.geocode(location_str).point, language='en')
                city = geolocator_reverse_data.raw['address'].get('city')
                if not city:
                    city = geolocator_reverse_data.raw['address'].get('town')
                if not city:
                    city = geolocator_reverse_data.raw['address'].get('village')
                if not city:
                    city = geolocator_reverse_data.raw['address'].get('county')

                state = geolocator_reverse_data.raw['address'].get('state')
                country = geolocator_reverse_data.raw['address']['country']
                print(reg.name, '-', country, '-', state, '-', city)
                # print(geolocator_reverse_data.raw['address'])
                reg.country = country
                reg.state = state
                reg.city = city
예제 #23
0
    def generateMap(self,
                    tiles,
                    map_zoom_start=6,
                    heatmap_radius=7,
                    heatmap_blur=4,
                    heatmap_min_opacity=0.2,
                    heatmap_max_zoom=4):

        map_data = [(coords[0], coords[1], magnitude)
                    for coords, magnitude in self.coordinates.items()]

        map_data_with_year = [
            (coords[0], coords[1], magnitude, coords[2])
            for coords, magnitude in self.coordinates.items()
        ]

        df_data = pd.DataFrame(map_data_with_year,
                               columns=['Lat', 'Long', 'Weight', 'Year'])

        year_list = df_data.Year.sort_values().unique()

        map_data_by_year = []
        for year in year_list:
            map_data_by_year.append(
                df_data.loc[df_data.Year == year,
                            ['Lat', 'Long', 'Weight']].groupby(
                                ['Lat',
                                 'Long']).sum().reset_index().values.tolist())

        # Generate map
        m = folium.Map(location=self.max_coordinates,
                       zoom_start=map_zoom_start,
                       tiles=tiles)

        world_imagery = "https://server.arcgisonline.com/ArcGIS/rest/services/World_Imagery/MapServer/tile/{z}/{y}/{x}"

        folium.TileLayer(
            tiles=world_imagery,
            name="World Imagery",
            attr=
            'Tiles &copy; Esri &mdash; Source: Esri, i-cubed, USDA, USGS, AEX, GeoEye, Getmapping, Aerogrid, IGN, IGP, UPR-EGP, and the GIS User Community'
        ).add_to(m)
        folium.TileLayer(tiles='Stamen Terrain',
                         name='Stamen Terrain').add_to(m)
        folium.TileLayer('cartodbdark_matter', name='Dark Matter').add_to(m)

        # Generate heat map

        heatmap = HeatMap(
            map_data,
            max_val=self.max_magnitude,
            min_opacity=heatmap_min_opacity,
            radius=heatmap_radius,
            blur=heatmap_blur,
            max_zoom=heatmap_max_zoom).add_to(
                folium.FeatureGroup(name="Combined HeatMap").add_to(m))

        locator = Nominatim(user_agent="geocoder", timeout=None)

        timesVisited = [x[2] for x in map_data]
        timesVisited.sort(reverse=True)
        top20Visited = timesVisited[19]

        marker_group = folium.FeatureGroup(name="Markers")
        mc = MarkerCluster()

        for lat, lon, freq in map_data:
            if freq >= top20Visited:
                coordinates = lat, lon
                location = locator.reverse(coordinates)

                times_visited = location.address + "\nVisited " + str(
                    freq) + " times"

                mc.add_child(
                    folium.Marker(location=[lat, lon], popup=times_visited))

        folium.plugins.HeatMapWithTime(map_data_by_year,
                                       name="HeatMap by Year",
                                       index=year_list.tolist(),
                                       min_opacity=heatmap_min_opacity,
                                       radius=heatmap_radius,
                                       gradient={
                                           0.2: 'blue',
                                           0.4: 'lime',
                                           0.6: 'orange',
                                           1: 'red'
                                       }).add_to(m)

        mc.add_to(marker_group)
        marker_group.add_to(m)

        folium.LayerControl().add_to(m)

        return m
예제 #24
0
def add():
    with open("extraction/other_crimes.out") as data_file:
        data = json.load(data_file)
    crime_data = iter(data['crimes'])
    for line in range(1):
        next_crime = next(crime_data)
        date = next_crime['date']
        date = date[:date.find('T')]
        converted_year = convert_year(date)
        converted_month = convert_month(date)
        converted_day = convert_day(date)
        #
        # next_crime_formatted = Crime(lat=next_crime['lat'], lng=next_crime['lon'], time=datetime.date(year=converted_year, month=converted_month, day=converted_day, address=next_crime['address'], description=next_crime['link'])
        # next_crime_type = CrimeType(name=next_crime['type'], desc='crimes are bad')
        geolocator = Nominatim()
        location = geolocator.reverse("30.25, -97.75")

        zip = location.raw['address']['postcode']

        location = geolocator.geocode(str(zip))
        boundingbox = location.raw['boundingbox']
        maxlat = float(boundingbox[1])
        minlat = float(boundingbox[0])
        maxlng = float(boundingbox[3])
        minlng = float(boundingbox[2])
        meanlat = (maxlat + minlat) / 2
        meanlng = (maxlng + minlng) / 2

        #next_zip = Zip(zip_code=zip, lat=meanlat, lng=meanlng)
        #next_week = Week(



    # crime_1 = Crime(lat=30.28500, lng=-97.7320000, time=datetime.date(year=2015, month=10, day=28), address="gdc", description="Graffiti of pig on building")
    # crime_2 = Crime(lat=30.30000, lng=-97.730000, time=datetime.date(year=2015, month=10, day=20), address="Duval Rd", description="Burglary at Quacks Bakery")
    # crime_3 = Crime(lat=30.27000, lng=-97.719000, time=datetime.date(year=2015, month=10, day=14), address="12th and Chicon", description="Murder on 12th and Chicon")
    crime_type_1 = CrimeType(name='Vandalism', desc = "Vandalism is bad")
    crime_type_2 = CrimeType(name='Burglary', desc = "Burglary is bad")
    crime_type_3 = CrimeType(name='Assault', desc = "Assault is bad")
    zip_1 = Zip(zip_code=78704, lat=32.123, lng=32.123, pop=20000, family_income=50000)
    zip_2 = Zip(zip_code=78705, lat=30.123, lng=30.123, pop=23000, family_income=30000)
    zip_3 = Zip(zip_code=78706, lat=35.123, lng=35.123, pop=19000, family_income=45000)
    week_1 = Week(start=datetime.date(year=2015, month=10, day=11), end=datetime.date(year=2015, month=10, day=17))
    week_2 = Week(start=datetime.date(year=2015, month=10, day=18), end=datetime.date(year=2015, month=10, day=24))
    week_3 = Week(start=datetime.date(year=2015, month=10, day=25), end=datetime.date(year=2015, month=10, day=31))

    #set up all of the foreign key relationships
    print("Crime one week: " + str(week_1.start))
    try:
        for crime in crimes:
            print('crime: ' + str(crime))
            # session.add()
        # session.add(crime_1)
        # session.add(crime_2)
        # session.add(crime_3)
        session.add(crime_type_1)
        session.add(crime_type_2)
        session.add(crime_type_3)
        session.add(zip_1)
        session.add(zip_2)
        session.add(zip_3)
        session.add(week_1)
        session.add(week_2)
        session.add(week_3)
        print("commiting to database")
        session.commit()
    except Exception as e:
        print(e)
        session.rollback()
        print("Everything broke")
예제 #25
0
파일: tasks.py 프로젝트: Agyolchu/geocoder
def coordinate_task(lat, long):
    """Coordinates -> Address."""
    locator = Nominatim(user_agent="geocoder_app")
    coordinate_address = locator.reverse(f"{lat}, {long}")
    return coordinate_address.raw
예제 #26
0
def usuario_login(token, token_fcm, latitude, longitude, fcm_type, movil):
    if latitude == '-1':
        latitud_registro = 41.683490
    else:
        latitud_registro = Decimal(latitude)

    if longitude == '-1':
        longitud_registro = -0.888479
    else:
        longitud_registro = Decimal(longitude)

    if token == 'nothing':
        return 'Error'
    else:
        try:
            user_info = auth.get_account_info(token)
            user_uid = user_info['users'][0]['localId']
            try:
                name = user_info['users'][0]['displayName']
                if name == '':
                    name = user_info['users'][0]['email'].split("@")[0]
            except:
                name = user_info['users'][0]['email'].split("@")[0]
            try:
                profile_image = user_info['users'][0]['providerUserInfo'][0][
                    'photoUrl']
            except:
                profile_image = 'https://www.iconsdb.com/icons/preview/black/book-xxl.png'
        except:
            print("Error con firebase en login social")
            return 'Error'
        try:
            geolocator = Nominatim(user_agent="bookalo")
            location = geolocator.reverse(
                str(latitud_registro) + ',' + str(longitud_registro))
            try:
                ciudad = location.raw['address']['city']
            except:
                ciudad = location.raw['address']['county']
        except:
            ciudad = 'Zaragoza'
        try:
            user = Usuario.objects.get(uid=user_uid)

            if user.esta_baneado:
                return status.HTTP_401_UNAUTHORIZED
            else:
                user.latitud_registro = latitud_registro
                user.longitud_registro = longitud_registro
                user.ciudad = ciudad
                user.save()
                update_last_connection(user)
                try:
                    if movil == 'true':
                        es_movil = True
                    else:
                        es_movil = False
                    sessions = Sesion.objects.filter(usuario=user)
                    if sessions:
                        for session in sessions:
                            if session_needs_deleting(session):
                                session.delete()
                        user = Usuario.objects.get(uid=user_uid)
                        try:
                            sesion = Sesion.objects.get(token_fcm=token_fcm,
                                                        usuario=user)
                            sesion.token = token
                            sesion.save()
                        except Exception as ex:
                            Sesion.objects.create(token=token,
                                                  token_fcm=token_fcm,
                                                  usuario=user,
                                                  es_movil=es_movil)
                    else:
                        try:
                            user = Usuario.objects.get(uid=user_uid)
                            Sesion.objects.create(token=token,
                                                  token_fcm=token_fcm,
                                                  usuario=user,
                                                  es_movil=es_movil)
                        except Exception as ex:
                            user = Usuario.objects.get(uid=user_uid)
                            Sesion.objects.create(token=token,
                                                  token_fcm=str(ex),
                                                  usuario=user,
                                                  es_movil=es_movil)
                except Exception as ex:
                    print("Error while looking for active sessions")
                return UserSerializer(user).data

        except Usuario.DoesNotExist:

            new_user_data = Usuario.objects.create(
                username=user_uid,
                uid=user_uid,
                token_fcm=token_fcm,
                nombre=name,
                latitud_registro=latitud_registro,
                longitud_registro=longitud_registro,
                imagen_perfil=profile_image,
                ciudad=ciudad)
            Sesion.objects.create(token=token,
                                  token_fcm=token_fcm,
                                  usuario=new_user_data)
            update_last_connection(new_user_data)
            return UserSerializer(new_user_data).data
예제 #27
0
 def set_location(self, coordinates):
     locator = Nominatim()
     self.location = locator.reverse(coordinates).address
예제 #28
0
print("[")

for tweet in cursor:
    place = tweet['place']
    coordinates = tweet['coordinates']
    location = None

    if coordinates != None:
        lon = coordinates['coordinates'][0]
        lat = coordinates['coordinates'][1]
        if -170 < lon < -60 and 12 < lat < 72:
            tries = 3
            while tries > 0:
                try:
                    time.sleep(1)
                    location = geolocator.reverse("%f, %f" % (lat, lon))
                    break
                except geopy.exc.GeocoderTimedOut:
                    time.sleep(1)
                    tries -= 1
                except geopy.exc.QuotaExceeded:
                    time.sleep(10)

    elif place != None:
        place_coordinates = place['bounding_box']['coordinates']
        lon = (float(place_coordinates[0][0][0]) +
               float(place_coordinates[0][1][0])) / 2
        lat = (float(place_coordinates[0][0][1]) +
               float(place_coordinates[0][2][1])) / 2
        if -170 < lon < -60 and 12 < lat < 72 and place[
                'country'] == "United States":
예제 #29
0
class Cave(Base):
    """ Cave class instance for storing caves to which belong images and hands

    """
    # Primary attributes
    name = Column(String(50))
    description = Column(String(200))
    latitude = Column(Float)
    longitude = Column(Float)
    project_id = Column(Integer, ForeignKey("projects.id"))

    # Secondary attributes (retrieved using geopy library)
    city = Column(String(50))
    town = Column(String(50))
    village = Column(String(50))
    suburb = Column(String(50))
    country = Column(String(50))
    country_code = Column(String(2))
    county = Column(String(50))
    state = Column(String(50))
    continent = Column(String(50))
    address = Column(String(200))

    # Relationships
    project = relationship("Project", back_populates="caves")
    images = relationship("Image",
                          order_by=Image.id,
                          back_populates="cave",
                          cascade="all, delete-orphan")

    def __init__(self, **kwargs):
        super().__init__(**kwargs)
        self.geolocator = Nominatim(user_agent="Kalimain")

        try:
            self.location = self.geolocator.reverse(
                "%f, %f" % (self.latitude, self.longitude))
        except GeocoderServiceError:
            warnings.warn(
                "Unable to reach service: only primary attributes will be set",
                ApiConnectionWarning)
        else:
            # Set secondary attributes
            self.get_secondary_attributes()

    def __eq__(self, other):
        if not isinstance(other, Cave):
            return False
        if self.latitude == other.latitude and self.longitude == other.longitude:
            return True
        else:
            return False

    def get_continent(self):
        if self.country is not None:
            continent_code = country_alpha2_to_continent_code(
                self.country_code.upper())
            return convert_continent_code_to_continent_name(continent_code)

    def get_secondary_attributes(self):
        self.address = self.location.raw["display_name"]

        for key, val in self.location.raw["address"].items():
            try:
                self.__setattr__(key, val)
            except AttributeError:
                pass

        self.continent = self.get_continent()
예제 #30
0
## add columns for output tables
locs['street_address'] = ""
locs['city'] = ""
locs['state'] = ""
locs['zipcode'] = np.nan

## fetch address data from lat and lon values
geolocator = Nominatim()
for i in range(locs.shape[0]):
    lat = locs.iloc[i]['latitude']
    lon = locs.iloc[i]['longitude']
    lat_lon = str(lat) + ', ' + str(lon)

    try:
        a_obj = geolocator.reverse(lat_lon)
    except:
        a_obj = geolocator.reverse(lat_lon)

    ## address components
    try:
        street_address = a_obj.raw['address'][
            'house_number'] + ' ' + a_obj.raw['address']['road']
    except:
        street_address = a_obj.address
    zipcode = a_obj.raw['address']['postcode']
    city = a_obj.raw['address']['city']
    state = a_obj.raw['address']['state']

    ## insert into dataframe
    locs['street_address'].iloc[i] = street_address
예제 #31
0

geolocator = Nominatim()
accidents = data['accidents']
# hood_info will store whatever we want to know about a given neighborhood
# ex: '
# {hood: [[incidents], total_incedents, severe, ...]
#  we can continue adding info to the dict
hood_info = defaultdict(list)
i = 0
for v in accidents:
    # if i == 50:
    #     break
    try:
        zippy = \
            geolocator.reverse(str(v['lat']) + ', ' + str(v['lng'])).raw['display_name'].split('Illinois')[1].split(
                ',')[1].replace(" ", "")
    except Exception:
        print('geolocator could not reverse.')
        i += 1
        continue

    if zippy not in zip_dict:
        print('zip:' + zippy + ' not in common neighborhoods')
        continue

    hood = zip_dict[zippy]  # the neighborhood name associated with a zip
    if hood in hood_info:
        hood_info[hood][0].append(v)
        hood_info[hood][1] += 1
    else:
        hood_info[hood] = [[v], 1, 0]
예제 #32
0
from geopy import Nominatim 
import json
import csv

locator = Nominatim(user_agent='myGeocoder')

with open("datasets\data-preview.csv",'r') as f:
    reader = csv.reader(f)
    addr = []
    for case in reader:
       if case[1] == 'US':
            if case[0] == "":
                next
            else:
                addr.append("\"{},{}\"".format(case[2],case[3]))

for place in addr:
    print(place)
    location = locator.reverse(place)
    
    print(location.raw)
    # print("Latitude = {}, Longitude = {}".format(location.latitude, location.longitude))

예제 #33
0
            pw.append(k.get('osmid'))
    except:  # to catch and skip noneType iterations
        continue

# DO NOT CHANGE TIMEOUT... THIS IS TO PREVENT YOUR IP FROM BEING BANNED
locator = Nominatim(user_agent="myGeocoder", timeout=30)

building = {}
autofillList = []
count = 0

# testing algorithmn speed
start_time = time.time()
for k in walkNodeList:
    coordinates = k.get('y'), k.get('x')
    location = locator.reverse(coordinates)
    k["address"] = location[0]
    print(count)
    count += 1
    if location[0] not in autofillList:
        print(location[0])
        autofillList.append(location[0])
    else:
        continue

for item in mrtNodeList:
    try:
        if "PE" in item.get('ref') or "PW" in item.get('ref'):
            coordinates = item.get('y'), item.get('x')
            location = locator.reverse(coordinates)
            autofillList.append(location[0])
예제 #34
0
def get_zip(next_crime_raw):
    geolocator = Nominatim()
    location = geolocator.reverse(str(str(next_crime_raw['lat']) + ", " + str(next_crime_raw['lon'])))
    return location.raw['address']['postcode']