Nathaniel - ETA API

.gitignore

@@ -1,3 +1,4 @@
+.DS_Store
 # Byte-compiled / optimized / DLL files
 __pycache__/
 *.py[cod]
@@ -126,4 +127,4 @@ venv.bak/
 dmypy.json
 
 # Pyre type checker
-.pyre/
+.pyre/

eta_microservice/README.md

@@ -0,0 +1,49 @@
+# ETA Microservice
+
+A Flask microservice that updates the PostgreSQL database with the ETA (in mins) from the inputted point to the checkpoints in the checkpoint_model_db.csv file.
+
+## Setup
+
+### Python install
+
+Install Python 3 on your system. To test, open a command prompt or a terminal and write `python3` or `py`.
+
+### Project setup
+
+Once Python is installed, clone this repo into your editor of choice.
+
+Cloning the repository will create a new folder named `victini-microservices` with all the code -- you will have 'cloned' the repository!
+
+Once cloned, run `cd victini-microservices/eta_microservice` to go into the new folder.
+
+First, set up a virtual environment using `python3 -m venv`. This will create a `venv/` folder in your directory and isolate all of the porpject dependencies from other projects.
+
+To source this environment run `source venv/bin/activate`.
+
+Then, to install the project dependencies, run `pip install -r requirements.txt` -- this will install all the libraries listed in the `requirements.txt` file.
+
+### Database Setup
+
+To setup the database, run the SQL script found in the schemas folder to create the table. The table should have columns: id, lat, long and eta.
+
+### Connection Setup
+
+Once the DB is setup, navigate to the `.env` file and ensure that the DB connection details are correctly populated.
+
+### Running the Microservice
+
+After ensuring that you're in the `eta_microservice` folder and running your **virtual environment**, run `python main.py` to start the microservice.
+
+The terminal should show that the Flask app is running on localhost on port 6000.
+
+### Calculating ETA
+
+With the microservice running, you can send a POST request for the `calculate_eta` function to run. 
+
+Using tool like Postman, send a POST request like `http://localhost:6000/calculate_eta` and ensure that the **lat** and **long** and included in the **JSON** file:
+
+eg. `{"lat": 43.46786317655638, "lon": -80.56637564010215}`
+
+Update the checkpoints table to see the new point and the list of ETAs to each checkpoint.
+
+If a checkpoint has already been passed or an error occurred while calculating the ETA, -1.0 will be the ETA.

eta_microservice/Schemas/checkpoints_DDL.sql

@@ -0,0 +1,6 @@
+CREATE TABLE public.checkpoints (
+	id int4 NULL,
+	lat float8 NULL,
+	lon float8 NULL,
+	eta _float8 NULL
+);

eta_microservice/current_location.txt

@@ -0,0 +1,3 @@
+43.46786317655638, -80.56637564010215
+
+This location can be used for testing purposes. Alternatively, any point from the route_model_db.csv in data folder can be used.

eta_microservice/data/checkpoint_model_db.csv

@@ -0,0 +1,8 @@
+latitude,longitude,route_model_index,last_updated,forecast_time
+43.46786317655638,-80.56637564010215,0,,
+43.47181929178542,-80.55498944295489,41,,
+43.47567782098289,-80.54387952656383,81,,
+43.47953526800491,-80.53276819650009,121,,
+43.48532332236007,-80.52733698515767,162,,
+43.49079136987552,-80.53590572263501,205,,
+43.49414882508247,-80.54735874761738,246,,

eta_microservice/data/route.csv

@@ -0,0 +1,10 @@
+43.46786317655638, -80.56637564010215
+43.48175280991097, -80.52637854159468
+43.48536483714299, -80.5270651870626
+43.48511573875007, -80.52869597004897
+43.48536483714299, -80.52989759961787
+43.48604985242712, -80.5304984144023
+43.48816712335336, -80.5320433668198
+43.489910702452285, -80.53461828732458
+43.49196557034531, -80.53762236124682
+43.494347261633344, -80.5482439084337

eta_microservice/eta.py

@@ -0,0 +1,98 @@
+import sys
+import os.path
+sys.path.append(os.path.dirname(sys.path[0]))
+
+import pandas as pd
+from geopy.distance import distance as geodist
+import math  
+
+class ETAQuery():
+    def __init__(self, lat, lon):
+        self.lat = lat
+        self.lon = lon
+        route_model_path = os.path.normpath(os.path.join(os.path.dirname(os.path.abspath(__file__)), '..', 'eta_microservice', 'data', 'route_model_db.csv')) #changed it for interoperability between unix and windows
+        checkpoint_model_path = os.path.normpath(os.path.join(os.path.dirname(os.path.abspath(__file__)), '..', 'eta_microservice', 'data', 'checkpoint_model_db.csv'))
+        # Read CSV files
+        self.route_model = pd.read_csv(route_model_path)
+        self.checkpoint_model = pd.read_csv(checkpoint_model_path)
+
+        self.checkpoint_coords = self.checkpoint_model.loc[:, ['latitude', 'longitude']].values.tolist()
+        self.ckpt_to_route_model_index = self.checkpoint_model.loc[:, ['route_model_index']].values.tolist()
+        self.eta_to_checkpoint = []
+        self.speed = self.get_speed_at_point(lat, lon) # Speed in km/h
+
+        self.generate_eta()
+
+    def get_speed_at_point(self, lat, lon):
+        return 5 # TODO: Take speed from route model after it is precomputed
+
+    def find_closest_point(self, lat, lon):
+        '''
+        The function takes in a coordinate point (lat/lon) and finds the closest point to it inside the route model 
+        @param lat: float representing the latitude
+        @param lon: float representing the longitude
+        @return: a row of the route_model dataframe containing information about the closest point on the race route
+        '''
+
+        distances = self.route_model.apply(lambda row: geodist((lat, lon), (row['latitude'], row['longitude'])).meters, axis=1)
+        return self.route_model.iloc[distances.idxmin()]
+
+    def generate_eta(self):
+        """
+        @return: a list of float values representing the time it takes to reach the checkpoints
+        """
+        closest_point = self.find_closest_point(self.lat, self.lon)
+        current_checkpoint = closest_point['checkpoint']
+        next_closest_checkpoint = current_checkpoint + 1
+
+        n = len(self.checkpoint_coords)
+
+        # Modified to instantiate eta list with -1.0 instead of -1 since returned eta will be a float
+        eta = [-1.0 for _ in range(n)] 
+
+        if next_closest_checkpoint >= n:
+            self.eta = eta
+            return self.eta
+
+        slat = self.lat
+        slon = self.lon
+        elat = self.checkpoint_coords[next_closest_checkpoint][0]
+        elon = self.checkpoint_coords[next_closest_checkpoint][1]
+
+        dist_to_next_checkpoint = geodist((slat, slon), (elat, elon)).meters
+        # Unit conversion is to put meters into kilometers and time into minutes
+        eta[next_closest_checkpoint] = (dist_to_next_checkpoint / 1000) / self.speed * 60
+
+        for future_checkpoint in range(next_closest_checkpoint + 1, n): 
+            a = self.ckpt_to_route_model_index[next_closest_checkpoint][0] 
+            b = self.ckpt_to_route_model_index[future_checkpoint]
+
+            print(self.route_model.iloc[b]['trip(m)'])
+
+            # Unit conversion is to put meters into kilometers and time into minutes
+            eta_next_to_future = ((self.route_model.iloc[b]['trip(m)'] - self.route_model.iloc[a]['trip(m)']) / 1000) / self.speed * 60
+            eta_value = eta[next_closest_checkpoint] + float(eta_next_to_future.iloc[0])
+
+            # Additional check for NaN -> leave it as -1.0 in the list
+            if not math.isnan(eta_value):
+                eta[future_checkpoint] = eta_value
+
+        self.eta = eta
+        return eta
+
+    def get_times(self):
+        """
+        @return: a list of float values representing the time it takes to reach the checkpoints
+        """
+        return self.eta
+
+
+    def get_time_to_point(self, lat, lon):
+        """
+        @return: float representing the time it takes to reach a given point
+        """
+        closest_point = self.find_closest_point(lat, lon)
+        return self.eta[closest_point['checkpoint']]
+
+
+

eta_microservice/main.py

@@ -0,0 +1,68 @@
+import sys
+import os.path
+sys.path.append(os.path.dirname(sys.path[0]))
+
+import psycopg2
+import pandas as pd
+from geopy.distance import distance as geodist
+from flask import Flask, request, jsonify
+from dotenv import load_dotenv
+from eta import ETAQuery  
+
+load_dotenv()
+
+app = Flask(__name__)
+
+# Retrieve environment variables from .env file
+DB_HOST = os.getenv("DATABASE_HOST")
+DB_PORT = int(os.getenv("DATABASE_PORT"))
+DB_NAME = os.getenv("DATABASE_NAME")
+DB_USER = os.getenv("DATABASE_USER")
+DB_PASSWORD = os.getenv("DATABASE_PASSWORD")
+
+# DB connection
+connection = psycopg2.connect(
+    host=DB_HOST,
+    port=DB_PORT,
+    database=DB_NAME,
+    user=DB_USER,
+    password=DB_PASSWORD
+)
+
+# Calculate_eta method requires that the new (lat, lon) position be inputted as json data -> eta appended to DB will be for all points in route.csv
+@app.route('/calculate_eta', methods=['POST']) 
+def calculate_eta():
+    try:
+        data = request.get_json()
+        lat = data.get('lat')
+        lon = data.get('lon')
+
+        # Invalid lat or lon
+        if lat is None or lon is None:
+            return jsonify({'error': 'Invalid request data'}), 400
+
+        eta_query = ETAQuery(lat, lon)
+        eta_values = eta_query.get_times()
+
+        # Insert a new row with lat, lon, and calculated eta (in mins)
+        with connection.cursor() as cursor:
+            # Find the maximum id in the table (ie. newest row) -> if no checkpoints, instantiate with 0
+            cursor.execute("SELECT MAX(id) FROM public.checkpoints")
+            max_id = cursor.fetchone()[0] or 0 
+
+            # Insert the new row with an incremented id
+            cursor.execute(
+                "INSERT INTO public.checkpoints (id, lat, lon, eta) VALUES (%s, %s, %s, %s)",
+                (max_id + 1, lat, lon, eta_values)
+            )
+            connection.commit()
+
+        # Successful calculation and DB change
+        return jsonify({'message': 'New row created with calculated ETA.', 'id': max_id + 1}), 200
+
+    # Error message
+    except Exception as e:
+        return jsonify({'error': str(e)}), 500
+
+if __name__ == '__main__':
+    app.run(host='0.0.0.0', port=6000) 

eta_microservice/requirements.txt

@@ -0,0 +1,6 @@
+Flask==3.0.0
+psycopg2==2.9.9
+numpy==1.26.1
+pandas==2.1.2
+geopy==2.4.0
+python-dotenv==1.0.0