Hackathons/VTHacks13
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

fixed flask run

Browse Source
This commit is contained in:
samarthjain2023
2025-09-28 02:38:24 -04:00
parent 9fd6dc11c3
commit a97b79ee37
2 changed files with 141 additions and 52 deletions
Download Patch File Download Diff File Expand all files Collapse all files

122
roadcast/app.py
View File

@@ -1,8 +1,78 @@
from flask import Flask, request, jsonify
from dotenv import load_dotenv
from openmeteo_client import compute_index
# Load environment variables from .env file
load_dotenv()
app = Flask(__name__)
import os
import threading
import json
# ML imports are lazy to avoid heavy imports on simple runs
@app.route('/')
def home():
return "<h1>Welcome to the Flask App</h1><p>Try /get-data or /health endpoints.</p>"
@app.route('/get-data', methods=['GET'])
def get_data():
# Example GET request handler
data = {"message": "Hello from Flask!"}
return jsonify(data)
@app.route('/post-data', methods=['POST'])
def post_data():
# Example POST request handler
content = request.json
# Process content or call AI model here
response = {"you_sent": content}
return jsonify(response)
@app.route('/train', methods=['POST'])
def train_endpoint():
"""Trigger training. Expects JSON: {"data_root": "path/to/data", "epochs": 3}
Training runs in a background thread and saves model to model.pth in repo root.
"""
payload = request.json or {}
data_root = payload.get('data_root')
epochs = int(payload.get('epochs', 3))
if not data_root or not os.path.isdir(data_root):
return jsonify({"error": "data_root must be a valid directory path"}), 400
def _run_training():
from train import train
train(data_root, epochs=epochs)
t = threading.Thread(target=_run_training, daemon=True)
t.start()
return jsonify({"status": "training_started"})
@app.route('/health', methods=['GET'])
def health():
"""Return status of loaded ML artifacts (model, centers, preprocess_meta)."""
try:
from openmeteo_inference import init_inference
status = init_inference()
return jsonify({'ok': True, 'artifacts': status})
except Exception as e:
return jsonify({'ok': False, 'error': str(e)}), 500
if __name__ == '__main__':
# eager load model/artifacts at startup (best-effort)
try:
from openmeteo_inference import init_inference
init_inference()
except Exception:
pass
app.run(debug=True)
@app.route('/predict', methods=['POST', 'GET'])
def predict_endpoint():
"""Predict route between two points given source and destination with lat and lon.
Expectation:
- POST with JSON: {"source": {"lat": .., "lon": ..}, "destination": {"lat": .., "lon": ..}}
- GET returns usage instructions for quick browser testing.
@@ -18,18 +88,46 @@ def predict_endpoint():
"http://127.0.0.1:5000/predict"
)
if request.method == 'GET':
return jsonify({"info": info, "example": example_payload, "note": note}), 200
# Return the same structure as POST but without prediction
# response_payload = {
# "index": None,
# "prediction": {},
# "called_with": "GET",
# "diagnostics": {},
# "example": example_payload,
# "info": info,
# "note": note
# }
# For GET request, compute the road risk index using the example coordinates
src_lat = example_payload['source']['lat']
src_lon = example_payload['source']['lon']
dst_lat = example_payload['destination']['lat']
dst_lon = example_payload['destination']['lon']
# Use the compute_index function to get the road risk index
index = compute_index(src_lat, src_lon)
# Prepare the response payload
response_payload = {
"index": index, # The computed index here
"prediction": {},
"called_with": "GET",
"diagnostics": {},
"example": example_payload,
"info": info,
"note": note
}
return jsonify(response_payload), 200
# POST request logic
data = request.json or {}
source = data.get('source')
destination = data.get('destination')
if not source or not destination:
return jsonify({"error": "both 'source' and 'destination' fields are required"}), 400
try:
src_lat = float(source.get('lat'))
src_lon = float(source.get('lon'))
@@ -38,7 +136,6 @@ def predict_endpoint():
except (TypeError, ValueError):
return jsonify({"error": "invalid lat or lon values; must be numbers"}), 400
# Ensure compute_reroute exists and is callable
try:
from openmeteo_client import compute_reroute
@@ -50,11 +147,9 @@ def predict_endpoint():
"(Open-Meteo does not need an API key)"
}), 500
if not callable(compute_reroute):
return jsonify({"error": "openmeteo_client.compute_reroute is not callable"}), 500
def _extract_index(res):
if res is None:
return None
@@ -69,20 +164,17 @@ def predict_endpoint():
return res[k]
return None
# Call compute_reroute (Open-Meteo requires no API key)
try:
result = compute_reroute(src_lat, src_lon, dst_lat, dst_lon)
called_with = "positional"
diagnostics = {"type": type(result).__name__}
try:
diagnostics["repr"] = repr(result)[:1000]
except Exception:
diagnostics["repr"] = "<unrepr-able>"
# Normalize return types
if isinstance(result, (list, tuple)):
idx = None
@@ -102,7 +194,6 @@ def predict_endpoint():
index = None
prediction = {"value": result}
response_payload = {
"index": index,
"prediction": prediction,
@@ -113,7 +204,6 @@ def predict_endpoint():
"note": note
}
# Add warning if no routing/index info found
expected_keys = ('route', 'path', 'distance', 'directions', 'index', 'idx', 'cluster')
if (not isinstance(prediction, dict) or not any(k in prediction for k in expected_keys)) and index is None:
@@ -122,9 +212,13 @@ def predict_endpoint():
"See diagnostics for details."
)
return jsonify(response_payload), 200
return jsonify(response_payload)
except Exception as e:
return jsonify({
"error": "Error processing the request",
"detail": str(e)
}), 500
except Exception as e:
return jsonify({"error": "compute_reroute invocation failed", "detail": str(e)}), 500

71
roadcast/openmeteo_client.py
View File

@@ -294,46 +294,41 @@ def compute_reroute(
"grid_shape": (n_lat, n_lon)
}
def compute_index(lat: float,
lon: float,
max_risk: float = 10.0,
num_bins: int = 10,
risk_provider: Optional[Callable[[float, float], float]] = None) -> int:
"""
Computes and returns an index based on road risk and accident information.
def compute_index_and_reroute(lat: float,
lon: float,
api_key: Optional[str] = None,
roadrisk_url: Optional[str] = None,
max_risk: float = 10.0,
num_bins: int = 10,
reroute_kwargs: Optional[Dict[str, Any]] = None) -> Dict[str, Any]:
"""
Get road risk, map to index (1..num_bins), and attempt reroute.
reroute_kwargs forwarded to compute_reroute.
api_key/roadrisk_url accepted for compatibility but ignored by Open-Meteo implementation.
"""
if reroute_kwargs is None:
reroute_kwargs = {}
Args:
lat: Latitude of the location.
lon: Longitude of the location.
max_risk: Maximum possible road risk score.
num_bins: Number of bins to divide the risk range into.
reroute_kwargs: Optional dictionary passed to reroute logic.
risk_provider: Optional custom risk provider function.
data, features = fetch_road_risk(lat, lon, extra_params=reroute_kwargs, api_key=api_key, roadrisk_url=roadrisk_url)
road_risk = float(features.get("road_risk_score", 0.0))
Returns:
An integer index (1 to num_bins) based on computed road risk.
"""
# If a risk provider is not provided, use a default one
if risk_provider is None:
risk_provider = lambda lat, lon: get_risk_score(lat, lon)
accidents = features.get("accidents") or features.get("accident_count")
try:
if accidents is not None:
# fallback: map accident count to index if present
from .models import accidents_to_bucket # may not exist; wrapped in try
idx = accidents_to_bucket(int(accidents), max_count=20000, num_bins=num_bins)
else:
idx = risk_to_index(road_risk, max_risk=max_risk, num_bins=num_bins)
except Exception:
idx = risk_to_index(road_risk, max_risk=max_risk, num_bins=num_bins)
# Fetch road risk score using the provided risk provider
road_risk = float(risk_provider(lat, lon))
def _rp(lat_, lon_):
return get_risk_score(lat_, lon_, api_key=api_key, roadrisk_url=roadrisk_url)
# Compute the index based on road risk score and the max_risk, num_bins parameters
# The formula will divide the risk score into `num_bins` bins
# The index will be a number between 1 and num_bins based on the risk score
reroute_info = compute_reroute(lat, lon, risk_provider=_rp, **reroute_kwargs)
return {
"lat": lat,
"lon": lon,
"index": int(idx),
"road_risk_score": road_risk,
"features": features,
"reroute": reroute_info,
"raw_roadrisk_response": data,
}
# Normalize the risk score to be between 0 and max_risk
normalized_risk = min(road_risk, max_risk) / max_risk
# Compute the index based on the normalized risk score
index = int(normalized_risk * num_bins)
# Ensure the index is within the expected range of 1 to num_bins
return max(1, min(index + 1, num_bins)) # Adding 1 because index is 0-based