🤖 Auto-deploy from GitHub (push) - 3681966 - 2025-08-15 10:47:16 UTC

apps/gradio-app/src/fitness_gradio/main.py

@@ -68,7 +68,9 @@ def main():
         app.launch(**gradio_config)
         
     except Exception as e:
+        import traceback
         logger.error(f"Failed to start Gradio app: {str(e)}")
+        logger.error(f"Full traceback:\n{traceback.format_exc()}")
         sys.exit(1)
 
 

apps/gradio-app/src/fitness_gradio/ui/app.py

@@ -64,7 +64,7 @@ class FitnessAppUI:
             with gr.Row():
                 with gr.Column():
                     gr.Markdown("## 📅 Training Schedule Calendar")
-                    calendar_html, calendar_view_selector, calendar_prev_btn, calendar_next_btn, calendar_today_btn, calendar_date_picker, refresh_calendar_btn, calendar_current_date = UIComponents.create_calendar_section()
+                    calendar_html, calendar_view_selector, calendar_prev_btn, calendar_next_btn, calendar_today_btn, calendar_date_picker, refresh_calendar_btn, calendar_current_date, current_date_display = UIComponents.create_calendar_section()
             
             # Voice conversation state
             voice_state = gr.State(value=VoiceConversationState())
@@ -89,7 +89,7 @@ class FitnessAppUI:
                 voice_exit_btn, voice_row, voice_state,
                 plan_display, view_plan_btn, clear_plan_btn,
                 calendar_html, calendar_view_selector, calendar_prev_btn, calendar_next_btn, 
-                calendar_today_btn, calendar_date_picker, refresh_calendar_btn, calendar_current_date
+                calendar_today_btn, calendar_date_picker, refresh_calendar_btn, calendar_current_date, current_date_display
             )
     
     def _setup_event_handlers(
@@ -119,7 +119,8 @@ class FitnessAppUI:
         calendar_today_btn: gr.Button,
         calendar_date_picker: gr.DateTime,
         refresh_calendar_btn: gr.Button,
-        calendar_current_date: gr.Textbox
+        calendar_current_date: gr.Textbox,
+        current_date_display: gr.Markdown
     ) -> None:
         """Set up all event handlers."""
         
@@ -277,25 +278,25 @@ class FitnessAppUI:
         calendar_prev_btn.click(
             lambda current_date, view_type: UIHandlers.navigate_calendar(current_date, view_type, "prev"),
             inputs=[calendar_current_date, calendar_view_selector],
-            outputs=[calendar_html, calendar_current_date]
+            outputs=[calendar_html, calendar_current_date, current_date_display, calendar_date_picker]
         )
         
         calendar_next_btn.click(
             lambda current_date, view_type: UIHandlers.navigate_calendar(current_date, view_type, "next"),
             inputs=[calendar_current_date, calendar_view_selector],
-            outputs=[calendar_html, calendar_current_date]
+            outputs=[calendar_html, calendar_current_date, current_date_display, calendar_date_picker]
         )
         
         calendar_today_btn.click(
             UIHandlers.go_to_today,
             inputs=[calendar_view_selector],
-            outputs=[calendar_html, calendar_current_date]
+            outputs=[calendar_html, calendar_current_date, current_date_display, calendar_date_picker]
         )
         
         calendar_date_picker.change(
             UIHandlers.jump_to_date,
             inputs=[calendar_date_picker, calendar_view_selector],
-            outputs=[calendar_html, calendar_current_date]
+            outputs=[calendar_html, calendar_current_date, current_date_display, calendar_date_picker]
         )
         
         # Update calendar after bot responses (when new fitness plans are created)

apps/gradio-app/src/fitness_gradio/ui/components.py

@@ -2,8 +2,10 @@
 UI components for the fitness app.
 """
 import gradio as gr
+import calendar
+import re
 from typing import List, Any
-from datetime import date
+from datetime import date, datetime
 
 from fitness_core.agents import FitnessAgent
 from fitness_core.agents.providers import ModelProvider
@@ -1014,7 +1016,7 @@ class UIComponents:
         Create the training calendar section with navigation controls and view options.
         
         Returns:
-            Tuple of (calendar_html, view_selector, prev_btn, next_btn, today_btn, date_picker, refresh_calendar_btn, current_date)
+            Tuple of (calendar_html, view_selector, prev_btn, next_btn, today_btn, date_picker, refresh_calendar_btn, current_date, current_date_display)
         """
         from datetime import date
         
@@ -1060,13 +1062,13 @@ class UIComponents:
                 scale=2
             )
             
-            # Date picker for jumping to specific dates
+            # Date picker for jumping to specific dates - improved for better UX
             date_picker = gr.DateTime(
-                value=date.today().isoformat(),
-                label="Jump to Date",
-                info="Select a date to navigate to",
-                elem_classes=["date-picker"],
-                scale=1
+                value=datetime.now(),  # Use datetime.now() which works correctly
+                label="📅 Jump to Date",
+                info="Click the calendar icon to select a date",
+                interactive=True,
+                include_time=False  # Only show date picker, not time
             )
             
             refresh_calendar_btn = gr.Button(
@@ -1076,6 +1078,14 @@ class UIComponents:
                 scale=1
             )
         
+        # Small row to show current viewing date in readable format
+        with gr.Row():
+            current_date_display = gr.Markdown(
+                value=f"**Current View:** {date.today().strftime('%A, %B %d, %Y')}",
+                elem_classes=["current-date-display"],
+                visible=True
+            )
+        
         # Hidden component to track current date being displayed
         current_date = gr.Textbox(
             value=date.today().isoformat(),
@@ -1083,7 +1093,7 @@ class UIComponents:
             label="Current Display Date"
         )
         
-        return calendar_html, view_selector, prev_btn, next_btn, today_btn, date_picker, refresh_calendar_btn, current_date
+        return calendar_html, view_selector, prev_btn, next_btn, today_btn, date_picker, refresh_calendar_btn, current_date, current_date_display
 
     @staticmethod
     def _get_initial_calendar_html() -> str:

apps/gradio-app/src/fitness_gradio/ui/handlers.py

@@ -857,10 +857,11 @@ Please check your API keys and try a different model."""
             direction: Navigation direction ("prev" or "next")
             
         Returns:
-            Tuple of (updated_calendar_html, new_current_date)
+            Tuple of (updated_calendar_html, new_current_date, current_date_display, date_picker_value)
         """
         try:
             from .components import UIComponents
+            from datetime import datetime
             
             # Calculate new date
             new_date_str = UIComponents.calculate_navigation_date(current_date_str, view_type, direction)
@@ -868,13 +869,34 @@ Please check your API keys and try a different model."""
             # Refresh calendar with new date
             calendar_html = UIHandlers.refresh_calendar_with_date(view_type, new_date_str)
             
-            return calendar_html, new_date_str
+            # Format date for display
+            new_date = datetime.fromisoformat(new_date_str).date()
+            formatted_date = new_date.strftime('%A, %B %d, %Y')
+            current_date_display = f"**Current View:** {formatted_date}"
+            
+            # Convert to timestamp for DateTime component
+            new_datetime = datetime.combine(new_date, datetime.min.time())
+            new_timestamp = new_datetime.timestamp()
+            
+            return calendar_html, new_date_str, current_date_display, new_timestamp
             
         except Exception as e:
             logger.error(f"Error navigating calendar: {str(e)}")
             # Return current state on error
+            from datetime import date
             current_calendar = UIHandlers.refresh_calendar_with_date(view_type, current_date_str)
-            return current_calendar, current_date_str
+            try:
+                current_date = datetime.fromisoformat(current_date_str).date()
+                formatted_date = current_date.strftime('%A, %B %d, %Y')
+                current_date_display = f"**Current View:** {formatted_date}"
+                current_datetime = datetime.combine(current_date, datetime.min.time())
+                current_timestamp = current_datetime.timestamp()
+            except:
+                current_date = datetime.fromisoformat(current_date_str).date() if current_date_str else date.today()
+                current_date_display = f"**Current View:** {current_date_str}"
+                current_datetime = datetime.combine(current_date, datetime.min.time())
+                current_timestamp = current_datetime.timestamp()
+            return current_calendar, current_date_str, current_date_display, current_timestamp
 
     @staticmethod
     def go_to_today(view_type: str) -> tuple:
@@ -885,63 +907,177 @@ Please check your API keys and try a different model."""
             view_type: Type of calendar view to display
             
         Returns:
-            Tuple of (updated_calendar_html, today_date_str)
+            Tuple of (updated_calendar_html, today_date_str, current_date_display, date_picker_value)
         """
         try:
-            from datetime import date
+            from datetime import date, datetime
             
-            today_str = date.today().isoformat()
+            today = date.today()
+            today_str = today.isoformat()
             calendar_html = UIHandlers.refresh_calendar_with_date(view_type, today_str)
             
-            return calendar_html, today_str
+            # Format today's date for display
+            today_formatted = today.strftime('%A, %B %d, %Y')
+            current_date_display = f"**Current View:** {today_formatted}"
+            
+            # Convert to timestamp for DateTime component
+            today_datetime = datetime.combine(today, datetime.min.time())
+            today_timestamp = today_datetime.timestamp()
+            
+            return calendar_html, today_str, current_date_display, today_timestamp
             
         except Exception as e:
+            from datetime import date, datetime
             logger.error(f"Error going to today: {str(e)}")
-            return UIHandlers.refresh_calendar(view_type), date.today().isoformat()
+            today = date.today()
+            today_str = today.isoformat()
+            today_formatted = today.strftime('%A, %B %d, %Y')
+            today_datetime = datetime.combine(today, datetime.min.time())
+            today_timestamp = today_datetime.timestamp()
+            return UIHandlers.refresh_calendar(view_type), today_str, f"**Current View:** {today_formatted}", today_timestamp
 
     @staticmethod
     def jump_to_date(date_picker_value, view_type: str) -> tuple:
         """
         Jump the calendar to a specific date from the date picker.
+        Supports both manual text input and calendar selection.
         
         Args:
             date_picker_value: Date value from the date picker component
             view_type: Type of calendar view to display
             
         Returns:
-            Tuple of (updated_calendar_html, target_date_str)
+            Tuple of (updated_calendar_html, target_date_str, current_date_display, date_picker_value)
         """
         try:
             from datetime import datetime, date
+            import re
+            
+            # Debug logging to understand the input format
+            logger.info(f"jump_to_date received: {date_picker_value} (type: {type(date_picker_value)})")
+            
+            target_date = None
             
-            # Handle different date picker formats
-            if isinstance(date_picker_value, str):
-                if 'T' in date_picker_value:
-                    # ISO datetime format
-                    target_date = datetime.fromisoformat(date_picker_value.split('T')[0]).date()
+            # Handle None or empty values
+            if date_picker_value is None:
+                logger.info("Received None value, using today")
+                target_date = date.today()
+            elif isinstance(date_picker_value, (int, float)):
+                # Unix timestamp (most common case for gr.DateTime)
+                logger.info(f"Processing Unix timestamp: {date_picker_value}")
+                try:
+                    target_date = datetime.fromtimestamp(date_picker_value).date()
+                except (ValueError, OSError) as e:
+                    logger.warning(f"Failed to parse timestamp {date_picker_value}: {e}")
+                    target_date = date.today()
+            elif isinstance(date_picker_value, str):
+                # String input - handle various formats
+                date_str = date_picker_value.strip()
+                logger.info(f"Processing string date: '{date_str}'")
+                
+                if not date_str:
+                    logger.warning("Empty date string received")
+                    target_date = date.today()
+                elif 'T' in date_str:
+                    # ISO datetime format (2024-12-25T00:00:00)
+                    logger.info("Parsing as ISO datetime format")
+                    target_date = datetime.fromisoformat(date_str.split('T')[0]).date()
+                elif re.match(r'^\d{4}-\d{2}-\d{2}$', date_str):
+                    # ISO date format (2024-12-25) - most common from gr.DateTime
+                    logger.info("Parsing as ISO date format")
+                    target_date = datetime.fromisoformat(date_str).date()
+                elif re.match(r'^\d{1,2}/\d{1,2}/\d{4}$', date_str):
+                    # US date format (12/25/2024)
+                    logger.info("Parsing as US date format")
+                    month, day, year = map(int, date_str.split('/'))
+                    target_date = date(year, month, day)
+                elif re.match(r'^\d{1,2}-\d{1,2}-\d{4}$', date_str):
+                    # Alternative date format (12-25-2024)
+                    logger.info("Parsing as alternative date format")
+                    month, day, year = map(int, date_str.split('-'))
+                    target_date = date(year, month, day)
                 else:
-                    # ISO date format
-                    target_date = datetime.fromisoformat(date_picker_value).date()
-            elif hasattr(date_picker_value, 'date'):
-                # DateTime object
-                target_date = date_picker_value.date()
+                    # Try to parse as ISO date anyway
+                    logger.info("Attempting ISO date parsing as fallback")
+                    try:
+                        target_date = datetime.fromisoformat(date_str).date()
+                    except ValueError as ve:
+                        logger.warning(f"Failed to parse date string '{date_str}': {ve}")
+                        target_date = None
             elif isinstance(date_picker_value, date):
-                # Date object
+                # Direct date object
+                logger.info("Processing as date object")
                 target_date = date_picker_value
+            elif isinstance(date_picker_value, datetime):
+                # DateTime object - extract date part
+                logger.info("Processing as datetime object")
+                target_date = date_picker_value.date()
+            elif hasattr(date_picker_value, 'year') and hasattr(date_picker_value, 'month') and hasattr(date_picker_value, 'day'):
+                # Date-like object with year, month, day attributes
+                logger.info("Processing as date-like object with year/month/day attributes")
+                target_date = date(date_picker_value.year, date_picker_value.month, date_picker_value.day)
+            elif hasattr(date_picker_value, 'date') and callable(getattr(date_picker_value, 'date')):
+                # DateTime object with date() method
+                logger.info("Processing as datetime object with date() method")
+                target_date = date_picker_value.date()
             else:
-                # Fallback to today
+                logger.warning(f"Unrecognized date picker value format: {date_picker_value} (type: {type(date_picker_value)})")
+                # Check if it has attributes we can inspect
+                if hasattr(date_picker_value, '__dict__'):
+                    logger.info(f"Object attributes: {date_picker_value.__dict__}")
+                # Try to convert to string and parse
+                try:
+                    str_value = str(date_picker_value)
+                    logger.info(f"Attempting to parse string representation: '{str_value}'")
+                    if re.match(r'^\d{4}-\d{2}-\d{2}', str_value):
+                        target_date = datetime.fromisoformat(str_value.split()[0]).date()
+                    else:
+                        target_date = None
+                except Exception as conv_error:
+                    logger.warning(f"Failed to convert to string: {conv_error}")
+                    target_date = None
+            
+            # If we couldn't parse the date, use today as fallback
+            if target_date is None:
+                logger.warning(f"Could not parse date picker value: {date_picker_value} (type: {type(date_picker_value)}), using today")
                 target_date = date.today()
             
+            logger.info(f"Parsed target_date: {target_date}")
+            
+            # Validate the date is reasonable (not too far in past/future)
+            today = date.today()
+            min_date = date(today.year - 10, 1, 1)  # 10 years ago
+            max_date = date(today.year + 10, 12, 31)  # 10 years from now
+            
+            if target_date < min_date or target_date > max_date:
+                logger.warning(f"Date {target_date} is outside reasonable range, using today")
+                target_date = today
+            
             target_date_str = target_date.isoformat()
+            logger.info(f"Final target_date_str: {target_date_str}")
+            
             calendar_html = UIHandlers.refresh_calendar_with_date(view_type, target_date_str)
             
-            logger.info(f"Jumped to date: {target_date_str}")
-            return calendar_html, target_date_str
+            # Format date for display
+            formatted_date = target_date.strftime('%A, %B %d, %Y')
+            current_date_display = f"**Current View:** {formatted_date}"
+            
+            logger.info(f"Successfully jumped to date: {target_date_str} (view: {view_type})")
+            
+            # Convert target_date back to timestamp for the DateTime component
+            target_datetime = datetime.combine(target_date, datetime.min.time())
+            target_timestamp = target_datetime.timestamp()
+            
+            return calendar_html, target_date_str, current_date_display, target_timestamp
             
         except Exception as e:
-            logger.error(f"Error jumping to date: {str(e)}")
-            today_str = date.today().isoformat()
-            return UIHandlers.refresh_calendar(view_type), today_str
+            logger.error(f"Error jumping to date with value '{date_picker_value}': {str(e)}", exc_info=True)
+            today = date.today()
+            today_str = today.isoformat()
+            today_formatted = today.strftime('%A, %B %d, %Y')
+            today_datetime = datetime.combine(today, datetime.min.time())
+            today_timestamp = today_datetime.timestamp()
+            return UIHandlers.refresh_calendar(view_type), today_str, f"**Current View:** {today_formatted}", today_timestamp
 
     @staticmethod
     def handle_voice_input(

apps/gradio-app/src/fitness_gradio/ui/styles.py

@@ -267,6 +267,32 @@ MAIN_CSS = """
     max-width: 200px !important;
 }
 
+/* Current date display styles */
+.current-date-display {
+    margin: 10px 0 !important;
+    padding: 8px 12px !important;
+    background-color: rgba(59, 130, 246, 0.1) !important;
+    border: 1px solid rgba(59, 130, 246, 0.3) !important;
+    border-radius: 6px !important;
+    text-align: center !important;
+    font-size: 14px !important;
+}
+
+.current-date-display p {
+    margin: 0 !important;
+    color: #1e40af !important;
+}
+
+/* Dark theme support for current date display */
+.dark .current-date-display {
+    background-color: rgba(59, 130, 246, 0.2) !important;
+    border-color: rgba(59, 130, 246, 0.4) !important;
+}
+
+.dark .current-date-display p {
+    color: #93c5fd !important;
+}
+
 /* Month View Styles */
 .calendar-grid.month-view {
     display: flex;

apps/gradio-app/test_datetime.py

@@ -0,0 +1,34 @@
+#!/usr/bin/env python3
+"""
+Test script to understand how Gradio DateTime component works
+"""
+import gradio as gr
+from datetime import date, datetime
+
+def test_date_input(date_value):
+    """Test function to see what format gr.DateTime passes to the function"""
+    print(f"Received: {date_value}")
+    print(f"Type: {type(date_value)}")
+    if hasattr(date_value, '__dict__'):
+        print(f"Attributes: {date_value.__dict__}")
+    
+    # Try to convert to string representation
+    str_repr = str(date_value)
+    print(f"String representation: '{str_repr}'")
+    
+    return f"Input: {date_value} (type: {type(date_value).__name__})\nString: {str_repr}"
+
+# Create a simple interface to test the DateTime component
+demo = gr.Interface(
+    fn=test_date_input,
+    inputs=gr.DateTime(
+        value=datetime.now(),  # Use datetime.now() instead of date.today()
+        label="Test DateTime Picker",
+        include_time=False
+    ),
+    outputs=gr.Textbox(label="Result"),
+    title="DateTime Component Test"
+)
+
+if __name__ == "__main__":
+    demo.launch(server_name="0.0.0.0", server_port=7861, debug=True)

apps/gradio-app/test_datetime_simple.py

@@ -0,0 +1,56 @@
+#!/usr/bin/env python3
+"""
+Simple test to understand Gradio DateTime component behavior
+"""
+import gradio as gr
+from datetime import date, datetime
+
+def test_datetime_component():
+    """Test DateTime component creation and behavior"""
+    print("Testing Gradio DateTime component...")
+    
+    # Test 1: Create with datetime.now()
+    try:
+        dt1 = gr.DateTime(
+            value=datetime.now(),
+            include_time=False,
+            label="Test 1"
+        )
+        print(f"✓ Created DateTime with datetime.now(): {dt1.value}")
+    except Exception as e:
+        print(f"✗ Failed to create DateTime with datetime.now(): {e}")
+    
+    # Test 2: Create with date.today()
+    try:
+        dt2 = gr.DateTime(
+            value=date.today(),
+            include_time=False,
+            label="Test 2"
+        )
+        print(f"✓ Created DateTime with date.today(): {dt2.value}")
+    except Exception as e:
+        print(f"✗ Failed to create DateTime with date.today(): {e}")
+    
+    # Test 3: Create with ISO string
+    try:
+        dt3 = gr.DateTime(
+            value="2025-08-15",
+            include_time=False,
+            label="Test 3"
+        )
+        print(f"✓ Created DateTime with ISO string: {dt3.value}")
+    except Exception as e:
+        print(f"✗ Failed to create DateTime with ISO string: {e}")
+    
+    # Test 4: Create with no value
+    try:
+        dt4 = gr.DateTime(
+            include_time=False,
+            label="Test 4"
+        )
+        print(f"✓ Created DateTime with no value: {dt4.value}")
+    except Exception as e:
+        print(f"✗ Failed to create DateTime with no value: {e}")
+
+if __name__ == "__main__":
+    test_datetime_component()

test_datetime.py

@@ -0,0 +1,34 @@
+#!/usr/bin/env python3
+"""
+Test script to understand how Gradio Date component works
+"""
+import gradio as gr
+from datetime import date, datetime
+
+def test_date_input(date_value):
+    """Test function to see what format gr.Date passes to the function"""
+    print(f"Received: {date_value}")
+    print(f"Type: {type(date_value)}")
+    if hasattr(date_value, '__dict__'):
+        print(f"Attributes: {date_value.__dict__}")
+    
+    # Try to convert to string representation
+    str_repr = str(date_value)
+    print(f"String representation: '{str_repr}'")
+    
+    return f"Input: {date_value} (type: {type(date_value).__name__})\nString: {str_repr}"
+
+# Create a simple interface to test the Date component
+demo = gr.Interface(
+    fn=test_date_input,
+    inputs=gr.DateTime(
+        value=datetime.now(),  # Use datetime.now() instead of date.today()
+        label="Test DateTime Picker",
+        include_time=False
+    ),
+    outputs=gr.Textbox(label="Result"),
+    title="DateTime Component Test"
+)
+
+if __name__ == "__main__":
+    demo.launch(server_name="0.0.0.0", server_port=7861, debug=True)