def loc():
if request.method == 'GET':
ghash = request.args.get("hash")
try:
count = redis_geohash.get(ghash).decode("utf-8")
except:
count = 0
return jsonify({ghash: count})
if request.method == 'POST':
lat = request.args.get("lat")
lon = request.args.get("lon")
for i in range(12):
ghash = geohash.encode(lat, lon, precision=i)
redis_geohash.incr(ghash, 1)
redis_geohash.expire(ghash, 3600)
log.info("lat={}, lon={}, hash={}".format(lat, lon, ghash))
return jsonify()
def searchRides(request):
if request.method == 'GET':
data = request.GET.dict()
data['user'] = request.user
ride = Ride(**data)
try:
ride.full_clean()
except Exception as e:
return sendResponse(False, e)
ride.startHash = geohash.encode(float(ride.startX), float(ride.startY),
PRECISION)
ride.endHash = geohash.encode(float(ride.endX), float(ride.endY),
PRECISION)
#also include rides from upto MINUTES_CUTOFF minutes ago
ride.time = make_aware(
ride.time) - datetime.timedelta(minutes=MINUTES_CUTOFF)
#Neighbouring geohash blocks for start and end points
startNeighbours = findNeighbours(ride.startHash)
endNeighbours = findNeighbours(ride.endHash)
#slice first PRECISION-VARY_PREC no of characters from the hash for preliminary database search
likeStartHash = ride.startHash[:PRECISION - VARY_PREC]
likeEndHash = ride.endHash[:PRECISION - VARY_PREC]
#generate regex string to match
startRegex = makeRegex(startNeighbours)
endRegex = makeRegex(endNeighbours)
queryRides = Ride.objects.filter(~Q(user__username=ride.user.username),
startHash__startswith=likeStartHash,
endHash__startswith=likeEndHash,
isActive=True,
time__gte=ride.time)
queryRides = queryRides.filter(
startHash__regex=startRegex,
endHash__regex=endRegex).order_by('time')
for q in queryRides:
q.time = localtime(q.time)
queryRides = parseRides(queryRides)
return sendResponse(True, queryRides)
return sendResponse(False, 'Incorrect method')
def insertRide(request):
if request.method == 'GET':
data = request.GET.dict()
data['user'] = request.user
data['isActive'] = True
ride = Ride(**data)
try:
ride.full_clean()
except Exception as e:
return sendResponse(False, e)
ride.startHash = geohash.encode(float(ride.startX), float(ride.startY),
PRECISION + 1)
ride.endHash = geohash.encode(float(ride.endX), float(ride.endY),
PRECISION + 1)
ride.time = make_aware(ride.time)
ride.save()
return sendResponse(True, None)
def locate(news_lst, city) :
'''Temporary geohasher assigns random locations based on city parameter; also
assigns unique id's
ARGS
---
news_lst : list of news articles in format ...
city (string) : collection id
RETURNS
---
list of news articles in format ...
'''
#long beach values
if (city == "long-beach"):
max_lat = 33.8765
min_lat = 33.7664
max_lon = -118.0997
min_lon = -118.2042
#cerritos values
elif (city == "cerritos"):
max_lat = 33.8879
min_lat = 33.8459
max_lon = -118.0287
min_lon = -118.1085
#
#bellflower values
elif (city == "bellflower"):
max_lat = 33.9105
min_lat = 33.8656
max_lon = -118.1067
min_lon = -118.1514
#
#lakewood values
elif (city == "lakewood"):
max_lat = 33.8692
min_lat = 33.8202
max_lon = -118.0590
min_lon = -118.1677
rand.seed()
#
for item in news_lst :
lati = min_lat + (max_lat-min_lat)*rand.random()
lon = min_lon + (max_lon-min_lon)*rand.random()
ghash = geohash.encode(lati, lon, 7)
loncoord = float(geohash.decode(ghash).lon)
latcoord = float(geohash.decode(ghash).lat)
item["geohash"] = ghash
item["id"] = gen_id(item)
item["coordinates"] = firestore.GeoPoint(latcoord, loncoord)
return news_lst
def process(self):
event = self.receive_message()
for key in ['source.geolocation.', 'destination.geolocation.']:
latitude_key = key + "latitude"
longitude_key = key + "longitude"
geohash_key = "extra." + key + "geohash"
if not (latitude_key in event and longitude_key in event):
continue
event.add(geohash_key,
geohash.encode(event[latitude_key],
event[longitude_key],
precision=self.parameters.precision),
overwrite=self.parameters.overwrite)
self.send_message(event)
self.acknowledge_message()
def __persist_charge_state(self, vehicle):
# get the charge_state: this contains battery information
try:
charge_state = vehicle.get_charge_state()
self.__telegrafClient.metric('battery_level',
charge_state['battery_level'],
tags={
'vehicleID':
str(vehicle.get_vehicleID()),
'vehicle_name':
vehicle.get_vehicle_name()
})
self.__telegrafClient.metric('battery_range',
charge_state['ideal_battery_range'],
tags={
'vehicleID':
str(vehicle.get_vehicleID()),
'vehicle_name':
vehicle.get_vehicle_name()
})
if (charge_state['charging_state'].upper() == 'Charging'.upper()):
location = geohash.encode(charge_state['latitude'],
charge_state['longitude'], 7)
logging.info(
str(datetime.datetime.now()) +
'==> Charging on location: ' + location +
' with value : ' +
str(charge_state['charge_energy_added']))
self.__telegrafClient.metric(
'charge_energy_added',
charge_state['charge_energy_added'],
tags={
'vehicleID': str(vehicle.get_vehicleID()),
'vehicle_name': vehicle.get_vehicle_name(),
'location': location
})
except Exception as e:
logging.error(
str(datetime.datetime.now()) +
'==> PersistTimeSeries.__persist_charge_state ==> failed ' +
str(e))
def geohash(lat_lon=Tuple[float, float]) -> str:
return gh.encode(*lat_lon, PRECISION)
# end::GEOHASH[]
def geohash(lat_lon: Coordinate) -> str:
return gh.encode(*lat_lon, PRECISION)
def test_encode():
assert geohash.encode('68', '-23', 1) == 'g'
assert geohash.encode('70.3', '-28', 2) == 'gk'
assert geohash.encode('70.2995', '-27.9993', 7) == 'gkkpfve'
def geohash(lat_lon: tuple[float, float]) -> str:
return gh.encode(*lat_lon, PRECISION)
