add lastN string functionality

Author: andrewm4894

dashboard/app.py

@@ -289,4 +289,4 @@
 
 app.state = AppState()
 
-serve()
+serve(port="5003")

dashboard/components.py

@@ -207,18 +207,17 @@ def _create_last_n_form(batch_name):
     """
     Create the last n number form for the dashboard.
     """
-    state = get_state()  # Get state instance first
+    state = get_state()
     return Form(
         DivLAligned(
             Input(
-                type="number",
+                type="text",
                 name="last_n",
-                value=state.last_n.get(batch_name, DEFAULT_LAST_N),
-                min=1,
-                max=1000,
-                step=1,
+                value=state.last_n.get(batch_name, "30n"),
+                pattern="^\d+[nNhmd]$",
+                title="Use format: 30n (observations), 24h (hours), 45m (minutes), 7d (days)",
                 cls="uk-input uk-form-small uk-form-width-small",
-                uk_tooltip="Filter for last N observations",
+                uk_tooltip="Filter by last N observations or time period (e.g., 30n, 24h, 45m, 7d)",
             ),
             cls="space-x-2",
         ),

dashboard/data.py

@@ -5,24 +5,89 @@
 import pandas as pd
 from anomstack.jinja.render import render
 from anomstack.sql.read import read_sql
+import re
+from datetime import datetime, timedelta
 
 
-def get_data(spec: dict, last_n: int = 30, ensure_timestamp: bool = False) -> pd.DataFrame:
+def parse_time_spec(spec_str: str) -> dict:
     """
-    Get data from the database for a given spec and last_n.
+    Parse a time specification string into a dictionary with type and value.
+    Supports formats:
+    - "30N" or "30n" for last N observations
+    - "24h" for last 24 hours
+    - "45m" for last 45 minutes
+    - "7d" for last 7 days
+    
+    Returns:
+        dict with keys:
+        - 'type': 'n' for observations, 'time' for time-based
+        - 'value': number of observations or timedelta object
+    """
+    if not spec_str:
+        return {'type': 'n', 'value': DEFAULT_LAST_N}
+    
+    # Convert to string if number passed
+    spec_str = str(spec_str).strip().lower()
+    
+    # Match patterns
+    n_pattern = re.match(r'^(\d+)n$', spec_str)
+    time_pattern = re.match(r'^(\d+)([hmd])$', spec_str)
+    
+    if n_pattern:
+        return {'type': 'n', 'value': int(n_pattern.group(1))}
+    
+    if time_pattern:
+        value = int(time_pattern.group(1))
+        unit = time_pattern.group(2)
+        
+        delta = {
+            'm': timedelta(minutes=value),
+            'h': timedelta(hours=value),
+            'd': timedelta(days=value)
+        }[unit]
+        
+        return {'type': 'time', 'value': delta}
+    
+    # Try to parse as plain number for backward compatibility
+    try:
+        return {'type': 'n', 'value': int(spec_str)}
+    except ValueError:
+        raise ValueError(
+            f"Invalid time specification: {spec_str}. "
+            "Use format: 30n (observations), 24h (hours), 45m (minutes), 7d (days)"
+        )
+
+def get_data(spec: dict, last_n: str = "30n", ensure_timestamp: bool = False) -> pd.DataFrame:
+    """
+    Get data from the database for a given spec and time specification.
     
     Args:
         spec: The spec to get data for.
-        last_n: The maximum number of observations to return.
+        last_n: Time specification (e.g., "30n", "24h", "45m", "7d")
+        ensure_timestamp: Whether to ensure timestamp column exists
         
     Returns:
         A pandas DataFrame containing the data.
     """
-    sql = render(
-        "dashboard_sql",
-        spec,
-        params={"last_n": last_n},
-    )
+    time_spec = parse_time_spec(last_n)
+    
+    if time_spec['type'] == 'time':
+        # For time-based queries, we'll need to modify the SQL
+        cutoff_time = datetime.now() - time_spec['value']
+        sql = render(
+            "dashboard_sql",
+            spec,
+            params={"cutoff_time": cutoff_time.isoformat()},
+            template_type="time_based"  # You'll need to add this template
+        )
+    else:
+        # For N-based queries, use existing logic
+        sql = render(
+            "dashboard_sql",
+            spec,
+            params={"last_n": time_spec['value']},
+        )
+    
     db = spec["db"]
     df = read_sql(sql, db=db)
 

dashboard/routes.py

@@ -395,24 +395,34 @@ def get(batch_name: str, search: str = ""):
 
 
 @rt("/batch/{batch_name}/update-n")
-def post(batch_name: str, last_n: int = DEFAULT_LAST_N, session=None):
+def post(batch_name: str, last_n: str = "30n", session=None):
     """
-    Update the number of observations for a given batch name.
+    Update the time window for a given batch name.
+    Supports formats like "30n" (observations), "24h" (hours), "45m" (minutes), "7d" (days)
     """
-    app.state.last_n[batch_name] = last_n
-    app.state.clear_batch_cache(batch_name)
+    try:
+        # Store the raw specification
+        app.state.last_n[batch_name] = last_n
+        app.state.clear_batch_cache(batch_name)
 
-    app.state.df_cache[batch_name] = get_data(
-        app.state.specs_enabled[batch_name], 
-        last_n=last_n,
-        ensure_timestamp=True
-    )
-    app.state.calculate_metric_stats(batch_name)
+        # Get new data with parsed specification
+        app.state.df_cache[batch_name] = get_data(
+            app.state.specs_enabled[batch_name], 
+            last_n=last_n,
+            ensure_timestamp=True
+        )
+        app.state.calculate_metric_stats(batch_name)
 
-    # Return the full page content with proper URL update
-    return get_batch_view(
-        batch_name, session=session, initial_load=DEFAULT_LOAD_N_CHARTS
-    )
+        # Return the full page content with proper URL update
+        return get_batch_view(
+            batch_name, session=session, initial_load=DEFAULT_LOAD_N_CHARTS
+        )
+    except ValueError as e:
+        # Return error message if invalid format
+        return Div(
+            P(str(e), cls="text-red-500 p-4 text-center"),
+            id="main-content",
+        )
 
 
 @rt("/batch/{batch_name}/toggle-size")

metrics/defaults/sql/dashboard.sql

@@ -21,6 +21,9 @@ where
   metric_type = 'metric'
   and 
   metric_timestamp >= current_date - interval '{{ alert_metric_timestamp_max_days_ago }} day'
+  {% if cutoff_time is defined %}
+  and metric_timestamp >= '{{ cutoff_time }}'
+  {% endif %}
 group by metric_timestamp, metric_batch, metric_name
 ),
 
@@ -176,8 +179,12 @@ select
   metric_change
 from 
   data_smoothed
+{% if cutoff_time is defined %}
+/* When using time-based filtering, don't limit by recency rank */
+{% else %}
 where 
   metric_value_recency_rank <= {{ last_n }}
+{% endif %}
 )
 
 select
@@ -191,4 +198,6 @@ select
   metric_change
 from 
   data_final
+order by
+  metric_timestamp
 ;