def geo(request,city1,city2):
    context = RequestContext(request)

    citydata1=Geocoder.geocode(city1)
    codtuple1=citydata1[0].coordinates
    codtuple1=list(codtuple1)

    citydata2=Geocoder.geocode(city2)
    codtuple2=citydata2[0].coordinates
    codtuple2=list(codtuple2)

    #Calculate Distance
    lat1, lon1 = codtuple1
    lat2, lon2 = codtuple2
    R = 6371 #Earth's Radius in Kms.

    lat_diff_radians = math.radians(lat2-lat1)
    long_diff_radians = math.radians(lon2-lon1)
    #Haversine formula to calculate distance between a pair of cordinates
    a = math.sin(lat_diff_radians/2) * math.sin(long_diff_radians/2) + math.cos(math.radians(lat1)) * math.cos(math.radians(lat2)) * math.sin(long_diff_radians/2) * math.sin(long_diff_radians/2)
    c = 2 * math.atan2(math.sqrt(a), math.sqrt(1-a))
    distance = R * c
    
    context_dict = {'cood1':codtuple1,'cood2':codtuple2,'distance':distance}
    

    return render_to_response('coods.html',context_dict,context)
def coordinate_generator(number_of_points):
    """
    Generate a number of random geographical points and then geocode them.

    :param number_of_points: number of points to generate
    :type number_of_points: int
    :return: list of geographic point tuples

    """

    coordinate_list = []
    counter = 0
    geocoder = Geocoder()

    while counter < number_of_points:
        lat = round(random.uniform(SOUTHERNMOST, NORTHERNMOST), 6)
        lng = round(random.uniform(EASTERNMOST, WESTERNMOST), 6)
        try:
            gcode = geocoder.reverse_geocode(lat, lng)

            if gcode[0].data[0]['formatted_address'][-6:] in ('Canada', 'Mexico'):
                continue
            elif 'unnamed road' in gcode[0].data[0]['formatted_address']:
                continue
            elif 'Unnamed Road' in gcode[0].data[0]['formatted_address']:
                continue
            else:
                counter += 1
                coordinate_list.append((gcode[0].coordinates, gcode[0].formatted_address))
            # output_file.write(fullstring.format(gcode.x, gcode.y, gcode.address))
        except GeocoderError:
            continue
    print 'Finished generating %d coordinate points' % counter
    return coordinate_list
def geocode(address):
    try:
        return Geocoder.geocode(address)[0].coordinates
    except:
        rep = re.match(r"((.+-\d+)|(.+\d+号))", ad).group()
        print('%sのgeocodeが見つかりませんでした。調整します。→%s' % (ad, rep))
        return Geocoder.geocode(rep)[0].coordinates
Example #4
0
def testCreate(request):
	if request.POST:
		form = suggestTest(request.POST)
		#I think this is where we would set the field for latLon
		#request = request.POST.copy()
		#request.setitem('latLon',latLon)
		if form.is_valid():
			address = form.cleaned_data['street']
			latLon = Geocoder.geocode(address)
			form = form.save(commit=False)
			coords = Geocoder.geocode(address)
			coords = coords[0].coordinates
			lat = coords[0]
			lon = coords[1]
			latLon = str(lat)+","+str(lon)
			form.latLon = latLon
			form.save()
			return HttpResponseRedirect(reverse('playgroundapp_home'))
	else:
		form = suggestTest()
	args = {}
	args.update(csrf(request))

	args['form'] = form
	args['dropdown'] = SchoolDistrict.objects.all()
	return render_to_response('playgroundapp/create_playground.html', args)
Example #5
0
	def save(self):
		if not (self.latitude and self.longitude):
			geocoder = geocoders.GoogleV3()
			geocoding_results = None

			if self.address:
				try:
					query = '%(address)s, %(city)s, %(state)s' % self.__dict__
					g = Geocoder()
					if g.geocode(query).valid_address:
						geocoding_results = list(geocoder.geocode(query, exactly_one=False))
     					if geocoding_results:
						place, (latitude, longitude) = geocoding_results[0]
						self.latitude = latitude
						self.longitude = longitude
						super(Location, self).save()
					else:
						self.latitude = 0
						self.longitude = 0
						super(Location, self).save()
						self.delete()
						return 'address'
				except GeocoderError:
					return 'address'
		else:
			super(Location, self).save()
Example #6
0
    def test_business_auth(self):
        """Test Business API access.

        This query fails on purpose, but we inspect and verify the signed URL is correct."""

        # Create the query parameters to sign. The order matters.
        params_to_sign = OrderedDict()
        params_to_sign['address'] = '1600 amphitheatre mountain view ca'
        params_to_sign['components'] = ''
        params_to_sign['bounds'] = ''
        params_to_sign['region'] = ''
        params_to_sign['language'] = ''
        params_to_sign['sensor'] = 'false'

        request_to_sign = requests.Request(
            'GET',
            url=Geocoder.GEOCODE_QUERY_URL,
            params=params_to_sign,
            headers={
                'User-Agent': Geocoder.USER_AGENT
            })
        client_id = 'gme-businessname'
        crypto_key = 'vNIXE0xscrmjlyV-12Nj_BvUPaw='
        g = Geocoder(client_id=client_id, private_key=crypto_key)
        signed_request = g.add_signature(request_to_sign)
        self.assertRegexpMatches(signed_request.url, r'&signature=[a-zA-Z0-9-=]+$', 'Signature must be at end of URL.')
        self.assertRegexpMatches(signed_request.url, r'&client=gme-businessname', 'URL must containg client id.')
        # Verified against https://m4b-url-signer.appspot.com/
        self.assertRegexpMatches(signed_request.url, r'&signature=7bVsUv6kyRHlG0DBAIhKHfX-96M=', 'Incorrect signature')
Example #7
0
def create_map(profiles):
    options = ("no", "don't", "not", u"❌", "sorry", u"🚫", u"✋", "paypal", "pp",
        "negociable", "negotiable", "negoatiating", "negotiate",
        "offer", "deal", "lower")
    kml = simplekml.Kml()
    coords_map = {}
    g = Geocoder()
    for p in profiles:
        location = p["location"]

        # Check if it's just a message and not a location
        if any(o in location for o in options):
            continue

        # We can't hit the API too hard
        time.sleep(6)
        try:
            coords = coords_map[location]
        except KeyError:
            try:
                results = g.geocode(location)
                lat, lng = results.coordinates
                coords = [(lng, lat)]
                coords_map[location] = coords
                pnt = kml.newpoint()
                pnt.style.labelstyle.scale = 2  # Make the text twice as big
                pnt.name =  p["user_name"]
                pnt.coords = coords

                # Save the KML
                kml.save("poshmark.kml")
            except GeocoderError as e:
                print e
Example #8
0
def xwalk_generic(form, advert):
    if not advert:
        advert = models.Advert()

    advert.set_owner(current_user.id)

    if form.category.data:
        advert.set_category(form.category.data)

    advert.set_title(form.title.data)

    if form.description.data:
        advert.set_description(form.description.data)

    if form.condition.data:
        advert.set_condition(form.condition.data)

    if form.price.data:
        advert.set_price(form.price.data)

    if form.location.data:
        advert.set_spot(form.location.data)
        if form.location.data == "home":
            if current_user.location:
                lat, lon = current_user.location
                advert.set_location(lat, lon)
            else:
                raise XWalkException(
                    "We do not have an address for your account. If you wish to use this option, please edit your information under My Account."
                )
        elif form.location.data == "uni":
            mail = current_user.id.split("@")
            domain = mail[-1]
            uni = domain_uni_lookup[domain]["address"]
            results = Geocoder.geocode(uni + ", United Kingdom")
            lat, lng = results[0].coordinates
            advert.set_location(lat, lng)
        elif form.location.data == "postcode":
            results = Geocoder.geocode(form.postcode.data + ", United Kingdom")
            lat, lng = results[0].coordinates
            advert.set_location(lat, lng)

    if form.keywords.data:
        advert.set_keywords(form.keywords.data)

    image = request.files["upload"]
    if image and allowed_file(image.filename):
        image_id = uuid.uuid4().hex
        name = image.filename.split(".")
        extension = name[-1]
        image_name = str(image_id) + "." + extension
        image.save(os.path.join(app.config["IMAGES_FOLDER"], image_name))
        advert.set_image_id(image_name)
    elif image and not allowed_file(image.filename):
        flash("This is not an allowed image type", "error")

    advert.expires_in(app.config.get("ADVERT_TIMEOUT", 604800))
    advert.save()
    advert.refresh()
    return advert
Example #9
0
 def geolocate(self):
     """Determines the latitude and longitude of the location."""
     if self.geolocated:
         return self.geolocate_success    
     the_address = self.address_for_geolocation()
     logmessage("Trying to geolocate " + str(the_address))
     from pygeocoder import Geocoder
     google_config = get_config('google')
     if google_config and 'api key' in google_config:
         my_geocoder = Geocoder(api_key=google_config['api key'])
     else:
         my_geocoder = Geocoder()
     results = my_geocoder.geocode(the_address)
     self.geolocated = True
     if len(results):
         self.geolocate_success = True
         self.location.gathered = True
         self.location.known = True
         self.location.latitude = results[0].coordinates[0]
         self.location.longitude = results[0].coordinates[1]
         self.location.description = self.block()
         self.geolocate_response = results.raw
         geo_types = {'administrative_area_level_2': 'county', 'neighborhood': 'neighborhood', 'postal_code': 'zip', 'country': 'country'}
         for geo_type, addr_type in geo_types.iteritems():
             if hasattr(results[0], geo_type) and not hasattr(self, addr_type):
                 logmessage("Setting " + str(addr_type) + " to " + str(getattr(results[0], geo_type)) + " from " + str(geo_type))
                 setattr(self, addr_type, getattr(results[0], geo_type))
             #else:
                 #logmessage("Not setting " + addr_type + " from " + geo_type)
         #logmessage(json.dumps(self.geolocate_response))
     else:
         logmessage("valid not ok: result count was " + str(len(results)))
         self.geolocate_success = False
     return self.geolocate_success
Example #10
0
def geoloc(request, entreprise_id=None):
	geocoder=Geocoder()
	try:
		proxy=os.environ['http_proxy']
		geocoder.set_proxy(proxy)
	except KeyError:
		pass
	entreprise = Entreprise.objects.get(pk=entreprise_id)
	adresseComplete = entreprise.adresse_propre+","+entreprise.ville_propre
	#testAdresse = "20 place de la Republique, Montargis"

	try:
		if geocoder.geocode(adresseComplete).valid_address :
			resultat = geocoder.geocode(adresseComplete)
			entreprise.latitude=resultat[0].coordinates[0]
			entreprise.longitude=resultat[0].coordinates[1]
			message = "adresse : "+str(resultat[0].coordinates)
			entreprise.save()
		else:
			message = "adresse non valide"
	except Exception as inst:
		message=inst.args
		
	return render(request, "entreprises/geolocalisation.html", {
		'entreprise': entreprise,
		'afficherAC': adresseComplete,
		'message':message
	})
Example #11
0
 def get_geocode(self):
     ad = self._get_address()
     try:
         return Geocoder.geocode("福岡県" + ad)[0].coordinates
     except:
         rep = re.match(r"((.+-\d+)|(.+\d+号))", ad).group()
         print('%sのgeocodeが見つかりませんでした。調整します。→%s' % (ad, rep))
         return Geocoder.geocode("福岡県" + rep)[0].coordinates
Example #12
0
def geocode_address(address):
    if address.cord is None:
        business_geocoder = Geocoder()
        results = business_geocoder.geocode(address.text)
        address.cord = results
    else:
        results = address.cord
    return Coordinate(results[0].coordinates[0], results[0].coordinates[1])
Example #13
0
def validate_location(self):
    g = Geocoder()
    isvalid = False
    try:
        isvalid = g.geocode(self).valid_address
    except:
        raise ValidationError("No address was found.")
    if not isvalid:
        raise ValidationError("Please enter a valid address.")
Example #14
0
def dist_address(addr1, addr2):
    ''' given two address, return distance in miles '''
    result1 = Geocoder.geocode(addr1)
    result2 = Geocoder.geocode(addr2)
    if (result1.count==1)&(result2.count==1): ## if only one valid address
        return dist(result1.coordinates, result2.coordinates) ## dist(coordinate1, coordinate2)
    else:
        print 'Error'
        return None
Example #15
0
def find_Path(MAP, model):
    gmaps = GoogleMaps()
    
    home = raw_input("Enter your starting address: ")
    end =  raw_input("Enter your destination address: ")
    results = Geocoder.geocode(home)
    results2 = Geocoder.geocode(end)
    #results = Geocoder.reverse_geocode(41.96786329,-87.71349889)
    #results2 = Geocoder.reverse_geocode(41.763258, -87.61172601)

    print '---Finding Path from ', results, ' to ', results2

    dirs  = gmaps.directions(results, results2)

    time  = dirs['Directions']['Duration']['seconds']
    dist  = dirs['Directions']['Distance']['meters']
    route = dirs['Directions']['Routes'][0]
    
    PATH = []
    EVALUATION = []
    
    for step in route['Steps']:
        position = (step['Point']['coordinates'][1], step['Point']['coordinates'][0])
        if position in MAP:
            for i in range(4): PATH.append('H')
            PATH.append('no')
        else:
            for i in range(4):PATH.append('L')
            PATH.append('yes')
        
        #PREDICT FOR EACH CITY IN THE INTERMEDIATE STEPS
        with open("predict.arff", "a") as myfile:
            for elem in PATH:
                if elem == 'yes' or elem == 'no': myfile.write(elem)
                else: myfile.write(elem  + ',')
            myfile.write('\n')
        PATH = []

    EVALUATION = model.TestClassifier("predict.arff")
    #mark current place as SAFE since you're already at that location anyways
    EVALUATION[0] = 'yes'
    
    #Print Final Results At this Point
    k = 0
    for step in route['Steps']:
        position = (step['Point']['coordinates'][1], step['Point']['coordinates'][0])
        print step['Point']['coordinates'][1], step['Point']['coordinates'][0] ,  '===========================>SAFE? ', EVALUATION[k]
        print step['descriptionHtml']
        k +=1
    
    #UPDATE THE FILES
    delete("predict.arff")
    filename2 = "predict.arff"
    shutil.copy("predict_start.arff", filename2)
    if os.path.isfile (filename2): print "Have a Safe Journey"
    else: print "#####Problem Here: Error 99. Engineeer Will Fix the Bug ASAP"
Example #16
0
    def test_simple_auth(self):
        """Test Simple API access. May be flacky is too many people test with the test key"""

        addr = '1600 amphitheatre mountain view ca'
        api_key = 'AIzaSyBUnYj-u24fsbWdftSwbos7XcyQVqiuSao'  # a throwaway test key
        g = Geocoder(api_key=api_key)
        result = g.geocode(addr)

        self.assertEqual(result.state, 'California')
        self.assertEqual(result.country, 'United States')
def get_county_name(longitude, latitude, placeID = None):
    url_prefix = 'https://maps.googleapis.com/maps/api/geocode/json?latlng='
    #placeID and longitude and latitude
    key = 'AIzaSyAw-2MPkd3FbwnTjNpsaai1tsIzUk-B2aA'
    geocoder_obj = Geocoder(None, key)
    print "Lookup of Address Begin"
    results = geocoder_obj.reverse_geocode(longitude, latitude)
    print type(results)
    address = results.split()
    print address
Example #18
0
def geocode():
    '''
    geocoder = GoogleV3(
        client_id='416144311414-9sa4usu4f9dsuvn8urbhprq3stdisq3k.apps.googleusercontent.com', 
        secret_key='0LGqN8vGa_xfEd4us9Y_VXKC',
        api_key='AIzaSyAc0R7DULyiZPWAcBTrCyFJM38WCepWrEU')
        '''
    #geocoder = GoogleV3(api_key='AIzaSyBBnPI_YDy1V51NfXAvHsVKWhq0Po31L24')	
    geocoder = Geocoder();
        
    #load geocode cache
    try:
        with open('process/geocache.json') as data_file:    
            cache = json.load(data_file)
    except:
        cache = {}

    #load properties
    with open('app/properties.json') as data_file:    
        properties = json.load(data_file)

    #geocode property addresses
    with stdchannel_redirected(sys.stderr, os.devnull):
        i = 0
        for p in properties:
            i += 1
            if p["id"] in cache:
                p["latlong"] = cache[p["id"]]
            else:
                try:
                    address = p["address"] + " " + p["city"] + " " + p["state"]
                    l = geocoder.geocode(address)
                    latlong = [ l.latitude, l.longitude]
                    p["latlong"] = latlong
                    cache[p["id"]] = latlong
                except: 
                    print('\nERROR: GeoCoding Failure, API Limit most likely reached')
                    break
                
                    

            #print percent progress
            sys.stdout.write("\r%d%%" % (float(i)/len(properties) *100.0))
            sys.stdout.flush()

    print ("\nGeoCoding Complete")

    #dump properties
    with open('app/properties.json', 'w') as outfile:
        json.dump(properties, outfile)

    #dump cache
    with open('process/geocache.json', 'w') as outfile:
        json.dump(cache, outfile)
Example #19
0
def determine_estimate():

    ### Gets addresses, converts them to coordinates, requests estimates from API, creates dictionary, saves to a session to use later

    uber_prices = []

    app_start_address = request.args.get("start_address")
    app_end_address = request.args.get("end_address")

    ### This is a fix for the problem that arose from the geocode lbirary, fixes SSL restrictions. See site for more details: https://urllib3.readthedocs.org/en/latest/security.html#pyopenssl

    # try:
    # 	import urllib3.contrib.pyopenssl
    # 	urllib3.contrib.pyopenssl.inject_into_urllib3()
    # except ImportError:
    # 	pass

    ### If the server receives correct input, it will convert to coordinates, make reuqest from Uber API, if not it will display an error message

    # try:
    geo_start_address = Geocoder.geocode(app_start_address)
    geo_end_address = Geocoder.geocode(app_end_address)
    if geo_start_address.valid_address and geo_end_address.valid_address:

        start_coordinates = geo_start_address[0].coordinates
        end_coordinates = geo_end_address[0].coordinates

        start_lat = start_coordinates[0]
        start_long = start_coordinates[1]

        end_lat = end_coordinates[0]
        end_long = end_coordinates[1]

        AUTH = Uber(ENV.CLIENT_ID, ENV.SERVER_TOKEN, ENV.SECRET)

        estimate = AUTH.get_price_estimate(start_lat, start_long, end_lat, end_long)

        services_and_prices = estimate["prices"]

        for i in range(len(services_and_prices)):
            uber_price = {}
            uber_price["service"] = services_and_prices[i]["display_name"]
            uber_price["price"] = services_and_prices[i]["estimate"]
            uber_prices.append(uber_price)

        session["user_travel"] = uber_prices

        return render_template("results.html")

    else:

        message = "Something went wrong. Please make sure you entered valid addresses."

        return render_template("index.html", message=message)
Example #20
0
	def _geocode(self, address,city,state,zipcode):
		# prepare geocoder
		from pygeocoder import Geocoder
		myg=Geocoder(api_key='AIzaSyAJmxEb1O6GJMxP9QuhCc4-HV2aae2FolA')
		addrstr = "%s %s, %s %s" %(address,city, state, zipcode)
		try:
			loc = myg.geocode(addrstr)
		except Exception, e:
			print "GEOCODER FAIL: %s. Maybe try setting the proxy?" %(e)
			myg.set_proxy('mtaweb.metro.net:8118')
			loc = myg.geocode(addrstr)
Example #21
0
def map(location,destination):
	api_key=open('api_key').read()
	url="https://maps.googleapis.com/maps/api/js?key=%s"%api_key
	geoOrig=Geocoder.geocode(location)
	geoDest=Geocoder.geocode(destination)
	lat1,lng1=geoOrig[0].coordinates
	lat2,lng2=geoDest[0].coordinates
	directionsurl=("https://maps.googleapis.com/maps/api/directions/json?origin=%s&destination=%s&key=%s")%(location, destination, api_key)
	directions=requests.get(directionsurl)
	print directions.content
	return render_template("base.html", url=url, lat1=lat1, lng1=lng1, lat2=lat2,lng2=lng2)
Example #22
0
def getGeocodedLocation(location, language='en'):
    if location is None:
        return None
    try:
        google_api = getUtility(IPasswordManager, 'googleapi')
        geocoder = Geocoder(api_key=google_api.password)
        locations = geocoder.geocode(location, language=language)
    except GeocoderError, e:
        if e.status == u'ZERO_RESULTS':
            return None
        else:
            raise e
Example #23
0
    def test_geocode_with_components(self):
        """Test pygeocoder geocode()"""

        addr = 'East London'
        components = 'country:ZA'
        g = Geocoder()

        bare_result = g.geocode(addr)
        self.assertEqual(bare_result.city, 'London')
        self.assertEqual(bare_result.country, 'United Kingdom')

        za_result = g.geocode(addr, components=components)
        self.assertEqual(za_result.city, 'East London')
        self.assertEqual(za_result.country, 'South Africa')
Example #24
0
 def get_reverse_geo(self,fileWithCoords):
     from pygeocoder import Geocoder # sudo port select python python26
     #fileWithAddresses='/Users/admin/Desktop/work_locations.txt'
     f=open(fileWithCoords,'r')
     x=f.read()
     f.close()
     z=x.split('\r')
     pt=0
     for i in range(0,len(z)):
         a=z[i].split('\t')
         print Geocoder.reverse_geocode(eval(a[0]),eval(a[1]))
         pt+=1
         if pt==10:
             sleep(10)
             pt=0
Example #25
0
def restaurant():
    #Get input arguments
    restaurant = request.args.get("restaurant", "")
    miles = request.args.get("miles", '')
    zipcode = request.args.get("zipcode", "")
    try:
        miles = str(int(float(miles)))
        if miles=="0":
            miles = "1"
    except ValueError:
        return json.dumps(["Please enter a number into the miles field"])

    try:
        location = Geocoder.geocode(zipcode)
    except:
        return json.dumps(["I couldn't recognize that address. Could you enter another one?"])

    zipcode = location.formatted_address

    query = restaurant + " " + miles + " " + zipcode
    sql = ('SELECT Result FROM Cached WHERE Query = "' + query + '";')
    db.cursor.execute(sql)
    results = db.cursor.fetchall()
    if len(results)>0:
        result = ast.literal_eval(results[0][0])
    else:
        result = predict_rest.predict_rest(restaurant, miles, location)
        sql = ('INSERT INTO Cached (Query, Result) VALUES ("' + query + '", %s);')
        db.cursor.execute(sql, (str(result),))
        db.commit()

    return json.dumps(result)
Example #26
0
File: views.py Project: MAPC/cedac
def geocode_property(obj):

    if obj.geocoded is False:

        attempts = 0
        success = False

        while success != True and attempts < 3:
            try:
                result = Geocoder.geocode(obj.address)
                attempts += 1

                if result.valid_address:
                    obj.lat = result[0].coordinates[0]
                    obj.lon = result[0].coordinates[1]
                    obj.geometry = Point(obj.lon, obj.lat)
                    obj.geocoded_address = str(result)
                    obj.geocoded_type = result.raw[0]['geometry']['location_type']
                    obj.geocoded = True

                # no geocoding error
                success = True

            except GeocoderError, e:
                if 'OVER_QUERY_LIMIT' in e:
                    time.sleep(2)
                    # retry
                    continue
                else:
                    # not really true, but stop trying
                    # not sure what happened
                    success = True 
                    break
Example #27
0
    def test_reverse_geocode(self):
        """
        Test pygeocoder reverse_geocode()

        """
        lat, lng = 38.897096, -77.036545
        result = Geocoder.reverse_geocode(lat, lng)

        self.assertEqual(result.country__short_name, 'US')
        self.assertEqual(result.postal_code, '20500')
        self.assertEqual(result.street_number, '1600')
        self.assertEqual(result.route, 'Pennsylvania Avenue Northwest')
        self.assertEqual(result.administrative_area_level_1, 'District of Columbia')
        self.assertEqual(result.city, 'Washington, D.C.')
        self.assertEqual(result.state, 'District of Columbia')
        self.assertEqual(result.state__short_name, 'DC')
        self.assertEqual(result.country, 'United States')
        addr = result.formatted_address
        self.assertEqual(addr, "1600 Pennsylvania Avenue Northwest, President's Park, Washington, D.C., DC 20500, USA")
        lat2, lng2 = result.coordinates
        self.assertAlmostEqual(lat, lat2, 3)
        self.assertAlmostEqual(lng, lng2, 3)
        self.assertAlmostEqual(lat, result.latitude, 3)
        self.assertAlmostEqual(lng, result.longitude, 3)
        self.assertTrue(result.count > 1)
Example #28
0
def generate_user_home_work(user):
    user_home=detect_home(user)
    # print user_home
    zip_is_valid = _check_zip_validity(user_home, user)
    logging.debug('starting for %s' % user)
    if Profiles.find({'user_id':user}).count()==0:
        profile_todo={'source':'Shankari','user_id': user,'home':user_home}
        Profiles.insert(profile_todo)
    else:
        #TODO: make detect_home return something better than a N/A string
        Profiles.update({"$and":[{'source':'Shankari'},
                                     {'user_id':user}]},{"$set":{'home':user_home}})
    user_work=detect_work_office(user)
    Profiles.update({"$and":[{'source':'Shankari'},{'user_id':user}]},{"$set":{'work_place':user_work}})
    user_zip=get_userZipcode(user, zip_is_valid)
    Profiles.update({"$and":[{'source':'Shankari'},{'user_id':user}]},{"$set":{'zip':user_zip}})
    if user_zip!='N/A':
        geoinfo= Geocoder.geocode(user_zip)
        # geocoder returns data in lat,lng format.
        # we convert to lng,lat internally, since that is the format that the
        # rest of our code is in
        zipCen=[geoinfo[0].coordinates[1],geoinfo[0].coordinates[0]]
    else:
        zipCen='N/A'
    Profiles.update({"$and":[{'source':'Shankari'},{'user_id':user}]},{"$set":{'zip_centroid':zipCen}})


    for day in range(1,6):
        key='work'+str(day)
        Profiles.update({"$and":[{'source':'Shankari'},
                                     {'user_id':user}]},{"$set":{key:detect_daily_work_office(user,day)}})
Example #29
0
    def retrieve(self, city, attempt=1):
        """Try to grab json data in multiple ways"""
        r = get_json_or_timeout(self.api_url.format(self.APIKEY,
                                                    '/'.join(self._features),
                                                    self.lang,
                                                    city))

        # when service is unreachable or times out
        if r is None:
            raise WeatherError('Could not reach wunderground.com')
        # if service does not recognize city, it returns possible
        # zmw code, which is possible to search for city with
        elif 'results' in r['response']:
            return self.retrieve('zmw:' + r['response']['results'][0]['zmw'],
                                 attempt + 1)
        # some cities are not recognized and have to have `,country` at the end
        # or be searched based on latitude and longitude
        elif 'error' in r['response']:
            if attempt < 2:
                loc = Geocoder.geocode(city)
                return self.retrieve(','.join([str(loc[0].latitude),
                                               str(loc[0].longitude)]),
                                     attempt + 1)
            elif attempt < 3:
                return self.retrieve(city + ',' + self.country, attempt + 1)
            raise WeatherError(r['response']['error']['description'])
        else:
            return r
Example #30
0
def _update_account(account, form):
    account.set_name(form.name.data)

    if form.degree.data:
        account.set_degree(form.degree.data)
    elif form.degree.data == "":
        del account.degree

    if form.postcode.data:
        account.set_postcode(form.postcode.data)

        results = Geocoder.geocode(form.postcode.data + ', United Kingdom')
        lat, lng = results[0].coordinates
        account.set_location(lat, lng)
    elif form.postcode.data == "":
        del account.postcode
        account.unset_location()

    if form.phone.data:
        account.set_phone(form.phone.data)
    elif form.phone.data == "":
        del account.phone

    if form.graduation.data:
        account.set_graduation(form.graduation.data)
    elif form.graduation.data == "":
        del account.graduation
Example #31
0
def search_business(business_name):

    results = Geocoder.geocode(business_name)
    
    for result in results:
        print result
    column_4 = col[3].find('a').string.strip()
    localidad.append(column_4)
    json += str(column_4)
    json += "\",\n \"Gasolina95\": \""
    column_5 = col[4].string.strip()
    gasolina95.append(column_5)
    json += str(column_5.encode('utf-8')[0:5])
    json += "\",\n \"Gasolina98\": \""
    column_6 = col[6].string.strip()
    gasolina98.append(column_6)
    json += str(column_6.encode('utf-8')[0:5])
    json += "\",\n \"Gasoleo\": \""
    column_7 = col[7].string.strip()
    gasoleo.append(column_7)
    json += str(column_7.encode('utf-8')[0:5])
    json += "\",\n \"GLP\": \""
    column_8 = col[8].string.strip()
    glp.append(column_8)
    json += str(column_8.encode('utf-8')[0:5])
    localizar = column_3 + ", " + column_4
    localizar = corrector(localizar)
    json += "\",\n \"Coordenadas\": \"["
    coordenadas = str(Geocoder.geocode(localizar).coordinates)[1:-1]
    json += coordenadas
    #print column_3
    #print column_4 para añadir la localizacion
    json += "]\"\n}\n"
    f.write(json)
    sleep(0.101)
f.close()
Example #33
0
                else:
                    # Check if agent is in exclude list
                    exclude = ex_agent(agentid, exclude_agent)
                    if exclude:
                        print "Agent ID " + str(
                            exclude) + " in exclude list, skipping .. "
                        continue
                    else:
                        print "Agent ID " + str(
                            agentid) + " not in exclude list .. "
                        listingcategory = "OtherListings"

# Get the latitude + longitude variables
            print "Address for geocoder : " + addressfix
            try:
                results = Geocoder.geocode(addressfix)
                lat, lng = results[0].coordinates
                lat = str(lat)
                lng = str(lng)
            except GeocoderError:
                print 'Error getting address, skipping'
                (lat, lng) = (0.0, 0.0)
                continue

            # Set variable for virtual tour
            if virtualtour == "":
                virtualtour = "N/A"
            else:
                virtualtour = "<strong>Virtual Tour:</strong> <a href=\"" + virtualtour + "\" target=\"_new\"><b>Click here for virtual tour</b></a>"

    # Start prepping the uploads folder for the MLS listing images
from pymongo import MongoClient
from pygeocoder import Geocoder
from elasticsearch import Elasticsearch
import time

mongo_client = MongoClient()
db = mongo_client.pune_bus
collection = db.routes
collection_insert = db.routes_with_geolocation_v4

for i in collection.find(no_cursor_timeout=True):
    if 'route_up' in i:
        for j in i['route_up']:
            temp_dict = {}
            try:
                geocode = Geocoder.geocode(j['stop_name'] + ",Pune")
                latitude, longitude = geocode.coordinates
                temp_dict['latitude'] = latitude
                temp_dict['longitude'] = longitude
            except Exception, e:
                temp_dict['latitude'] = None
                temp_dict['longitude'] = None
            j.update(temp_dict)
            time.sleep(0.05)
    if 'route_down' in i:
        for k in i['route_down']:
            temp1_dict = {}
            try:
                geocode = Geocoder.geocode(k['stop_name'] + ",Pune")
                latitude, longitude = geocode.coordinates
                temp_dict1['latitude'] = latitude
Example #35
0
from pygeocoder import Geocoder

a = Geocoder(
    client_id=
    '352528416515-r1du34cl9j9kqf4cv0dc8pnjnmi6qj9l.apps.googleusercontent.com',
    api_key='AIzaSyDRNTE8EWOsbZzAQcM3hlBpaNA0zTuVups')
b = a.geocode('kahmandu')
from pygeocoder import Geocoder

latitude = float(input("Enter latitude...: "))
longitude = float(input("Enter longitude.: "))

result = Geocoder.reverse_geocode(latitude, longitude)
if result.valid_address:
    print("Address...........: ", result)
    print("Number............: ", result.street_number)
    print("Postal Code.......: ", result.postal_code)
from pygeocoder import Geocoder

skip = input("Skip first line?: y/n (default no)\n")
if skip == "y":
    skip = True
else:
    skip = False
GeocoderApi = input(
    "Please enter a Geocoder API key from the google cloud console: \n")
f = open("addresses.txt", "a+")
r = open("cordinates.txt", "w+")
previous = ""
f.seek(0)
for line in f:
    if skip:
        skip = False
        continue
    else:
        if line != previous:
            r.write(str(Geocoder(GeocoderApi).geocode(line).coordinates))
            r.write("\n")
            previous = line
            print("Calculating cordinates for: " + line)
print("Done. No more addresses to consider")
f.close
r.close
Example #38
0
def get_zip_code(lat, lon):
    result = pd.Series()
    for i in range(len(list(lat))):
        result.set_value(label=i,value=Geocoder.reverse_geocode(lat[i], lon[i]).formatted_address.split(',')[2][4:9],takeable=False)
        
    return result
Example #39
0
# -*- coding: utf-8 -*-
Example #40
0
"""
from pygeocoder import Geocoder
endereco = '1222, Lins de Vasconcelos, Sao Paulo, SP'
print(Geocoder('AIzaSyCKifeG7c5OiA_6A1UITwRkHJIqocTCKV8').geocode(endereco).coordinates)


resultado = Geocoder('AIzaSyCKifeG7c5OiA_6A1UITwRkHJIqocTCKV8').geocode(endereco).country
resultado = Geocoder('AIzaSyCKifeG7c5OiA_6A1UITwRkHJIqocTCKV8').geocode(endereco).coordinates
resultado = Geocoder('AIzaSyCKifeG7c5OiA_6A1UITwRkHJIqocTCKV8').geocode(endereco).state
"""

from pygeocoder import Geocoder

endereco = 'avenida paulista, 100, Sao Paulo'
resultado = Geocoder(
    'AIzaSyCKifeG7c5OiA_6A1UITwRkHJIqocTCKV8').reverse_geocode(
        -23.570807, -46.6444668)
print(resultado)
Example #41
0
def map_address(address):
    results = Geocoder.geocode(address)
    return str(results[0].coordinates).strip('()')
Example #42
0
            print(a_steps[a_idx_steps]['distance'])
            #print("\n")
            print(a_steps[a_idx_steps]['duration'])
            #print("\n")
            print(a_steps[a_idx_steps]['html_instructions'])
            #print("\n")
            print(a_steps[a_idx_steps]['polyline'])
            #print("\n")
            print(a_steps[a_idx_steps]['travel_mode'])
            #print("\n")

exit(0)

# Geocoder
address = "国会議事堂"
results = Geocoder.geocode(address)
print(results[0].coordinates)
result = Geocoder.reverse_geocode(*results.coordinates, language="ja")
print(result)

# GoogleMaps
address = '札幌駅'
#address = 'ホワイトハウス'
results = Geocoder.geocode(address)
print(results[0].coordinates)
result = Geocoder.reverse_geocode(*results.coordinates, language="ja")
print(result)
html1 = "https://maps.googleapis.com/maps/api/staticmap?center="
html2 = "&maptype=hybrid&size=640x480&sensor=false&zoom=18&markers="
html3 = ""
#html3 = "&key=AIzaSyBRRmlCHEWhI9m7WLOgGNuGtBT9sxfoSzc"
import sys
import csv
from pygeocoder import Geocoder

infile = open('in.csv', 'rt')
outfile = open('out.csv', 'wt')

try:
    reader = csv.reader(infile)
    writer = csv.writer(outfile)
    geocoder = Geocoder()

    for row in reader:
        if len(row) > 0:
            try:
                result = geocoder.geocode(row[0], language='ja')

                if len(result) > 0:
                    writer.writerow([
                        row[0], result[0].coordinates[0],
                        result[0].coordinates[1]
                    ])
            except:
                print(sys.exc_info()[0])
except:
    print(sys.exc_info()[0])
finally:
    infile.close()
    outfile.close()

print('geocoding finished!')
Example #44
0
import sys
import random
import os.path
##The Args the Args Thank God for the args (CronJob Ho!)

import argparse
parser = argparse.ArgumentParser()
parser.add_argument("--resume","-r",help="Resume Existing job and filling in API.  -r 500 (api limit 500)")
#parser.add_argument("--apilimit","-a", help="API Query Limit Default is 1000",type=int)
args = parser.parse_args()
if args.resume:
    shouldcontinue = 'y'
    apiquerylimi = args.resume

#File Names and Array setup
geocoder = Geocoder()
workdone = "workdone"
test = "test"
filename = "addresses"
toberemoved = []
latlong = []
completed = []

#making it not casesensitive basically
geocoder = Geocoder()


#This function removes duplicates from any array that comes into it.  Handy to reduce API Query 
def remove_duplicates(list):
    newlist = []
    for i in list:
Example #45
0
def sendEventReminder(purchase, tz):
    """
    Send event reminder 24 hours before event
    """
    user = purchase.owner
    event = purchase.event
    event_month = DateFormat(localize(event.start_time))
    event_month = event_month.format('M')
    event_day = DateFormat(localize(event.start_time))
    event_day = event_day.format('j')
    organizers = event.organizers.all()
    to = [{
        'email': user.email,
        'name': user.first_name + ' ' + user.last_name
    }]
    subject = 'Reminder for ' + event.name
    from_name = organizers[0].name
    from_email = ''
    if organizers[0].email:
        from_email = organizers[0].email
    template = 'event-reminder'
    items = Purchase_item.objects.filter(purchase = purchase) \
                                 .prefetch_related('ticket')
    reciept_info = ''
    if event.slug:
        event_url = 'https://bazaarboy.com/' + event.slug
    else:
        event_url = 'https://bazaarboy.com/event/' + str(event.id)
    startTime = event.start_time.astimezone(tz)
    startTime = tz.normalize(startTime)
    if event.end_time:
        endTime = event.end_time.astimezone(tz)
        endTime = tz.normalize(endTime)
        if endTime.day == startTime.day:
            event_date = '<span style="font-weight: 600;">' + startTime.strftime(
                '%A') + '</span>, '
            event_date += startTime.strftime('%I:%M%p').lower(
            ) + ' - ' + endTime.strftime('%I:%M%p').lower()
        else:
            event_date = startTime.strftime('%A') + ', ' + startTime.strftime(
                '%I:%M%p').lower() + ' - '
            event_date += endTime.strftime('%A') + ', ' + endTime.strftime(
                '%I:%M%p').lower()
    else:
        event_date = '<span style="font-weight: 600;">' + startTime.strftime(
            '%A') + '</span>, '
        event_date += startTime.strftime('%I:%M%p').lower()
    event_address = ''
    event_map = ''
    if event.latitude and event.longitude:
        event_address += "<div style='margin-bottom:5px; text-decoration:underline;'>Event Address</div>"
        address = Geocoder.reverse_geocode(event.latitude, event.longitude)
        address = [x.strip() for x in address[0].formatted_address.split(',')]
        for address_component in address:
            if address_component != 'USA':
                event_address += str(address_component) + "<br />"
        event_map = u'<a href="https://maps.google.com/?saddr=' + str(
            event.latitude
        ) + ',' + str(
            event.longitude
        ) + '"><img src="http://maps.google.com/maps/api/staticmap?center=' + str(
            event.latitude) + ',' + str(
                event.longitude) + '&zoom=15&size=300x150&markers=' + str(
                    event.latitude) + ',' + str(event.longitude) + '" /></a>'
    mergeVars = [{
        'rcpt':
        user.email,
        'vars': [{
            'name': 'first_name',
            'content': user.first_name
        }, {
            'name': 'organizer_email',
            'content': from_email
        }, {
            'name': 'event_link',
            'content': event_url
        }, {
            'name': 'event_name',
            'content': event.name
        }, {
            'name': 'event_month',
            'content': event_month
        }, {
            'name': 'event_day',
            'content': event_day
        }, {
            'name': 'event_date',
            'content': event_date
        }, {
            'name': 'event_location',
            'content': event.location
        }, {
            'name': 'event_address',
            'content': event_address
        }, {
            'name': 'event_map',
            'content': event_map
        }]
    }]
    attachments = Ticket_attachment.getTicketAttachments(purchase, items)
    return sendEmails(to, from_name, subject, template, mergeVars, attachments)
Example #46
0
    def parse_items(self, response):
        rentalList = ListingItem()
        try:
            rentalList['pid'] = response.meta['pid']
            rentalList['repostId'] = response.meta['repostId']
            rentalList['dt'] = response.meta['dt']
            rentalList['url'] = response.url
            rentalList['title'] = response.meta['title']
            rentalList['price'] = response.meta['price']
            rentalList['bedroom'] = response.meta['beds']
            rentalList['area'] = response.meta['sqft']
            rentalList['hood'] = response.meta['hood']
            rentalList['listid'] = WEBSITE + response.meta['pid']
            rentalList['website'] = WEBSITE
            lat = ''
            lng = ''
            accuracy = ''
            street_address = ''
            city = ''
            state = ''
            post_code = ''

            map = response.xpath('//div[@id="map"]')
            print
            # Sometimes there's no location info, and no map on the page
            if len(map) > 0:
                lat = float(map[0].xpath('./@data-latitude').extract_first())
                lng = float(map[0].xpath('./@data-longitude').extract_first())
                accuracy = map[0].xpath('./@data-accuracy').extract_first()
                results = Geocoder.reverse_geocode(lat, lng)
                city = results.city
                state = results.administrative_area_level_1
                post_code = results.postal_code
                street = response.xpath(
                    '//div[@class="mapaddress"]/text()').extract_first()
                if street is not None:
                    street_address = street
                else:
                    street_address = results.street_number + ' ' + results.route
            descList = response.xpath(
                '//section[@id="postingbody"]/text()').extract()
            description = ''
            if descList is not None:
                # description = self._get_list_str(descList).rstrip()
                description = " ".join(self._get_list_str(descList).split())
            if len(description) == 0:
                descriptionArray = response.xpath(
                    '//section[@id="postingbody"]/p/text()').extract()
                if descriptionArray is not None:
                    description = " ".join(
                        self._get_list_str(descriptionArray).split())
            # removed
            isRemoved = False
            removedElement = response.xpath('//div[@class="removed"]')
            if len(removedElement) > 0:
                isRemoved = True
            print "length of removedElement is" + str(len(removedElement))
            isFlagged = False
            flagList = response.xpath('//aside[@class="flags done"]')
            if len(flagList) > 0:
                flagTextList = flagList[0].xpath(
                    './span[@class="flagtext"]/text()').extract_first()
                if flagTextList is not None and flagTextList == 'prohibited':
                    isFlagged = True
            print "length of flagTextList is" + str(len(flagTextList))
            imgTree = response.xpath('//a[@class="thumb"]')
            imageSet = []
            # Sometimes there's no location info, and no map on the page
            if len(imgTree) > 0:
                for image in imgTree:
                    url = image.xpath('./@href').extract_first()
                    imageSet.append(url)
            print "length of imageTree is" + str(len(imgTree))
            rentalList['description'] = description
            rentalList['isFlagged'] = isFlagged
            rentalList['isRemoved'] = isRemoved
            rentalList['accuracy'] = accuracy
            rentalList['image'] = imageSet
            rentalList['agent'] = ''
            rentalList['contact'] = ''
            rentalList['address'] = {
                "address": "",
                "street": street_address,
                "city": city,
                "state": state,
                "zipcode": post_code,
                "lat": lat,
                "lon": lng
            }
            print rentalList
            yield rentalList

        except Exception, e:
            log.msg(u'Error happens in parse items: {0}'.format(e),
                    level=log.WARNING)
            # Skip listing if there are problems parsing it
            return
Example #47
0
                        min_listing) + " , Not adding"
                    continue
                else:
                    # Check if agent is in exclude list
                    exclude = ex_agent(agentid, exclude_agent)
                    if exclude:
                        print "Agent ID " + str(
                            exclude) + " in exclude list, skipping .. "
                        continue
                    else:
                        print "Agent ID " + str(
                            agentid) + " not in exclude list .. "
                        listingcategory = "OtherListings"

# Get the latitude + longitude variables
            results = Geocoder.geocode(address + " Toronto, Ontario, Canada")
            lat, lng = results[0].coordinates
            lat = str(lat)
            lng = str(lng)

            # Set variable for virtual tour
            if virtualtour == "":
                virtualtour = "N/A"
            else:
                virtualtour = "<a href=\"" + virtualtour + "\" target=\"_new\"><b>Click here for virtual tour</b></a>"

    # Start prepping the uploads folder for the MLS listing images
            if pictures == "Y":
                mlsimage = mlsnumber[-3:]
                print "MLS Image : " + mlsimage
Example #48
0
from pygeocoder import Geocoder
whitehouse = '1600 Pennsylvania Avenue, Washington, DC'
results = Geocoder.geocode(whitehouse)
lat, lng = results[0].coordinates
reverseCode = Geocoder.reverse_geocode(lat, lng)

#https://bitbucket.org/xster/pygeocoder/wiki/Home
Example #49
0
#!/usr/bin/env python3

from pygeocoder import Geocoder
if __name__ == '__main__':
    endereco = 'Av. Senador Salgado Filho, 1559, Natal, RN'
    print(Geocoder.geocode(endereco)[0].coordinates)
Example #50
0
lat = []
lon = []
country = []
count = 0

file = open('country1.txt', 'a')

count = 0

with open('subset_artist_location.txt') as f:
    for line in f:
        count += 1
        if count > 0:
            print(count)
            valTuple = line.split('<SEP>')
            if len(valTuple) > 1:
                if count % 3 == 0:
                    time.sleep(1.5)
                artistID = valTuple[0]
                artist_location_dic[artistID] = valTuple[1], valTuple[2]
                lat.append(float(valTuple[1]))
                lon.append(float(valTuple[2]))
                results = Geocoder.reverse_geocode(float(valTuple[1]),
                                                   float(valTuple[2]))
                country.append(results.country)
                file.write(artistID + "', " + results.country + "\n")

f.close()

#print (country)
print(count)
Example #51
0
    erad = 6371  # kilometers
    return (vangle * erad)


# read dataframe
f = open(sys.argv[0], 'rb')
df = pd.read_csv(sys.argv[1])

# iteration start point
lat0 = float(sys.argv[2])
lon0 = float(sys.argv[3])
nit = int(sys.argv[4])

# optimization iterations
costs = []
for i in range(0, nit):
    dist = get_dist(df.lat, df.lon, lat0, lon0)
    denom = df.demand / dist
    numx = df.demand * df.lat / dist
    numy = df.demand * df.lon / dist
    lat0 = sum(numx) / sum(denom)
    lon0 = sum(numy) / sum(denom)
    costs.append(sum(df.demand * dist))
    if 1.0 - (costs[i] / costs[i - 1]) < 1e-6 and i != 0:
        break
#  print "Optimal site\nlat: %f, lon: %f" % (lat0, lon0)
    print "New Address: %s" % Geocoder.reverse_geocode(lat0, lon0)[0]

print "Optimal site\nlat: %f, lon: %f" % (lat0, lon0)
print "Address: %s" % Geocoder.reverse_geocode(lat0, lon0)[0]
def parse_tweet_json(line, tweetdata):
    """
    Take in a line from the file as a dict
    Add to it the relevant fields from the json returned by Twitter
    
    Documentation https://dev.twitter.com/docs
    """

    line["tweet_coordinates"] = str(tweetdata["coordinates"])
    line["tweet_favorited"] = str(tweetdata["favorited"])
    if tweetdata["entities"] is not None:
        if tweetdata["entities"]["hashtags"] is not None:
            hashtag_string = ""
            for tag in tweetdata["entities"]["hashtags"]:
                hashtag_string = hashtag_string + tag["text"] + "~"
            hashtag_string = hashtag_string[:-1]
            line["hashtags"] = str(hashtag_string.encode('utf-8'))
        else:
            line["hashtags"] = ""
        if tweetdata["entities"]["user_mentions"] is not None:
            user_mentions_string = ""
            for tag in tweetdata["entities"]["user_mentions"]:
                user_mentions_string = user_mentions_string + tag[
                    "screen_name"] + "~"
            user_mentions_string = user_mentions_string[:-1]
            line["user_mentions"] = str(user_mentions_string)
        else:
            line["user_mentions"] = ""
    line["tweet_retweet_count"] = str(tweetdata["retweet_count"])
    line["tweet_favorite_count"] = str(tweetdata["favorite_count"])
    line["tweet_retweeted"] = str(tweetdata["retweeted"])
    line["tweet_place"] = str(tweetdata["place"])
    line["tweet_geo"] = str(tweetdata["geo"])
    line["tweet_coordinates"] = str(tweetdata["coordinates"])
    line["tweet_in_reply_to_screen_name"] = str(
        tweetdata["in_reply_to_screen_name"])
    if tweetdata["user"] is not None:
        line["user_friends_count"] = str(tweetdata["user"]["friends_count"])
        line["user_name"] = tweetdata["user"]["name"].encode('utf-8')
        line["user_favourites_count"] = str(
            tweetdata["user"]["favourites_count"])
        line["user_screen_name"] = tweetdata["user"]["screen_name"].encode(
            'utf-8')
        line["user_listed_count"] = str(tweetdata["user"]["listed_count"])
        line["user_location"] = tweetdata["user"]["location"].encode('utf-8')
        line["user_utc_offset"] = str(tweetdata["user"]["utc_offset"])
        line["user_followers_count"] = str(
            tweetdata["user"]["followers_count"])
        line["user_listed_count"] = str(tweetdata["user"]["listed_count"])
        line["user_lang"] = tweetdata["user"]["lang"].encode('utf-8')
        line["user_geo_enabled"] = str(tweetdata["user"]["geo_enabled"])
        line["user_time_zone"] = str(tweetdata["user"]["time_zone"])
        line["user_statuses_count"] = str(tweetdata["user"]["statuses_count"])
        line["user_verified"] = str(tweetdata["user"]["verified"])
        line["user_description"] = tweetdata["user"]["description"].encode(
            'utf-8')

    # geo location data
    from pygeocoder import Geocoder
    try:
        geo_results = Geocoder.geocode(line["user_time_zone"])
    except:
        geo_results = "error"
    line["user_time_zone_coordinates"] = ""
    line["user_time_zone_placename"] = ""
    if geo_results != "error":
        line["user_time_zone_coordinates"] = geo_results.coordinates
        for foo in geo_results:
            line["user_time_zone_placename"] = foo
            break
    try:
        geo_results = Geocoder.geocode(line["user_location"])
    except:
        geo_results = "error"
    line["user_location_coordinates"] = ""
    line["user_location_placename"] = ""
    if geo_results != "error":
        line["user_location_coordinates"] = geo_results.coordinates
        for foo in geo_results:
            line["user_location_placename"] = foo
            break

    return line
Example #53
0
#!/usr/bin python3.6
# -*- coding: utf-8 -*-

from pygeocoder import Geocoder
from pygeolib import GeocoderError as GeocoderError

LOCATION = 'Laniakea'

try:
    print(Geocoder.geocode(LOCATION))
except GeocoderError as e:
    print(e)
# In[81]:

correlation = mass_shootings.filter(['Mental Health Issues', 'Race'])
correlation.head()
correlation = pd.get_dummies(correlation)
test = correlation.corr()

import numpy as np
condition = (test > 0.15) | (test < -0.15)
condition
test[condition]

# In[539]:

from pygeocoder import Geocoder
rresults = Geocoder.reverse_geocode(mass_shootings['Latitude'][50],
                                    mass_shootings['Longitude'][50])

# In[540]:

rresults.city

# In[528]:

mass_shootings['Latitude'] = mass_shootings['Latitude'].astype(float)
mass_shootings['Longitude'] = mass_shootings['Longitude'].astype(float)

# # Learnings
# • There is a timeline on the tableau dashboard (https://us-east-1.online.tableau.com/t/tejbirsworkspace/views/USMassshootings/Finaldashboard?:embed=y&:showAppBanner=false&:showShareOptions=true&:display_count=no&:showVizHome=no#3) that gives us the number of injured and killed people over the years.
# It is clearly seen that from 2010 onwards, there is a significant rise in the number of people affected by these activities. The deadliest years have been 2015 with 226 and 2014 with 193 reported dead people.
#
# • Visualized mass shootings on US map-
Example #55
0
from pygeocoder import Geocoder

if __name__ == '__main__':
    address = 'Tamil Nadu, India, 600127'
    print(Geocoder.geocode(address)[0].coordinates)
def get_latlongs(location):
    return Geocoder.geocode(location)[0].coordinates
Example #57
0
def generate_user_home_work(user):
    user_home = detect_home(user)
    # print user_home
    zip_is_valid = _check_zip_validity(user_home, user)
    logging.debug('starting for %s' % user)
    if Profiles.find({'user_id': user}).count() == 0:
        profile_todo = {
            'source': 'Shankari',
            'user_id': user,
            'home': user_home
        }
        Profiles.insert(profile_todo)
    else:
        #TODO: make detect_home return something better than a N/A string
        Profiles.update({"$and": [{
            'source': 'Shankari'
        }, {
            'user_id': user
        }]}, {"$set": {
            'home': user_home
        }})
    user_work = detect_work_office(user)
    Profiles.update({"$and": [{
        'source': 'Shankari'
    }, {
        'user_id': user
    }]}, {"$set": {
        'work_place': user_work
    }})
    user_zip = get_userZipcode(user, zip_is_valid)
    Profiles.update({"$and": [{
        'source': 'Shankari'
    }, {
        'user_id': user
    }]}, {"$set": {
        'zip': user_zip
    }})
    if user_zip != 'N/A':
        geoinfo = Geocoder.geocode(user_zip)
        # geocoder returns data in lat,lng format.
        # we convert to lng,lat internally, since that is the format that the
        # rest of our code is in
        zipCen = [geoinfo[0].coordinates[1], geoinfo[0].coordinates[0]]
    else:
        zipCen = 'N/A'
    Profiles.update({"$and": [{
        'source': 'Shankari'
    }, {
        'user_id': user
    }]}, {"$set": {
        'zip_centroid': zipCen
    }})

    for day in range(1, 6):
        key = 'work' + str(day)
        Profiles.update({"$and": [{
            'source': 'Shankari'
        }, {
            'user_id': user
        }]}, {"$set": {
            key: detect_daily_work_office(user, day)
        }})
Example #58
0
def geocode(address):
    if Geocoder.geocode(address).valid_address:
        result = Geocoder.geocode(address)
        return result.latitude, result.longitude, result.street_number, result.route
    else:
        return 0, 0, u'999999', u'ZZZZZZZ'
Example #59
0
from pygeocoder import Geocoder
endereco = 'avenida paulista, 100 sao paulo'
resultado = Geocoder('apikey').reverse_geocode(-23.5703022, -46.6451267)
print(resultado)
Example #60
0
 def save(self, *args, **kwargs):
     #Geocode the address
     results = Geocoder.geocode(self.province + self.city + self.address)
     self.latitude = results[0].coordinates[0]
     self.longitude = results[0].coordinates[1]
     super(Note, self).save(*args, **kwargs)