From 7fb9bdef13cf0c05a67cba69b5511b481594edeb Mon Sep 17 00:00:00 2001 From: Cursor Agent Date: Tue, 28 Jul 2026 15:53:54 +0000 Subject: [PATCH 1/3] fix(time): gracefully parse free-form departure times Empty minutes on the split HH/MM fields produced a NaN validation error loop (e.g. typing 08 / 0800 with blank MM). Accept compact forms like 0800 and 0800 AM on both the frontend and backend normalizer, default missing parts, and cover with unit tests. Co-authored-by: jssturm --- app/engine/planner.py | 83 ++++++++++----- static/app.html | 4 +- static/js/app.js | 235 +++++++++++++++++++++++++++++++---------- static/js/i18n.js | 4 +- test_normalize_time.py | 37 +++++++ 5 files changed, 279 insertions(+), 84 deletions(-) create mode 100644 test_normalize_time.py diff --git a/app/engine/planner.py b/app/engine/planner.py index a13f5b9..2efe400 100644 --- a/app/engine/planner.py +++ b/app/engine/planner.py @@ -1354,40 +1354,75 @@ def _fmt_time(hour: int, minute: int) -> str: # --------------------------------------------------------------------------- +def _to_24h(hour: int, meridiem: str | None) -> int | None: + """Convert hour + optional AM/PM to 24-hour clock, or None if invalid.""" + if meridiem: + if hour < 1 or hour > 12: + return None + if meridiem == "AM" and hour == 12: + return 0 + if meridiem == "PM" and hour != 12: + return hour + 12 + return hour + # No meridiem: treat as 24-hour when hour >= 13, else leave as-is (AM-ish). + if hour < 0 or hour > 23: + return None + return hour + + def _normalize_departure_time(raw: str) -> str: """Normalize a user-entered departure time string to 'HH:MM AM/PM' format. - Accepts '7:00 AM', '07:00', '7am', '0700', '7:00AM', etc. + Accepts '7:00 AM', '07:00', '7am', '0700', '0800 AM', '7:00AM', bare + hour integers, and similar free-form variants. Returns the normalized time string or the raw input if unparseable. """ - stripped = raw.strip().upper() - # Try "H:MM AM/PM" or "HH:MM AM/PM" - m = re.match(r'(\d{1,2}):(\d{2})\s*(AM|PM)?', stripped) + stripped = re.sub(r"[.\u00b7]", ":", raw.strip().upper()) + stripped = re.sub(r"\s+", " ", stripped).strip() + + def _finish(hour: int, minute: int, meridiem: str | None) -> str | None: + if minute < 0 or minute > 59: + return None + hour_24 = _to_24h(hour, meridiem) + if hour_24 is None: + return None + return _fmt_time(hour_24, minute) + + # Try "H:MM AM/PM" or "HH:MM AM/PM" (optional colon variants already normalized) + m = re.match(r"^(\d{1,2}):(\d{2})\s*(AM|PM)?$", stripped) if m: - hour = int(m.group(1)) - minute = int(m.group(2)) - meridiem = m.group(3) or ('AM' if hour < 12 else 'PM') - # Convert to 24-hour for _fmt_time: - # - 12:xx AM → hour 0 (midnight) - # - 12:xx PM → hour 12 (noon, unchanged) - # - AM otherwise → hour unchanged - # - PM otherwise → hour + 12 - if meridiem == 'AM' and hour == 12: - hour = 0 - elif meridiem == 'PM' and hour != 12: - hour += 12 - return _fmt_time(hour, minute) - # Try "7am", "7 AM", "07:00AM" etc without minutes - m = re.match(r'(\d{1,2})\s*(AM|PM)', stripped) + result = _finish(int(m.group(1)), int(m.group(2)), m.group(3)) + if result: + return result + + # Compact HHmm / Hmm with optional AM/PM: "0700", "800", "0800 AM", "0800AM" + m = re.match(r"^(\d{3,4})\s*(AM|PM)?$", stripped) if m: - hour = int(m.group(1)) + digits = m.group(1) meridiem = m.group(2) - return _fmt_time(hour if meridiem == 'AM' or hour == 12 else hour + 12, 0) + if len(digits) == 3: + hour, minute = int(digits[0]), int(digits[1:]) + else: + hour, minute = int(digits[:2]), int(digits[2:]) + # With AM/PM, hour must be 1–12; without, allow 00–23 military style. + result = _finish(hour, minute, meridiem) + if result: + return result + + # Try "7am", "7 AM", "08AM" etc without minutes + m = re.match(r"^(\d{1,2})\s*(AM|PM)$", stripped) + if m: + result = _finish(int(m.group(1)), 0, m.group(2)) + if result: + return result + # Try bare hour like "7", "14" - m = re.match(r'^(\d{1,2})$', stripped) + m = re.match(r"^(\d{1,2})$", stripped) if m: - hour = int(m.group(1)) - return _fmt_time(hour, 0) + result = _finish(int(m.group(1)), 0, None) + if result: + return result + # Return as-is; _parse_time will handle fallback return raw diff --git a/static/app.html b/static/app.html index 47d658e..e7b4918 100644 --- a/static/app.html +++ b/static/app.html @@ -124,7 +124,7 @@

Plan Your Trip

+ placeholder="07" maxlength="4" autocomplete="off" /> : @@ -133,7 +133,7 @@

Plan Your Trip

-
When you plan to leave. Enter the time and select AM or PM.
+
When you plan to leave. Enter a time like 8:00, 0800, or 8am, and select AM or PM.
diff --git a/static/js/app.js b/static/js/app.js index ded9d22..056054b 100644 --- a/static/js/app.js +++ b/static/js/app.js @@ -435,16 +435,25 @@ const departurePeriod = getSelectedPeriod(); var departure = ""; if (hh || mm) { - // Validate time before constructing the departure string - var timeErr = validateTimeInput(hh, mm); - if (timeErr) { - showToast(timeErr, "error"); + // Extract a valid time from whatever the user typed (08 + blank, + // compact 0800, 8am, etc.) instead of hard-failing into a toast loop. + var parsedDep = parseFlexibleDeparture(hh, mm, departurePeriod); + if (!parsedDep) { + showToast(t("error.validTime"), "error"); $btnGenerate.disabled = false; $btnGenerate.innerHTML = "🚀 Generate Itinerary"; return; } - departure = (hh || "00") + ":" + (mm || "00"); - if (departurePeriod) departure = departure + " " + departurePeriod; + // Reflect the normalized values back into the fields + if ($tripDepartureHh) $tripDepartureHh.value = parsedDep.hh; + if ($tripDepartureMm) $tripDepartureMm.value = parsedDep.mm; + if ($tripDepartureAmpm) { + var buttons = $tripDepartureAmpm.querySelectorAll(".ampm-btn"); + buttons.forEach(function (b) { + b.classList.toggle("active", b.dataset.period === parsedDep.period); + }); + } + departure = parsedDep.hh + ":" + parsedDep.mm + " " + parsedDep.period; } const restaurants = $tripRestaurants.value.trim(); if (start) payload.starting_location = start; @@ -1079,7 +1088,7 @@
- +
@@ -1107,21 +1116,20 @@ updates[key] = val; }); - // Validate time if it was edited + // Normalize free-form time (0800, 8:00, 8am, etc.) then reassemble with AM/PM if (updates.time) { - var editTimeErr = validateTimeString(updates.time); - if (editTimeErr) { - showToast(editTimeErr, "error"); + var modalAmpmEdit = $modalContainer.querySelector(".modal-ampm"); + var editPeriod = "AM"; + if (modalAmpmEdit) { + var editActive = modalAmpmEdit.querySelector(".ampm-btn.active"); + editPeriod = editActive ? editActive.dataset.period : "AM"; + } + var parsedEdit = parseFlexibleTimeString(updates.time, editPeriod); + if (!parsedEdit) { + showToast(t("error.validTime"), "error"); return; } - } - - // Reassemble time from HH:MM input + AM/PM toggle in modal - var modalAmpm = $modalContainer.querySelector(".modal-ampm"); - if (modalAmpm && updates.time) { - var activeBtn = modalAmpm.querySelector(".ampm-btn.active"); - var period = activeBtn ? activeBtn.dataset.period : "AM"; - updates.time = updates.time + " " + period; + updates.time = parsedEdit.hh + ":" + parsedEdit.mm + " " + parsedEdit.period; } try { @@ -1163,7 +1171,7 @@
- +
@@ -1218,16 +1226,28 @@
`, async () => { - var addTime = document.getElementById("add-time").value.trim(); - var addAmpm = $modalContainer.querySelector(".modal-ampm-add"); - if (addAmpm && addTime) { - var activeBtn = addAmpm.querySelector(".ampm-btn.active"); - var period = activeBtn ? activeBtn.dataset.period : "AM"; - addTime = addTime + " " + period; + var addTimeRaw = document.getElementById("add-time").value.trim(); + var addAction = document.getElementById("add-action").value.trim(); + if (!addTimeRaw || !addAction) { + showToast(t("error.timeRequired"), "error"); + return; } + + var addAmpmEl = $modalContainer.querySelector(".modal-ampm-add"); + var addPeriod = "AM"; + if (addAmpmEl) { + var addActive = addAmpmEl.querySelector(".ampm-btn.active"); + addPeriod = addActive ? addActive.dataset.period : "AM"; + } + var parsedAdd = parseFlexibleTimeString(addTimeRaw, addPeriod); + if (!parsedAdd) { + showToast(t("error.validTime"), "error"); + return; + } + const scheduleItem = { - time: addTime, - action: document.getElementById("add-action").value.trim(), + time: parsedAdd.hh + ":" + parsedAdd.mm + " " + parsedAdd.period, + action: addAction, priority: document.getElementById("add-priority").value, walking_time_min: parseOrNull(document.getElementById("add-walk").value), wait_time_min: parseOrNull(document.getElementById("add-wait").value), @@ -1236,18 +1256,6 @@ backup_plan: document.getElementById("add-backup").value.trim() || null, }; - if (!scheduleItem.time || !scheduleItem.action) { - showToast(t("error.timeRequired"), "error"); - return; - } - - // Validate the time format (HH:MM, 1-12 hours, 0-59 minutes) - var timeStrErr = validateTimeString(addTime); - if (timeStrErr) { - showToast(timeStrErr, "error"); - return; - } - const position = Array.isArray(plan.schedule) ? plan.schedule.length : 0; try { @@ -1343,14 +1351,50 @@ if (firstBtn) firstBtn.focus(); } }); - // Allow only digits in time fields + // Allow digits in time fields; if a compact HHmm is typed/pasted into hours, + // split it across HH + MM so "0800" becomes 08:00 instead of erroring. [$tripDepartureHh, $tripDepartureMm].forEach(function (el) { el.addEventListener("input", function () { el.value = el.value.replace(/[^0-9]/g, ""); + if (el === $tripDepartureHh && el.value.length >= 3) { + var compact = parseFlexibleTimeString(el.value, getSelectedPeriod()); + if (compact) { + $tripDepartureHh.value = compact.hh; + $tripDepartureMm.value = compact.mm; + if ($tripDepartureAmpm) { + $tripDepartureAmpm.querySelectorAll(".ampm-btn").forEach(function (b) { + b.classList.toggle("active", b.dataset.period === compact.period); + }); + } + $tripDepartureMm.focus(); + } + } }); }); - // Clamp hours to 1-12 and minutes to 0-59 on blur + $tripDepartureHh.addEventListener("paste", function (e) { + var text = (e.clipboardData || window.clipboardData).getData("text") || ""; + var parsed = parseFlexibleTimeString(text.trim(), getSelectedPeriod()); + if (parsed) { + e.preventDefault(); + $tripDepartureHh.value = parsed.hh; + $tripDepartureMm.value = parsed.mm; + if ($tripDepartureAmpm) { + $tripDepartureAmpm.querySelectorAll(".ampm-btn").forEach(function (b) { + b.classList.toggle("active", b.dataset.period === parsed.period); + }); + } + } + }); + // Clamp hours to 1-12 and minutes to 0-59 on blur (after compact split) $tripDepartureHh.addEventListener("blur", function () { + if ($tripDepartureHh.value.length >= 3) { + var compactBlur = parseFlexibleTimeString($tripDepartureHh.value, getSelectedPeriod()); + if (compactBlur) { + $tripDepartureHh.value = compactBlur.hh; + if (!$tripDepartureMm.value) $tripDepartureMm.value = compactBlur.mm; + return; + } + } var v = parseInt($tripDepartureHh.value, 10); if ($tripDepartureHh.value !== "" && (isNaN(v) || v < 1)) $tripDepartureHh.value = "1"; else if (v > 12) $tripDepartureHh.value = "12"; @@ -1810,21 +1854,106 @@ } /* ------------------------------------------------------------------------ - Time Validation + Time Validation / Flexible Parsing ------------------------------------------------------------------------ */ + /** + * Parse a free-form time string into { hh, mm, period }. + * Accepts: 7:00 AM, 07:00, 7am, 0700, 0800 AM, 8, etc. + * @param {string} timeStr + * @param {string} [defaultPeriod="AM"] used when input has no AM/PM and hour ≤ 12 + * @returns {{hh: string, mm: string, period: string}|null} + */ + function parseFlexibleTimeString(timeStr, defaultPeriod) { + if (!timeStr || !String(timeStr).trim()) return null; + var stripped = String(timeStr).trim().toUpperCase().replace(/[.\u00b7]/g, ":"); + stripped = stripped.replace(/\s+/g, " ").trim(); + var periodDefault = defaultPeriod === "PM" ? "PM" : "AM"; + + function finish(hour, minute, meridiem) { + if (isNaN(hour) || isNaN(minute) || minute < 0 || minute > 59) return null; + var period = meridiem || null; + if (period) { + if (hour < 1 || hour > 12) return null; + } else if (hour >= 0 && hour <= 23) { + // Military / 24-hour style without AM/PM + if (hour === 0) { + hour = 12; + period = "AM"; + } else if (hour === 12) { + period = "PM"; + } else if (hour > 12) { + hour = hour - 12; + period = "PM"; + } else { + period = periodDefault; + } + } else { + return null; + } + return { + hh: String(hour).padStart(2, "0"), + mm: String(minute).padStart(2, "0"), + period: period, + }; + } + + var m = stripped.match(/^(\d{1,2}):(\d{2})\s*(AM|PM)?$/); + if (m) return finish(parseInt(m[1], 10), parseInt(m[2], 10), m[3] || null); + + m = stripped.match(/^(\d{3,4})\s*(AM|PM)?$/); + if (m) { + var digits = m[1]; + var hour = digits.length === 3 ? parseInt(digits[0], 10) : parseInt(digits.slice(0, 2), 10); + var minute = parseInt(digits.slice(-2), 10); + return finish(hour, minute, m[2] || null); + } + + m = stripped.match(/^(\d{1,2})\s*(AM|PM)$/); + if (m) return finish(parseInt(m[1], 10), 0, m[2]); + + m = stripped.match(/^(\d{1,2})$/); + if (m) return finish(parseInt(m[1], 10), 0, null); + + return null; + } + + /** + * Parse homepage split HH / MM fields, including compact paste into HH ("0800"). + */ + function parseFlexibleDeparture(hh, mm, period) { + hh = (hh || "").trim(); + mm = (mm || "").trim(); + period = period === "PM" ? "PM" : "AM"; + + // Compact / free-form typed into the hour field (pasted 0800, 8am, etc.) + if (hh && !mm && !/^\d{1,2}$/.test(hh)) { + return parseFlexibleTimeString(hh, period); + } + // Hour field holds a full compact time while minutes also filled — prefer hh alone + if (/^\d{3,4}$/.test(hh)) { + return parseFlexibleTimeString(hh + (/\b(AM|PM)\b/i.test(hh) ? "" : " " + period), period); + } + + var raw = hh || ""; + if (mm) { + raw = (hh || "12") + ":" + mm.padStart(2, "0"); + } else if (hh) { + raw = hh + ":00"; + } else { + return null; + } + return parseFlexibleTimeString(raw + " " + period, period); + } + /** * Validate a 12-hour time entry (HH:MM with AM/PM). * Returns null if valid, or an error message string if invalid. + * Empty is allowed; missing minutes default to 00. */ function validateTimeInput(hh, mm) { if (!hh && !mm) return null; // empty is fine — time is optional - var hours = parseInt(hh, 10); - var minutes = parseInt(mm, 10); - if (isNaN(hours) || isNaN(minutes)) return t("error.validTime"); - if (hours < 1 || hours > 12) return t("error.hourRange"); - if (minutes < 0 || minutes > 59) return t("error.minuteRange"); - return null; + return parseFlexibleDeparture(hh, mm, "AM") ? null : t("error.validTime"); } /** @@ -1833,13 +1962,7 @@ */ function validateTimeString(timeStr) { if (!timeStr) return null; // empty is fine - var match = timeStr.match(/^(\d{1,2}):(\d{2})$/); - if (!match) return t("error.timeFormat"); - var hours = parseInt(match[1], 10); - var minutes = parseInt(match[2], 10); - if (hours < 1 || hours > 12) return t("error.hourRange12"); - if (minutes < 0 || minutes > 59) return t("error.minuteRange"); - return null; + return parseFlexibleTimeString(timeStr, "AM") ? null : t("error.timeFormat"); } /* ------------------------------------------------------------------------ diff --git a/static/js/i18n.js b/static/js/i18n.js index efc4a0e..4f17171 100644 --- a/static/js/i18n.js +++ b/static/js/i18n.js @@ -53,7 +53,7 @@ "newTrip.tripPlaceholder": "e.g. Drive to Kennedy Space Center from Orlando tomorrow — stop for lunch, stay overnight at a hotel near Cocoa Beach, and drive back the next morning. Need long-term parking at KSC.", "newTrip.tripHint": "Include as many details as possible — venue, date, mode of travel (drive/fly), meal stops, hotel stays, long-term parking, return trip, and any special interests. The more details you provide, the better your itinerary.", "newTrip.departureTime": "Departure Time", - "newTrip.departureHint": "When you plan to leave. Enter the time and select AM or PM.", + "newTrip.departureHint": "When you plan to leave. Enter a time like 8:00, 0800, or 8am, and select AM or PM.", "newTrip.startingLocation": "Starting Location (Street Address, City, State, Zip Code)", "newTrip.startPlaceholder": "e.g. 9801 International Dr, Orlando, Florida 32819", "newTrip.startHint": "Required if provided — must include street address, city, state, and zip code, separated by commas.", @@ -254,7 +254,7 @@ "newTrip.tripPlaceholder": "Ej. Conducir al Centro Espacial Kennedy desde Orlando mañana — parar para almorzar, pasar la noche en un hotel cerca de Cocoa Beach y volver a la mañana siguiente. Necesito estacionamiento de larga estadía en KSC.", "newTrip.tripHint": "Incluye tantos detalles como sea posible — lugar, fecha, modo de viaje (coche/avión), paradas para comer, estancias en hotel, estacionamiento de larga estadía, viaje de regreso e intereses especiales. Cuantos más detalles, mejor será tu itinerario.", "newTrip.departureTime": "Hora de Salida", - "newTrip.departureHint": "Cuándo planeas salir. Ingresa la hora y selecciona AM o PM.", + "newTrip.departureHint": "Cuándo planeas salir. Ingresa una hora como 8:00, 0800 o 8am, y selecciona AM o PM.", "newTrip.startingLocation": "Lugar de Partida (Dirección, Ciudad, Estado, Código Postal)", "newTrip.startPlaceholder": "Ej. 9801 International Dr, Orlando, Florida 32819", "newTrip.startHint": "Obligatorio si se proporciona — debe incluir dirección, ciudad, estado y código postal, separados por comas.", diff --git a/test_normalize_time.py b/test_normalize_time.py new file mode 100644 index 0000000..d12d34b --- /dev/null +++ b/test_normalize_time.py @@ -0,0 +1,37 @@ +"""Unit tests for departure-time normalization.""" + +import pytest + +from app.engine.planner import _normalize_departure_time + + +@pytest.mark.parametrize( + "raw,expected", + [ + ("0800 AM", "08:00 AM"), + ("0800AM", "08:00 AM"), + ("0800", "08:00 AM"), + ("0700", "07:00 AM"), + ("800", "08:00 AM"), + ("8:00 AM", "08:00 AM"), + ("08:00", "08:00 AM"), + ("7am", "07:00 AM"), + ("7 AM", "07:00 AM"), + ("7:00AM", "07:00 AM"), + ("08", "08:00 AM"), + ("8", "08:00 AM"), + ("6:30 PM", "06:30 PM"), + ("1830", "06:30 PM"), + ("12:00 PM", "12:00 PM"), + ("12:00 AM", "12:00 AM"), + ("00:00", "12:00 AM"), + (" 0800 am ", "08:00 AM"), + ], +) +def test_normalize_departure_time_extracts_valid_times(raw, expected): + assert _normalize_departure_time(raw) == expected + + +def test_normalize_departure_time_unparseable_returns_raw(): + raw = "not-a-time" + assert _normalize_departure_time(raw) == raw From 48449b32f0c6c3f0e0b49aedac3f23e37556e544 Mon Sep 17 00:00:00 2001 From: Cursor Agent Date: Tue, 28 Jul 2026 16:06:21 +0000 Subject: [PATCH 2/3] refactor: unify flexible time parsing and graceful address normalize Share timeparse across planner, calendar, API schemas, and reminders. Accept free-form departure times at the request boundary (drop strict HH:MM AM/PM pattern). Add addressparse so run-on starting locations like "9801 International Dr Orlando FL 32819" structure for Census geocoding without blocking the user on commas. Co-authored-by: jssturm --- app/engine/addressparse.py | 185 +++++++++++++++++++++++++++++++++++++ app/engine/calendar.py | 35 +++---- app/engine/osrm.py | 50 +++++----- app/engine/planner.py | 119 ++---------------------- app/engine/timeparse.py | 130 ++++++++++++++++++++++++++ app/schemas/itinerary.py | 30 ++++-- app/schemas/requests.py | 35 ++++--- static/app.html | 6 +- static/js/app.js | 147 ++++++++++++++++++++--------- static/js/i18n.js | 12 +-- test_address_parse.py | 77 +++++++++++++++ test_normalize_time.py | 19 +++- 12 files changed, 610 insertions(+), 235 deletions(-) create mode 100644 app/engine/addressparse.py create mode 100644 app/engine/timeparse.py create mode 100644 test_address_parse.py diff --git a/app/engine/addressparse.py b/app/engine/addressparse.py new file mode 100644 index 0000000..2d2d963 --- /dev/null +++ b/app/engine/addressparse.py @@ -0,0 +1,185 @@ +"""Graceful US address parsing for free-form starting locations. + +Accepts comma-separated or run-on addresses and extracts street / city / +state / ZIP so Census geocoding can succeed without forcing users into a +single punctuation style. +""" + +from __future__ import annotations + +import re +from typing import TypedDict + +from app.engine.states import STATE_PATTERN_2LETTER, US_STATE_NAMES + +_STREET_SUFFIX = ( + r"(?:street|st|avenue|ave|boulevard|blvd|road|rd|drive|dr|lane|ln|" + r"court|ct|circle|cir|way|place|pl|terrace|ter|parkway|pkwy|" + r"highway|hwy|trail|trl|pike)\.?" +) + +_ZIP_RE = re.compile(r"\b(\d{5}(?:-\d{4})?)\b") + + +class AddressParts(TypedDict): + street: str + city: str + state: str + zip: str + formatted: str + + +def _extract_state(text: str) -> tuple[str, str]: + """Return (state_code, remainder_without_state).""" + best_len = 0 + best_code = "" + text_lower = text.lower() + for name, code in sorted(US_STATE_NAMES.items(), key=lambda x: -len(x[0])): + # Require word boundaries for short names like "dc" + pattern = r"\b" + re.escape(name) + r"\b" + if re.search(pattern, text_lower) and len(name) > best_len: + best_len = len(name) + best_code = code + + if best_code: + for full_name, code in US_STATE_NAMES.items(): + if code == best_code and len(full_name) == best_len: + remainder = re.sub( + r"\b" + re.escape(full_name) + r"\b", + "", + text, + count=1, + flags=re.IGNORECASE, + ) + return best_code, re.sub(r"\s{2,}", " ", remainder).strip(" ,") + return best_code, text + + state_match = re.search(STATE_PATTERN_2LETTER, text, flags=re.IGNORECASE) + if state_match: + code = state_match.group(1).upper() + remainder = re.sub( + r"\b" + re.escape(state_match.group(1)) + r"\b", + "", + text, + count=1, + flags=re.IGNORECASE, + ) + return code, re.sub(r"\s{2,}", " ", remainder).strip(" ,") + return "", text + + +def _split_street_city(remainder: str) -> tuple[str, str]: + """Split leftover text into (street, city) when possible.""" + remainder = remainder.strip(" ,") + if not remainder: + return "", "" + + # Street number + street name ending in a known suffix, then city + m = re.match( + rf"^(\d+\s+.{{1,80}}?\b{_STREET_SUFFIX})\s+(.+)$", + remainder, + flags=re.IGNORECASE, + ) + if m: + return m.group(1).strip(" ,"), m.group(2).strip(" ,") + + # Leading street number without recognized suffix: last token(s) = city + if re.match(r"^\d+", remainder): + tokens = remainder.split() + if len(tokens) >= 3: + # Prefer last 1 token as city; if last is short directional, take 2 + if len(tokens) >= 4 and tokens[-1].lower() in {"n", "s", "e", "w", "ne", "nw", "se", "sw"}: + return " ".join(tokens[:-2]), " ".join(tokens[-2:]) + return " ".join(tokens[:-1]), tokens[-1] + if len(tokens) == 2: + return tokens[0], tokens[1] + + # No street number — treat whole remainder as city / place name + return "", remainder + + +def parse_us_address(raw: str) -> AddressParts: + """Extract street, city, state, ZIP from free-form or structured input.""" + empty: AddressParts = { + "street": "", + "city": "", + "state": "", + "zip": "", + "formatted": (raw or "").strip(), + } + if not raw or not str(raw).strip(): + return empty + + text = re.sub(r"\s+", " ", str(raw).strip()) + text = text.replace(";", ",") + + zip_code = "" + zip_m = _ZIP_RE.search(text) + if zip_m: + zip_code = zip_m.group(1) + text = (text[: zip_m.start()] + " " + text[zip_m.end() :]).strip(" ,") + + state, remainder = _extract_state(text) + remainder = remainder.strip(" ,") + + street = "" + city = "" + + if "," in remainder: + parts = [p.strip() for p in remainder.split(",") if p.strip()] + if len(parts) >= 2: + # Heuristic: first part is street if it has a digit; else place,city + if re.search(r"\d", parts[0]): + street = parts[0] + city = parts[-1] + if len(parts) > 2 and not city: + city = parts[1] + else: + city = parts[-1] + street = ", ".join(parts[:-1]) if len(parts) > 1 else "" + if not re.search(r"\d", street): + # "Downtown, Orlando" style — keep last as city, drop street + city = parts[-1] + street = "" + elif len(parts) == 1: + street, city = _split_street_city(parts[0]) + else: + street, city = _split_street_city(remainder) + + # If state extraction ate everything and we only have zip, bail gracefully + formatted = format_address(street, city, state, zip_code) or str(raw).strip() + return { + "street": street, + "city": city, + "state": state, + "zip": zip_code, + "formatted": formatted, + } + + +def format_address(street: str, city: str, state: str, zip_code: str) -> str: + """Build a canonical ``street, city, ST ZIP`` string from parts.""" + chunks: list[str] = [] + if street: + chunks.append(street.strip()) + city_state = " ".join(x for x in [city.strip(), state.strip()] if x).strip() + if zip_code: + city_state = f"{city_state} {zip_code}".strip() if city_state else zip_code + if city_state: + chunks.append(city_state) + return ", ".join(chunks) + + +def normalize_us_address(raw: str) -> str: + """Return a comma-structured address when components can be inferred. + + Unparseable input is returned stripped unchanged (never raises). + """ + if not raw or not str(raw).strip(): + return raw + parts = parse_us_address(raw) + # Only rewrite when we confidently found state or zip — otherwise keep raw + # so hotel/landmark names are not mangled. + if parts["state"] or parts["zip"]: + return parts["formatted"] + return str(raw).strip() diff --git a/app/engine/calendar.py b/app/engine/calendar.py index 23a6800..51547f4 100644 --- a/app/engine/calendar.py +++ b/app/engine/calendar.py @@ -9,6 +9,7 @@ from __future__ import annotations import logging +import re from datetime import datetime, timedelta from typing import Any @@ -221,32 +222,26 @@ def _pick_event_date(plan: dict) -> datetime: def _parse_to_datetime(time_str: str, base_date: datetime) -> datetime | None: - """Parse a time string like '07:30 AM' or '08:00 AM +1' into a datetime.""" - import re + """Parse a free-form time string into a datetime on *base_date*.""" + from app.engine.timeparse import normalize_time, parse_time - time_str = time_str.strip() + time_str = (time_str or "").strip() if not time_str: return None - # Handle "+1" suffix for next-day events - is_next_day = "+1" in time_str - time_str = time_str.replace("+1", "").strip() - - m = re.match(r"(\d{1,2}):(\d{2})\s*(AM|PM)", time_str, re.IGNORECASE) - if not m: + # Handle "+1" / "+N" suffix for next-day events (also preserved by normalize) + is_next_day = bool(re.search(r"\+\d+", time_str)) + normalized = normalize_time(time_str) + hour, minute = parse_time(normalized, default=(-1, -1)) + if hour < 0: return None - hour = int(m.group(1)) - minute = int(m.group(2)) - meridiem = m.group(3).upper() - - if meridiem == "PM" and hour < 12: - hour += 12 - if meridiem == "AM" and hour == 12: - hour = 0 - - result = base_date.replace(hour=hour, minute=minute, second=0, microsecond=0) - if is_next_day: + result = base_date.replace(hour=hour % 24, minute=minute, second=0, microsecond=0) + # Day offsets beyond +1 from normalize_time's fmt (+N) — apply full offset + day_m = re.search(r"\+(\d+)", normalized) + if day_m: + result += timedelta(days=int(day_m.group(1))) + elif is_next_day: result += timedelta(days=1) return result diff --git a/app/engine/osrm.py b/app/engine/osrm.py index ac84117..c7bcd76 100644 --- a/app/engine/osrm.py +++ b/app/engine/osrm.py @@ -427,41 +427,31 @@ def _geocode_census(addr: str) -> tuple[float, float] | None: Handles structured US addresses (street, city, state, zip) that Nominatim often fails on. No API key, no rate limit. + Free-form input without commas (e.g. ``9801 International Dr Orlando FL + 32819``) is normalized via :func:`parse_us_address` before the Census + request. + Returns (lat, lon) or None. """ import json import urllib.request import urllib.parse - # Parse address components from the input string. - parts = [p.strip() for p in addr.split(",")] - if len(parts) < 2: - return None + from app.engine.addressparse import parse_us_address - street = parts[0] - zip_match = re.search(r'\b(\d{5}(?:-\d{4})?)\b', parts[-1]) - zip_code = zip_match.group(1) if zip_match else "" - has_street_number = bool(re.search(r'\d', parts[0])) - if not has_street_number and not zip_code: - return None - state, _remainder_state = _extract_state(parts[-1]) - if len(parts) >= 3: - city = parts[-2].strip() - elif len(parts) == 2 and state: - if re.search(r'\d', parts[0]): - remainder = re.sub(r'\b\d{5}(?:-\d{4})?\b', '', parts[1]) - remainder = re.sub(r'\b[A-Za-z]{2}\b', '', remainder) - city = remainder.strip().rstrip(",").strip() - else: - city = parts[0].strip() - street = "" - else: - city = "" + parts = parse_us_address(addr) + street = parts["street"] + city = parts["city"] + state = parts["state"] + zip_code = parts["zip"] if not city or not state: return None - has_street = bool(re.search(r'\d', street)) - if has_street and not zip_code: + # Census structured lookup works best with a street; city+state+zip is ok + # for place-level matches when street is absent. + if street and not zip_code: + # Keep prior behavior: street-level queries without ZIP are unreliable + # on Census — fall through to Nominatim. return None params = urllib.parse.urlencode({ @@ -479,7 +469,10 @@ def _geocode_census(addr: str) -> tuple[float, float] | None: data = json.loads(resp.read().decode()) if data.get("result", {}).get("addressMatches"): coords = data["result"]["addressMatches"][0]["coordinates"] - logger.info("Census geocoded: %r → (%f, %f)", addr[:60], coords["y"], coords["x"]) + logger.info( + "Census geocoded: %r → (%f, %f) [street=%r city=%r state=%r zip=%r]", + addr[:60], coords["y"], coords["x"], street, city, state, zip_code, + ) return (coords["y"], coords["x"]) return None except Exception: @@ -533,6 +526,11 @@ def _osrm_transit(origin: str, destination: str) -> dict[str, str] | None: import json import time + from app.engine.addressparse import normalize_us_address + + origin = normalize_us_address(origin) + destination = normalize_us_address(destination) + # ── Step 1a: Geocode origin to determine country context ──────────── origin_coord = _geocode_census(origin) if not origin_coord: diff --git a/app/engine/planner.py b/app/engine/planner.py index 2efe400..5143d03 100644 --- a/app/engine/planner.py +++ b/app/engine/planner.py @@ -17,6 +17,10 @@ from dateutil.parser import ParserError from app.engine import crowd, currency, search, weather +from app.engine.addressparse import normalize_us_address +from app.engine.timeparse import fmt_time as _fmt_time +from app.engine.timeparse import normalize_time as _normalize_departure_time +from app.engine.timeparse import parse_time as _parse_time from app.llm import deepseek_client logger = logging.getLogger("plan-it.planner") @@ -64,6 +68,9 @@ def build_travel_plan( venue = search.search_venue_info(search_venue_name) # 3. Build the route legs (pass departure_time for meal-label context) + # Normalize free-form starting addresses so Census geocoding gets structure. + if starting_location: + starting_location = normalize_us_address(starting_location) route = _build_route(intent, venue, starting_location, user_input, departure_time=departure_time) @@ -1315,118 +1322,6 @@ def _check_traffic_warning(step: str) -> str | None: return None -def _parse_time(time_str: str) -> tuple[int, int]: - m = re.match(r'(\d{1,2}):(\d{2})\s*(AM|PM)', time_str, re.IGNORECASE) - if not m: - return (8, 0) - h = int(m.group(1)) - minute = int(m.group(2)) - meridiem = m.group(3).upper() - if meridiem == "PM" and h < 12: - h += 12 - if meridiem == "AM" and h == 12: - h = 0 - return (h, minute) - - -def _fmt_time(hour: int, minute: int) -> str: - """Format a 24-hour hour and minute as a 12-hour clock string. - - Handles overflow beyond 24 hours by appending a `` +N`` day-offset - suffix (e.g. ``02:48 AM +1`` for hour=26). Previously, the function - only subtracted 24 once, so hours ≥ 48 (e.g. a two-day drive with - rest stops) produced invalid times like ``14:48 PM``. - """ - day_offset = hour // 24 - hour = hour % 24 - meridiem = "AM" - if hour >= 12: - meridiem = "PM" - display_h = hour if hour <= 12 else hour - 12 - if display_h == 0: - display_h = 12 - suffix = f" +{day_offset}" if day_offset > 0 else "" - return f"{display_h:02d}:{minute:02d} {meridiem}{suffix}" - - -# --------------------------------------------------------------------------- -# Default generators -# --------------------------------------------------------------------------- - - -def _to_24h(hour: int, meridiem: str | None) -> int | None: - """Convert hour + optional AM/PM to 24-hour clock, or None if invalid.""" - if meridiem: - if hour < 1 or hour > 12: - return None - if meridiem == "AM" and hour == 12: - return 0 - if meridiem == "PM" and hour != 12: - return hour + 12 - return hour - # No meridiem: treat as 24-hour when hour >= 13, else leave as-is (AM-ish). - if hour < 0 or hour > 23: - return None - return hour - - -def _normalize_departure_time(raw: str) -> str: - """Normalize a user-entered departure time string to 'HH:MM AM/PM' format. - - Accepts '7:00 AM', '07:00', '7am', '0700', '0800 AM', '7:00AM', bare - hour integers, and similar free-form variants. - Returns the normalized time string or the raw input if unparseable. - """ - stripped = re.sub(r"[.\u00b7]", ":", raw.strip().upper()) - stripped = re.sub(r"\s+", " ", stripped).strip() - - def _finish(hour: int, minute: int, meridiem: str | None) -> str | None: - if minute < 0 or minute > 59: - return None - hour_24 = _to_24h(hour, meridiem) - if hour_24 is None: - return None - return _fmt_time(hour_24, minute) - - # Try "H:MM AM/PM" or "HH:MM AM/PM" (optional colon variants already normalized) - m = re.match(r"^(\d{1,2}):(\d{2})\s*(AM|PM)?$", stripped) - if m: - result = _finish(int(m.group(1)), int(m.group(2)), m.group(3)) - if result: - return result - - # Compact HHmm / Hmm with optional AM/PM: "0700", "800", "0800 AM", "0800AM" - m = re.match(r"^(\d{3,4})\s*(AM|PM)?$", stripped) - if m: - digits = m.group(1) - meridiem = m.group(2) - if len(digits) == 3: - hour, minute = int(digits[0]), int(digits[1:]) - else: - hour, minute = int(digits[:2]), int(digits[2:]) - # With AM/PM, hour must be 1–12; without, allow 00–23 military style. - result = _finish(hour, minute, meridiem) - if result: - return result - - # Try "7am", "7 AM", "08AM" etc without minutes - m = re.match(r"^(\d{1,2})\s*(AM|PM)$", stripped) - if m: - result = _finish(int(m.group(1)), 0, m.group(2)) - if result: - return result - - # Try bare hour like "7", "14" - m = re.match(r"^(\d{1,2})$", stripped) - if m: - result = _finish(int(m.group(1)), 0, None) - if result: - return result - - # Return as-is; _parse_time will handle fallback - return raw - - def _default_flights(origin: str, destination: str) -> list[dict[str, str]]: return [ { diff --git a/app/engine/timeparse.py b/app/engine/timeparse.py new file mode 100644 index 0000000..b95e67b --- /dev/null +++ b/app/engine/timeparse.py @@ -0,0 +1,130 @@ +"""Shared free-form time parsing used by planner, calendar, and API schemas. + +Normalizes user-entered times to canonical ``HH:MM AM/PM`` (with optional +`` +N`` day offset from ``fmt_time`` overflow handling). +""" + +from __future__ import annotations + +import re + + +def to_24h(hour: int, meridiem: str | None) -> int | None: + """Convert hour + optional AM/PM to 24-hour clock, or None if invalid.""" + if meridiem: + if hour < 1 or hour > 12: + return None + if meridiem == "AM" and hour == 12: + return 0 + if meridiem == "PM" and hour != 12: + return hour + 12 + return hour + if hour < 0 or hour > 23: + return None + return hour + + +def fmt_time(hour: int, minute: int) -> str: + """Format a 24-hour hour and minute as a 12-hour clock string. + + Handles overflow beyond 24 hours by appending a `` +N`` day-offset + suffix (e.g. ``02:48 AM +1`` for hour=26). + """ + day_offset = hour // 24 + hour = hour % 24 + meridiem = "AM" + if hour >= 12: + meridiem = "PM" + display_h = hour if hour <= 12 else hour - 12 + if display_h == 0: + display_h = 12 + suffix = f" +{day_offset}" if day_offset > 0 else "" + return f"{display_h:02d}:{minute:02d} {meridiem}{suffix}" + + +def normalize_time(raw: str) -> str: + """Normalize a user-entered time string to ``HH:MM AM/PM`` format. + + Accepts ``7:00 AM``, ``07:00``, ``7am``, ``0700``, ``0800 AM``, + ``7:00AM``, bare hour integers, and similar free-form variants. + Returns the normalized time string or the raw input if unparseable. + """ + if raw is None: + return raw + stripped = re.sub(r"[.\u00b7]", ":", str(raw).strip().upper()) + stripped = re.sub(r"\s+", " ", stripped).strip() + # Drop day-offset suffixes for parsing; re-apply via fmt when needed. + extra_hours = 0 + day_m = re.search(r"\s*\+(\d+)\s*$", stripped) + if day_m: + extra_hours = 24 * int(day_m.group(1)) + stripped = stripped[: day_m.start()].strip() + + def _finish(hour: int, minute: int, meridiem: str | None) -> str | None: + if minute < 0 or minute > 59: + return None + hour_24 = to_24h(hour, meridiem) + if hour_24 is None: + return None + return fmt_time(hour_24 + extra_hours, minute) + + m = re.match(r"^(\d{1,2}):(\d{2})\s*(AM|PM)?$", stripped) + if m: + result = _finish(int(m.group(1)), int(m.group(2)), m.group(3)) + if result: + return result + + m = re.match(r"^(\d{3,4})\s*(AM|PM)?$", stripped) + if m: + digits = m.group(1) + meridiem = m.group(2) + if len(digits) == 3: + hour, minute = int(digits[0]), int(digits[1:]) + else: + hour, minute = int(digits[:2]), int(digits[2:]) + result = _finish(hour, minute, meridiem) + if result: + return result + + m = re.match(r"^(\d{1,2})\s*(AM|PM)$", stripped) + if m: + result = _finish(int(m.group(1)), 0, m.group(2)) + if result: + return result + + m = re.match(r"^(\d{1,2})$", stripped) + if m: + result = _finish(int(m.group(1)), 0, None) + if result: + return result + + return str(raw) + + +def parse_time(time_str: str, *, default: tuple[int, int] = (8, 0)) -> tuple[int, int]: + """Parse a free-form time to ``(hour_24, minute)``. + + Uses :func:`normalize_time` first so compact forms like ``0800 AM`` work. + Falls back to *default* when unparseable. + """ + if not time_str or not str(time_str).strip(): + return default + + normalized = normalize_time(time_str) + m = re.match(r"(\d{1,2}):(\d{2})\s*(AM|PM)", normalized, re.IGNORECASE) + if not m: + return default + + h = int(m.group(1)) + minute = int(m.group(2)) + meridiem = m.group(3).upper() + hour_24 = to_24h(h, meridiem) + if hour_24 is None: + return default + return (hour_24, minute) + + +# Back-compat aliases used throughout the planner +_fmt_time = fmt_time +_normalize_departure_time = normalize_time +_parse_time = parse_time diff --git a/app/schemas/itinerary.py b/app/schemas/itinerary.py index 72fb628..de15bdf 100644 --- a/app/schemas/itinerary.py +++ b/app/schemas/itinerary.py @@ -108,10 +108,19 @@ def walking_map_url_must_be_valid(cls, v: str | None) -> str | None: @field_validator("time") @classmethod def time_must_look_like_clock(cls, v: str) -> str: - """Lightweight check that the time string is plausible.""" - if len(v) < 5: - raise ValueError(f"time must be at least 5 characters (e.g. '07:30 AM'), got: {v}") - return v + """Normalize free-form times; reject only if unparseable.""" + import re + + from app.engine.timeparse import normalize_time + + if not v or not str(v).strip(): + raise ValueError("time must not be empty") + normalized = normalize_time(v.strip()) + if not re.match(r"^\d{1,2}:\d{2}\s*(AM|PM)", normalized, re.IGNORECASE): + raise ValueError( + f"time could not be parsed (e.g. '07:30 AM', '0800', '8am'), got: {v}" + ) + return normalized class RentalCar(BaseModel): @@ -220,5 +229,14 @@ class TravelPlan(BaseModel): @field_validator("departure_time") @classmethod def departure_time_strip(cls, v: str) -> str: - """Strip whitespace from departure_time.""" - return v.strip() if v else v + """Strip and normalize departure_time when present.""" + import re + + from app.engine.timeparse import normalize_time + + if not v: + return v + normalized = normalize_time(v.strip()) + if re.match(r"^\d{1,2}:\d{2}\s*(AM|PM)", normalized, re.IGNORECASE): + return normalized + return v.strip() diff --git a/app/schemas/requests.py b/app/schemas/requests.py index 855a386..4709309 100644 --- a/app/schemas/requests.py +++ b/app/schemas/requests.py @@ -5,6 +5,9 @@ from pydantic import BaseModel, Field, model_validator +from app.engine.addressparse import normalize_us_address +from app.engine.timeparse import normalize_time + # Patterns that indicate prompt injection or system-instruction override attempts. # These are rejected at the API boundary before any processing occurs. _PROMPT_INJECTION_PATTERNS: list[re.Pattern] = [ @@ -37,8 +40,11 @@ class TravelRequest(BaseModel): min_length=1, max_length=500, description="Where the trip starts from (e.g. home address, hotel name). " - "If omitted, the planner will flag it as unspecified rather than guessing.", - examples=["Hyatt Regency Orlando, 9801 International Dr"], + "Free-form US addresses are accepted (commas optional) and normalized when possible.", + examples=[ + "Hyatt Regency Orlando, 9801 International Dr", + "9801 International Dr Orlando FL 32819", + ], ) restaurant_preferences: Optional[str] = Field( default=None, @@ -59,29 +65,30 @@ class TravelRequest(BaseModel): default=None, min_length=1, max_length=30, - pattern=r"^(0?[1-9]|1[0-2]):[0-5]\d\s+(AM|PM)$", - description="User-defined departure time in 12-hour format (e.g. '7:00 AM', '08:00 AM', '6:30 PM'). " - "Hour must be 1-12, minute must be 00-59, and AM/PM suffix is required. " - "If omitted, the departure time will be left blank in the itinerary.", - examples=["7:00 AM", "08:00 AM", "6:30 PM"], + description="User-defined departure time. Accepts free-form values such as " + "'7:00 AM', '07:00', '7am', '0700', or '0800 AM' and normalizes to " + "'HH:MM AM/PM'. If omitted, the departure time is left blank.", + examples=["7:00 AM", "08:00 AM", "0800 AM", "6:30 PM"], ) @model_validator(mode="after") def strip_and_validate(self) -> "TravelRequest": - """Strip leading/trailing whitespace and reject obviously bogus input.""" + """Strip, normalize free-form fields, and reject injection attempts.""" self.input = self.input.strip() if self.starting_location is not None: - self.starting_location = self.starting_location.strip() + self.starting_location = normalize_us_address(self.starting_location.strip()) if self.restaurant_preferences is not None: self.restaurant_preferences = self.restaurant_preferences.strip() if self.departure_time is not None: - self.departure_time = self.departure_time.strip() + normalized = normalize_time(self.departure_time.strip()) + if not re.match(r"^\d{1,2}:\d{2}\s*(AM|PM)", normalized, re.IGNORECASE): + raise ValueError( + "departure_time could not be parsed — try formats like " + "'7:00 AM', '0700', or '8am'" + ) + self.departure_time = normalized if not self.input: raise ValueError("input must not be empty or whitespace-only") - # Reject prompt-injection / system-override attempts before any - # processing. This protects the planner from malicious input that - # tries to override system instructions. All user-supplied free-text - # fields are checked, not just ``input``. if _contains_injection(self.input): raise ValueError("input contains disallowed content") if self.starting_location and _contains_injection(self.starting_location): diff --git a/static/app.html b/static/app.html index e7b4918..b0f7d80 100644 --- a/static/app.html +++ b/static/app.html @@ -136,11 +136,11 @@

Plan Your Trip

When you plan to leave. Enter a time like 8:00, 0800, or 8am, and select AM or PM.
- + -
Required if provided — must include street address, city, state, and zip code, separated by commas.
+ placeholder="e.g. 9801 International Dr Orlando FL 32819" /> +
Optional — free-form is fine (commas optional). e.g. 9801 International Dr Orlando FL 32819
diff --git a/static/js/app.js b/static/js/app.js index 056054b..ee3f89b 100644 --- a/static/js/app.js +++ b/static/js/app.js @@ -181,13 +181,12 @@ } function parseTimeString(timeStr) { - var match = timeStr.match(/(\d{1,2}):(\d{2})\s*(AM|PM)/i); - if (!match) return null; - var hours = parseInt(match[1], 10); - var mins = parseInt(match[2], 10); - var period = match[3].toUpperCase(); - if (period === "PM" && hours < 12) hours += 12; - if (period === "AM" && hours === 12) hours = 0; + var parsed = parseFlexibleTimeString(timeStr, "AM"); + if (!parsed) return null; + var hours = parseInt(parsed.hh, 10); + var mins = parseInt(parsed.mm, 10); + if (parsed.period === "PM" && hours < 12) hours += 12; + if (parsed.period === "AM" && hours === 12) hours = 0; return hours * 60 + mins; } @@ -412,10 +411,12 @@ return; } - const start = $tripStart.value.trim(); - // Address validation removed — Nominatim handles free-form geocoding - // for any reasonable input (city names, addresses, landmarks, etc.) - + const startRaw = $tripStart.value.trim(); + // Soft-normalize free-form US addresses (commas optional) without blocking. + const start = startRaw ? normalizeUSAddress(startRaw) : ""; + if (start && start !== startRaw && $tripStart) { + $tripStart.value = start; + } // Check for city names without a state — duplicate cities exist // (e.g. Jacksonville FL/TX/NC, Portland OR/ME, Springfield IL/MO/MA) const cityErr = validateCityState(input); @@ -1809,48 +1810,108 @@ } /* ------------------------------------------------------------------------ - Address Validation + Address Normalization (graceful — never blocks submit) ------------------------------------------------------------------------ */ - function validateAddress(addr) { - if (!addr) return null; // empty is fine (field is optional) - // Must contain a street number (digits at start or after a comma) - var hasStreet = /\d+\s+\w+/i.test(addr); - // Must contain a city-like component followed by comma/space and - // either a US state abbreviation OR a spelled-out state name - var hasCityState = /[a-z]+(?:,\s*|\s+)(A[LKZR]|C[AOT]|D[EC]|F[LM]|G[AU]|HI|I[DLNA]|K[SY]|LA|M[ADEHINOPST]|N[CDEHJMVY]|O[HKR]|P[AWR]|RI|S[CD]|T[NX]|UT|V[AIT]|W[AIVY])\b/i.test(addr) || _fullStatePattern.test(addr); - // Must contain a 5-digit ZIP code (optionally with +4) - var hasZip = /\b\d{5}(?:-\d{4})?\b/.test(addr); - - var missing = []; - if (!hasStreet) missing.push("street address"); - if (!hasCityState) missing.push("city and state"); - if (!hasZip) missing.push("zip code"); - - if (missing.length === 0) return null; + var _US_STATE_NAMES = { + alabama: "AL", alaska: "AK", arizona: "AZ", arkansas: "AR", california: "CA", + colorado: "CO", connecticut: "CT", delaware: "DE", florida: "FL", georgia: "GA", + hawaii: "HI", idaho: "ID", illinois: "IL", indiana: "IN", iowa: "IA", + kansas: "KS", kentucky: "KY", louisiana: "LA", maine: "ME", maryland: "MD", + massachusetts: "MA", michigan: "MI", minnesota: "MN", mississippi: "MS", + missouri: "MO", montana: "MT", nebraska: "NE", nevada: "NV", + "new hampshire": "NH", "new jersey": "NJ", "new mexico": "NM", "new york": "NY", + "north carolina": "NC", "north dakota": "ND", ohio: "OH", oklahoma: "OK", + oregon: "OR", pennsylvania: "PA", "rhode island": "RI", "south carolina": "SC", + "south dakota": "SD", tennessee: "TN", texas: "TX", utah: "UT", vermont: "VT", + virginia: "VA", washington: "WA", "west virginia": "WV", wisconsin: "WI", + wyoming: "WY", "district of columbia": "DC", "washington dc": "DC", dc: "DC" + }; - if (missing.length === 3) { - return t("error.missingFullAddress"); + /** + * Soft-normalize a free-form US address into "street, city, ST ZIP" when + * components can be inferred. Never rejects — returns original trim on failure. + */ + function normalizeUSAddress(raw) { + if (!raw || !String(raw).trim()) return raw; + var text = String(raw).trim().replace(/;/g, ",").replace(/\s+/g, " "); + var zip = ""; + var zipMatch = text.match(/\b(\d{5}(?:-\d{4})?)\b/); + if (zipMatch) { + zip = zipMatch[1]; + text = (text.slice(0, zipMatch.index) + " " + text.slice(zipMatch.index + zipMatch[0].length)) + .trim().replace(/^,|,$/g, "").trim(); } - // Single missing field — give a specific hint - if (missing.length === 1) { - if (missing[0] === "street address") { - return t("error.missingStreet"); - } - if (missing[0] === "city and state") { - return t("error.missingCityState"); + var state = ""; + var lower = text.toLowerCase(); + var bestLen = 0; + Object.keys(_US_STATE_NAMES).forEach(function (name) { + var re = new RegExp("\\b" + name.replace(/[.*+?^${}()|[\]\\]/g, "\\$&") + "\\b", "i"); + if (re.test(lower) && name.length > bestLen) { + bestLen = name.length; + state = _US_STATE_NAMES[name]; } - if (missing[0] === "zip code") { - return t("error.missingZip"); + }); + if (state && bestLen > 2) { + var matchedName = Object.keys(_US_STATE_NAMES).filter(function (n) { + return _US_STATE_NAMES[n] === state && n.length === bestLen; + })[0]; + var nameRe = new RegExp("\\b" + matchedName.replace(/[.*+?^${}()|[\]\\]/g, "\\$&") + "\\b", "i"); + text = text.replace(nameRe, " ").replace(/\s{2,}/g, " ").trim().replace(/^,|,$/g, "").trim(); + } else { + var codeMatch = text.match(_stateCodePattern); + if (codeMatch) { + state = codeMatch[1].toUpperCase(); + text = text.replace(new RegExp("\\b" + codeMatch[1] + "\\b", "i"), " ") + .replace(/\s{2,}/g, " ").trim().replace(/^,|,$/g, "").trim(); } } - // Two missing fields - if (missing[0] === "city and state" || missing[1] === "city and state") { - return t("error.missingCityState2"); + if (!state && !zip) return String(raw).trim(); + + var street = ""; + var city = ""; + if (text.indexOf(",") !== -1) { + var parts = text.split(",").map(function (p) { return p.trim(); }).filter(Boolean); + if (parts.length >= 2 && /\d/.test(parts[0])) { + street = parts[0]; + city = parts[parts.length - 1]; + } else if (parts.length >= 1) { + city = parts[parts.length - 1]; + } + } else { + var streetCity = text.match(new RegExp( + "^(\\d+\\s+.{1,80}?\\b(?:street|st|avenue|ave|boulevard|blvd|road|rd|drive|dr|lane|ln|court|ct|circle|cir|way|place|pl|parkway|pkwy|highway|hwy)\\.?)\\s+(.+)$", + "i" + )); + if (streetCity) { + street = streetCity[1].trim(); + city = streetCity[2].trim(); + } else if (/^\d/.test(text)) { + var tokens = text.split(/\s+/); + if (tokens.length >= 3) { + street = tokens.slice(0, -1).join(" "); + city = tokens[tokens.length - 1]; + } else { + city = text; + } + } else { + city = text; + } } - return t("error.missingGeneric"); + + var chunks = []; + if (street) chunks.push(street); + var cityState = [city, state].filter(Boolean).join(" ").trim(); + if (zip) cityState = cityState ? cityState + " " + zip : zip; + if (cityState) chunks.push(cityState); + return chunks.length ? chunks.join(", ") : String(raw).trim(); + } + + /** @deprecated Kept for compatibility; always returns null (non-blocking). */ + function validateAddress(addr) { + return null; } /* ------------------------------------------------------------------------ diff --git a/static/js/i18n.js b/static/js/i18n.js index 4f17171..0cf9abe 100644 --- a/static/js/i18n.js +++ b/static/js/i18n.js @@ -54,9 +54,9 @@ "newTrip.tripHint": "Include as many details as possible — venue, date, mode of travel (drive/fly), meal stops, hotel stays, long-term parking, return trip, and any special interests. The more details you provide, the better your itinerary.", "newTrip.departureTime": "Departure Time", "newTrip.departureHint": "When you plan to leave. Enter a time like 8:00, 0800, or 8am, and select AM or PM.", - "newTrip.startingLocation": "Starting Location (Street Address, City, State, Zip Code)", - "newTrip.startPlaceholder": "e.g. 9801 International Dr, Orlando, Florida 32819", - "newTrip.startHint": "Required if provided — must include street address, city, state, and zip code, separated by commas.", + "newTrip.startingLocation": "Starting Location", + "newTrip.startPlaceholder": "e.g. 9801 International Dr Orlando FL 32819", + "newTrip.startHint": "Optional — free-form is fine (commas optional). e.g. 9801 International Dr Orlando FL 32819", "newTrip.restaurantPrefs": "Restaurant Preferences", "newTrip.restaurantPlaceholder": "e.g. vegetarian, Italian, $$-$$$ range", "newTrip.restaurantHint": "Diet, cuisine, or price preferences for meal stops.", @@ -255,9 +255,9 @@ "newTrip.tripHint": "Incluye tantos detalles como sea posible — lugar, fecha, modo de viaje (coche/avión), paradas para comer, estancias en hotel, estacionamiento de larga estadía, viaje de regreso e intereses especiales. Cuantos más detalles, mejor será tu itinerario.", "newTrip.departureTime": "Hora de Salida", "newTrip.departureHint": "Cuándo planeas salir. Ingresa una hora como 8:00, 0800 o 8am, y selecciona AM o PM.", - "newTrip.startingLocation": "Lugar de Partida (Dirección, Ciudad, Estado, Código Postal)", - "newTrip.startPlaceholder": "Ej. 9801 International Dr, Orlando, Florida 32819", - "newTrip.startHint": "Obligatorio si se proporciona — debe incluir dirección, ciudad, estado y código postal, separados por comas.", + "newTrip.startingLocation": "Lugar de Partida", + "newTrip.startPlaceholder": "Ej. 9801 International Dr Orlando FL 32819", + "newTrip.startHint": "Opcional — formato libre (comas opcionales). Ej. 9801 International Dr Orlando FL 32819", "newTrip.restaurantPrefs": "Preferencias de Restaurante", "newTrip.restaurantPlaceholder": "Ej. vegetariano, italiana, rango $$-$$$", "newTrip.restaurantHint": "Preferencias de dieta, cocina o precio para las paradas de comida.", diff --git a/test_address_parse.py b/test_address_parse.py new file mode 100644 index 0000000..0271218 --- /dev/null +++ b/test_address_parse.py @@ -0,0 +1,77 @@ +"""Unit tests for free-form US address normalization.""" + +import pytest + +from app.engine.addressparse import normalize_us_address, parse_us_address + + +@pytest.mark.parametrize( + "raw,expected_street,expected_city,expected_state,expected_zip", + [ + ( + "9801 International Dr, Orlando, FL 32819", + "9801 International Dr", + "Orlando", + "FL", + "32819", + ), + ( + "9801 International Dr Orlando FL 32819", + "9801 International Dr", + "Orlando", + "FL", + "32819", + ), + ( + "9801 International Drive Orlando Florida 32819", + "9801 International Drive", + "Orlando", + "FL", + "32819", + ), + ( + "Orlando, FL", + "", + "Orlando", + "FL", + "", + ), + ( + "Orlando FL 32819", + "", + "Orlando", + "FL", + "32819", + ), + ], +) +def test_parse_us_address_parts(raw, expected_street, expected_city, expected_state, expected_zip): + parts = parse_us_address(raw) + assert parts["street"] == expected_street + assert parts["city"] == expected_city + assert parts["state"] == expected_state + assert parts["zip"] == expected_zip + + +def test_normalize_inserts_commas_for_run_on_address(): + assert normalize_us_address("9801 International Dr Orlando FL 32819") == ( + "9801 International Dr, Orlando FL 32819" + ) + + +def test_normalize_preserves_landmark_without_state(): + raw = "Hyatt Regency Orlando" + assert normalize_us_address(raw) == raw + + +def test_travel_request_accepts_freeform_time_and_address(): + from app.schemas.requests import TravelRequest + + req = TravelRequest( + input="Trip to Disney", + starting_location="9801 International Dr Orlando FL 32819", + departure_time="0800 AM", + ) + assert req.departure_time == "08:00 AM" + assert "Orlando" in req.starting_location + assert "FL" in req.starting_location diff --git a/test_normalize_time.py b/test_normalize_time.py index d12d34b..7c3c4e0 100644 --- a/test_normalize_time.py +++ b/test_normalize_time.py @@ -2,7 +2,7 @@ import pytest -from app.engine.planner import _normalize_departure_time +from app.engine.timeparse import normalize_time @pytest.mark.parametrize( @@ -26,12 +26,21 @@ ("12:00 AM", "12:00 AM"), ("00:00", "12:00 AM"), (" 0800 am ", "08:00 AM"), + ("08:00 AM +1", "08:00 AM +1"), ], ) -def test_normalize_departure_time_extracts_valid_times(raw, expected): - assert _normalize_departure_time(raw) == expected +def test_normalize_time_extracts_valid_times(raw, expected): + assert normalize_time(raw) == expected -def test_normalize_departure_time_unparseable_returns_raw(): +def test_normalize_time_unparseable_returns_raw(): raw = "not-a-time" - assert _normalize_departure_time(raw) == raw + assert normalize_time(raw) == raw + + +def test_parse_time_uses_normalizer(): + from app.engine.timeparse import parse_time + + assert parse_time("0800 AM") == (8, 0) + assert parse_time("1830") == (18, 30) + assert parse_time("bogus") == (8, 0) From eae073f98d85f195cdadb6c84ef6bf6164af1e7b Mon Sep 17 00:00:00 2001 From: Cursor Agent Date: Tue, 28 Jul 2026 16:24:24 +0000 Subject: [PATCH 3/3] fix(ci): install requirements-dev so pytest is available in Test workflow The Test job only installed requirements.txt, which does not include pytest, so CI failed with "No module named pytest" (including on main). Install requirements-dev.txt and run the full pytest suite. Co-authored-by: jssturm --- .github/workflows/test.yml | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-) diff --git a/.github/workflows/test.yml b/.github/workflows/test.yml index 45aaf76..4cd7457 100644 --- a/.github/workflows/test.yml +++ b/.github/workflows/test.yml @@ -20,7 +20,9 @@ jobs: python-version: "3.12" - name: Install dependencies - run: pip install -r requirements.txt + run: | + python -m pip install --upgrade pip + pip install -r requirements-dev.txt - name: Run tests - run: python -m pytest test_travel.py -v + run: python -m pytest -q