Attempt 2

app.py

@@ -1,36 +1,14 @@
 """
 Per Diem / Leave Start Date Calculator (Form e49)
 
-Reserve members accrue leave at 2.5 days per month of service (per the
-official "Leave Accrual to Date of Separation" chart), and take that
-leave during the final days of the deployment, so the last day of leave
-equals the end date on their orders.
-
-Given the FIRST and LAST day of the deployment, this app:
-  1. Looks up how much leave was earned over that span, using the same
-     day-of-month / month accrual logic as the official chart (in 0.5-day
-     increments).
-  2. Truncates that to a whole number of usable days (leave can only
-     actually be taken in whole days — e.g. 1.5 earned days means only
-     1 day can be taken).
-  3. Adds one bonus day if the deployment end date falls on a weekend or
-     federal holiday (existing rule, unchanged from the original app).
-  4. Reports the leave start date, so the last day of leave still equals
-     the deployment end date.
-
---- IMPORTANT ASSUMPTION ABOUT THE ACCRUAL CHART ---
-The official chart is expressed relative to the start of the fiscal/leave
-year (Oct 1) and its values reset to ~0 every October. Real leave accrual
-does NOT actually reset mid-deployment — it just keeps accumulating at a
-constant 2.5 days/month. Since 6-month deployments routinely cross an
-Oct 1 boundary, this app reproduces the chart's exact day-of-month /
-month-of-year logic (verified to match the chart's printed values
-exactly within any single fiscal year), but does NOT hard-reset the
-counter at each Oct 1 — leave earned is simply
-(accrual value at end date) - (accrual value at start date).
-If your unit's actual policy is that leave literally zeroes out every
-Oct 1 even mid-deployment, this calculation will need to change —
-flag it and it can be adjusted to hard-reset instead.
+Reserve members accrue leave (typically 15 days for a 6-month deployment)
+and take it during the last 15 days of the deployment, so the last day of
+leave equals the end date on their orders. Given that end date, this app
+tells them when their leave starts.
+
+Rule: leave is 15 days inclusive of start and end date.
+If the end date falls on a weekend or federal holiday, the member gets
+one extra day of leave (so the start date shifts one day earlier).
 
 Usage tracking: every time someone clicks "Calculate", a timestamped
 row is appended to a log file in a separate Hugging Face dataset repo
@@ -105,180 +83,84 @@ def log_usage():
         print(f"Usage logging failed: {e}")
 
 
-def is_holiday(d: date) -> bool:
-    """Return True if d is a US federal holiday."""
-    return d in US_HOLIDAYS
-
-
-def is_weekend(d: date) -> bool:
-    """Return True if d is a Saturday or Sunday."""
-    return d.weekday() >= 5
-
-
-# --- Leave accrual chart logic ---
-#
-# The official "Leave Accrual to Date of Separation" table earns 2.5 days
-# per calendar month, subdivided into five 0.5-day steps per month based
-# on which 6-day bucket the day-of-month falls into:
-#   days 1-6   -> +0.5   (bucket 1)
-#   days 7-12  -> +1.0   (bucket 2)
-#   days 13-18 -> +1.5   (bucket 3)
-#   days 19-24 -> +2.0   (bucket 4)
-#   days 25-31 -> +2.5   (bucket 5, i.e. the full month)
-#
-# So within any month, accrued-since-start-of-month = bucket * 0.5, and
-# each full elapsed calendar month is worth a flat 2.5 days on top of that.
-
-
-def _day_bucket(day_of_month: int) -> int:
-    """Map a day-of-month (1-31) to its 6-day accrual bucket (1-5)."""
-    if day_of_month <= 6:
-        return 1
-    elif day_of_month <= 12:
-        return 2
-    elif day_of_month <= 18:
-        return 3
-    elif day_of_month <= 24:
-        return 4
-    else:
-        return 5  # 25-31 (or 25-28/29/30 for shorter months)
-
-
-def _accrual_value(d: date) -> float:
-    """
-    A running accrual "odometer" value for date d: increases by 2.5 for
-    every full calendar month, plus the partial-month bucket amount.
-    This is anchored to an arbitrary fixed point (not Oct 1 of any
-    particular year), which is fine because only *differences* between
-    two of these values are ever used — the anchor cancels out.
-    """
-    absolute_month_index = d.year * 12 + (d.month - 1)
-    return absolute_month_index * 2.5 + _day_bucket(d.day) * 0.5
-
-
-def earned_leave_days(deployment_start: date, deployment_end: date) -> float:
-    """
-    Days of leave earned over the deployment, per the accrual chart,
-    rounded to the nearest 0.5 to avoid floating point drift.
-    """
-    raw = _accrual_value(deployment_end) - _accrual_value(deployment_start)
-    return round(raw * 2) / 2
-
-
-def calc_leave_plan(deployment_start: date, deployment_end: date) -> dict:
-    """
-    Given the deployment's first and last day, compute:
-      - earned: raw leave earned (chart lookup, in 0.5-day increments)
-      - usable: whole days actually usable (earned, truncated down)
-      - exception: whether the end date is a weekend/holiday bonus day
-      - total_days: usable days actually taken (usable + bonus day if any)
-      - leave_start: first day of leave (last day is always deployment_end)
-    """
-    earned = earned_leave_days(deployment_start, deployment_end)
-    usable = int(earned)  # whole days only; e.g. 1.5 -> 1 (earned is always >= 0)
-
-    exception = is_weekend(deployment_end) or is_holiday(deployment_end)
-    total_days = usable + (1 if exception else 0)
+def is_holiday(end_date: date) -> bool:
+    """Return True if end_date is a US federal holiday."""
+    return end_date in US_HOLIDAYS
 
-    leave_start = deployment_end - timedelta(days=max(total_days - 1, 0))
 
-    return {
-        "earned": earned,
-        "usable": usable,
-        "exception": exception,
-        "total_days": total_days,
-        "leave_start": leave_start,
-        "leave_end": deployment_end,
-    }
+def is_weekend(end_date: date) -> bool:
+    """Return True if end_date is a Saturday or Sunday."""
+    return end_date.weekday() >= 5
 
 
-def _parse_date_input(value):
+def fifteen_days_prior(end_date: date, exception: bool) -> date:
     """
-    gr.DateTime can hand back either a datetime object, a string, or a
-    numeric timestamp depending on how the value was set, so handle all
-    three defensively.
+    Return the date 15 days (inclusive) before end_date.
+    If `exception` is True (end date is a weekend/holiday), the member
+    gets one extra day of leave, so we go back 15 days instead of 14.
     """
-    if value is None:
-        return None
-    if isinstance(value, str):
-        return datetime.strptime(value.split(" ")[0], "%Y-%m-%d").date()
-    if isinstance(value, (int, float)):
-        return datetime.fromtimestamp(value).date()
-    return value.date()
-
-
-def submit_leave_dates(deployment_start_input, deployment_end_input):
-    deployment_start = _parse_date_input(deployment_start_input)
-    deployment_end = _parse_date_input(deployment_end_input)
-
-    if deployment_start is None or deployment_end is None:
-        return "Please select both a deployment start date and end date."
-
-    if deployment_end < deployment_start:
-        return "The deployment end date can't be before the start date."
-
-    plan = calc_leave_plan(deployment_start, deployment_end)
+    if exception:
+        return end_date - timedelta(days=15)
+    return end_date - timedelta(days=14)
+
+
+def calc_leave_dates(end_date: date) -> tuple[date, date]:
+    """Determine the leave start date given the leave end date."""
+    exception = is_weekend(end_date) or is_holiday(end_date)
+    start_date = fifteen_days_prior(end_date, exception)
+    return start_date, end_date
+
+
+def submit_leave_date(end_of_leave):
+    if end_of_leave is None:
+        return "Please select a date."
+
+    # gr.DateTime can hand back either a datetime object or a string
+    # depending on how the value was set, so handle both defensively.
+    if isinstance(end_of_leave, str):
+        end_of_leave = datetime.strptime(
+            end_of_leave.split(" ")[0], "%Y-%m-%d"
+        ).date()
+    elif isinstance(end_of_leave, (int, float)):
+        end_of_leave = datetime.fromtimestamp(end_of_leave).date()
+    else:
+        end_of_leave = end_of_leave.date()
 
-    if plan["total_days"] <= 0:
-        return (
-            f"Based on a deployment from {deployment_start:%B %d, %Y} to "
-            f"{deployment_end:%B %d, %Y}, you earned {plan['earned']:g} days "
-            "of leave — not enough to take a full day off."
-        )
+    start_date, end_date = calc_leave_dates(end_of_leave)
 
     reason = []
-    if is_weekend(deployment_end):
+    if is_weekend(end_date):
         reason.append("your end date falls on a weekend")
-    if is_holiday(deployment_end):
+    if is_holiday(end_date):
         reason.append("your end date is a federal holiday")
-    extra_note = (
-        f" You get one extra day of leave because {' and '.join(reason)}, "
-        f"for {plan['total_days']} total days off."
-        if plan["exception"]
-        else ""
-    )
+    extra_note = f" (You get an extra day of leave because {' and '.join(reason)}.)" if reason else ""
 
     # Log this use (best-effort, won't block or break the result).
     log_usage()
 
     return (
-        f"Based on a deployment from {deployment_start:%B %d, %Y} to "
-        f"{deployment_end:%B %d, %Y}, you earned {plan['earned']:g} days of "
-        f"leave. Since leave can only be taken in whole days, you can use "
-        f"{plan['usable']} day(s).{extra_note}\n\n"
-        f"Your leave starts on {plan['leave_start']:%B %d, %Y} "
-        f"and ends on {plan['leave_end']:%B %d, %Y}."
+        f"Your leave starts on {start_date:%B %d, %Y} "
+        f"and ends on {end_date:%B %d, %Y}.{extra_note}"
     )
 
 
 with gr.Blocks(title="Leave Start Date Calculator") as app:
     gr.Markdown(
         "# Leave Start Date Calculator\n"
-        "Enter the **first and last day of your deployment** to see how "
-        "much leave you earned and when it starts. Your last day of leave "
-        "will always be your deployment's end date."
+        "Enter the **end date of your deployment (Form e49 end date)** "
+        "to find out when your 15 days of leave will start."
+    )
+    date_input = gr.DateTime(
+        label="When is the end of your leave?",
+        include_time=False,
+        type="datetime",
     )
-    with gr.Row():
-        start_input = gr.DateTime(
-            label="First day of deployment",
-            include_time=False,
-            type="datetime",
-        )
-        end_input = gr.DateTime(
-            label="Last day of deployment (Form e49 end date)",
-            include_time=False,
-            type="datetime",
-        )
     submit_btn = gr.Button("Calculate", variant="primary")
-    output = gr.Textbox(label="Result", interactive=False, lines=4)
+    output = gr.Textbox(label="Result", interactive=False)
 
-    submit_btn.click(
-        fn=submit_leave_dates, inputs=[start_input, end_input], outputs=output
-    )
-    end_input.submit(
-        fn=submit_leave_dates, inputs=[start_input, end_input], outputs=output
-    )
+    submit_btn.click(fn=submit_leave_date, inputs=date_input, outputs=output)
+    date_input.submit(fn=submit_leave_date, inputs=date_input, outputs=output)
 
 
 if __name__ == "__main__":
-    app.launch()
+    app.launch()