mcli-framework 7.8.2__py3-none-any.whl → 7.8.4__py3-none-any.whl

mcli/ml/dashboard/app_supabase.py

@@ -1,6 +1,7 @@
 """Streamlit dashboard for ML system monitoring - Supabase version"""
 
 import asyncio
+import os
 from datetime import datetime, timedelta
 
 import numpy as np
@@ -48,7 +49,7 @@ def get_politicians_data():
 
 @st.cache_data(ttl=30)
 def get_disclosures_data():
-    """Get trading disclosures from Supabase"""
+    """Get trading disclosures from Supabase with politician details"""
     client = get_supabase_client()
     if not client:
         return pd.DataFrame()
@@ -64,6 +65,40 @@ def get_disclosures_data():
         )
         df = pd.DataFrame(response.data)
 
+        if df.empty:
+            return df
+
+        # Get all unique politician IDs
+        politician_ids = df["politician_id"].dropna().unique()
+
+        # Fetch politician details
+        politicians = {}
+        if len(politician_ids) > 0:
+            pol_response = (
+                client.table("politicians")
+                .select("id, full_name, party, state_or_country")
+                .in_("id", list(politician_ids))
+                .execute()
+            )
+            politicians = {p["id"]: p for p in pol_response.data}
+
+        # Add politician details to disclosures
+        df["politician_name"] = df["politician_id"].map(
+            lambda x: politicians.get(x, {}).get("full_name", "Unknown")
+        )
+        df["politician_party"] = df["politician_id"].map(
+            lambda x: politicians.get(x, {}).get("party", "Unknown")
+        )
+        df["politician_state"] = df["politician_id"].map(
+            lambda x: politicians.get(x, {}).get("state_or_country", "Unknown")
+        )
+
+        # Rename columns for compatibility
+        df["ticker_symbol"] = df["asset_ticker"]
+        df["amount"] = df["amount_exact"].fillna(
+            (df["amount_range_min"] + df["amount_range_max"]) / 2
+        )
+
         # Convert datetime columns to proper datetime format
         date_columns = ["transaction_date", "disclosure_date", "created_at", "updated_at"]
         for col in date_columns:
@@ -346,21 +381,29 @@ def show_politicians():
             )
         with col2:
             state_filter = st.multiselect(
-                "State",
-                options=politicians["state"].dropna().unique() if "state" in politicians else [],
+                "State/Country",
+                options=(
+                    politicians["state_or_country"].dropna().unique()
+                    if "state_or_country" in politicians
+                    else []
+                ),
                 default=[],
             )
         with col3:
-            active_only = st.checkbox("Active Only", value=True)
+            active_only = st.checkbox("Active Only", value=False)
 
         # Apply filters
         filtered = politicians.copy()
         if party_filter and "party" in filtered:
             filtered = filtered[filtered["party"].isin(party_filter)]
-        if state_filter and "state" in filtered:
-            filtered = filtered[filtered["state"].isin(state_filter)]
-        if active_only and "is_active" in filtered:
-            filtered = filtered[filtered["is_active"] == True]
+        if state_filter and "state_or_country" in filtered:
+            filtered = filtered[filtered["state_or_country"].isin(state_filter)]
+        if active_only and "term_end" in filtered:
+            # Filter for active (term_end is in the future or null)
+            filtered = filtered[
+                (filtered["term_end"].isna())
+                | (pd.to_datetime(filtered["term_end"]) > pd.Timestamp.now())
+            ]
 
         # Display data
         st.dataframe(filtered, width="stretch")
@@ -368,17 +411,20 @@ def show_politicians():
         # Stats
         col1, col2 = st.columns(2)
         with col1:
-            if "party" in filtered:
+            if "party" in filtered and not filtered["party"].dropna().empty:
                 party_dist = filtered["party"].value_counts()
                 fig = px.pie(
                     values=party_dist.values, names=party_dist.index, title="Party Distribution"
                 )
                 st.plotly_chart(fig, width="stretch", config={"responsive": True})
         with col2:
-            if "state" in filtered:
-                state_dist = filtered["state"].value_counts().head(10)
+            if "state_or_country" in filtered and not filtered["state_or_country"].dropna().empty:
+                state_dist = filtered["state_or_country"].value_counts().head(10)
                 fig = px.bar(
-                    x=state_dist.values, y=state_dist.index, orientation="h", title="Top States"
+                    x=state_dist.values,
+                    y=state_dist.index,
+                    orientation="h",
+                    title="Top States/Countries",
                 )
                 st.plotly_chart(fig, width="stretch", config={"responsive": True})
     else:

mcli/ml/dashboard/pages/predictions_enhanced.py

@@ -158,54 +158,83 @@ def generate_mock_historical_performance() -> pd.DataFrame:
 
 
 def get_real_predictions() -> pd.DataFrame:
-    """Get real predictions from ML pipeline"""
+    """Get real predictions from ML pipeline - REQUIRES SUPABASE CONNECTION"""
     if not HAS_REAL_DATA:
-        st.warning("⚠️ Supabase connection not configured. Using demo data.")
-        return generate_mock_predictions()
+        st.error("❌ **CONFIGURATION ERROR**: Real data functions not available!")
+        st.error(
+            "Cannot import Supabase utilities. Check that `src/mcli/ml/dashboard/utils.py` exists."
+        )
+        st.stop()
 
     try:
         # Get real disclosure data
         disclosures = get_disclosures_data()
 
         if disclosures.empty:
-            st.info(
-                "No disclosure data available. Click 'Run ML Pipeline' in sidebar to generate predictions."
+            st.error("❌ **DATABASE ERROR**: No trading disclosure data available!")
+            st.error("Supabase connection may not be configured. Check secrets configuration.")
+            st.code(
+                """
+# Required Streamlit Secrets:
+SUPABASE_URL = "your_supabase_url"
+SUPABASE_KEY = "your_supabase_key"
+SUPABASE_SERVICE_ROLE_KEY = "your_service_role_key"
+""",
+                language="toml",
+            )
+            st.stop()
+
+        # Check if we have enough data for ML
+        if len(disclosures) < 10:
+            st.error(
+                f"❌ **INSUFFICIENT DATA**: Found only {len(disclosures)} disclosures. "
+                f"Need at least 10 for ML predictions."
             )
-            return generate_mock_predictions()
+            st.info("Please run data collection workflows to populate the database.")
+            st.stop()
 
         # Run ML pipeline to generate predictions
-        _, _, predictions = run_ml_pipeline(disclosures)
-
-        if predictions is not None and not predictions.empty:
-            # Ensure all required columns exist
-            required_cols = [
-                "ticker",
-                "predicted_return",
-                "confidence",
-                "risk_score",
-                "recommendation",
-                "sector",
-                "politician",
-            ]
-
-            for col in required_cols:
-                if col not in predictions.columns:
-                    if col == "sector":
-                        predictions[col] = "Technology"  # Default
-                    elif col == "politician":
-                        predictions[col] = "Unknown"
-                    elif col == "ticker":
-                        predictions[col] = "UNK"
-
-            return predictions
-        else:
-            st.info("ML pipeline did not generate predictions. Using demo data for display.")
-            return generate_mock_predictions()
+        st.success(f"✅ Loaded {len(disclosures)} real trading disclosures from database!")
+
+        try:
+            _, _, predictions = run_ml_pipeline(disclosures)
+
+            if predictions is not None and not predictions.empty:
+                # Ensure all required columns exist
+                required_cols = [
+                    "ticker",
+                    "predicted_return",
+                    "confidence",
+                    "risk_score",
+                    "recommendation",
+                    "sector",
+                    "politician",
+                ]
+
+                for col in required_cols:
+                    if col not in predictions.columns:
+                        if col == "sector":
+                            predictions[col] = "Technology"  # Default
+                        elif col == "politician":
+                            predictions[col] = "Unknown"
+                        elif col == "ticker":
+                            predictions[col] = "UNK"
+
+                st.success("✅ Generated ML predictions from real data!")
+                return predictions
+            else:
+                st.error("❌ **ML PIPELINE ERROR**: Predictions returned empty!")
+                st.error("ML pipeline ran but produced no predictions.")
+                st.stop()
+        except Exception as ml_error:
+            st.error(f"❌ **ML PIPELINE ERROR**: {ml_error}")
+            st.exception(ml_error)
+            st.stop()
 
     except Exception as e:
-        st.error(f"Error loading predictions: {e}")
-        st.info("Falling back to demo data")
-        return generate_mock_predictions()
+        st.error(f"❌ **FATAL ERROR**: {e}")
+        st.exception(e)
+        st.stop()
 
 
 def show_predictions_enhanced():
@@ -659,12 +688,27 @@ def show_prediction_generator():
 
 
 def show_performance_tracker():
-    """Show prediction performance over time"""
+    """Show prediction performance over time - REQUIRES REAL ML PREDICTION HISTORY"""
 
     st.subheader("📈 Prediction Performance Tracker")
     st.markdown("Track the accuracy and ROI of our ML predictions over time")
 
-    # Generate historical data
+    # TODO: Implement real performance tracking from database
+    st.error(
+        "❌ **FEATURE NOT IMPLEMENTED**: Performance tracking requires ML prediction history database."
+    )
+    st.info(
+        """
+    This feature requires:
+    1. A prediction_history table in Supabase
+    2. Automated prediction tracking and validation
+    3. Historical performance metrics calculation
+
+    Currently showing mock data for demonstration only.
+    """
+    )
+
+    # Generate historical data (mock for now)
     performance_df = generate_mock_historical_performance()
 
     # KPIs

mcli/ml/dashboard/utils.py

@@ -69,17 +69,11 @@ def get_disclosures_data() -> pd.DataFrame:
     """Get trading disclosures from Supabase with proper schema mapping"""
     client = get_supabase_client()
     if not client:
-        return _generate_demo_disclosures()
+        st.warning("⚠️ Supabase connection not available. Configure SUPABASE_URL and SUPABASE_KEY.")
+        return pd.DataFrame()  # Return empty instead of demo data
 
     try:
-        # First, get total count
-        count_response = client.table("trading_disclosures").select("*", count="exact").execute()
-        total_count = count_response.count
-
-        if total_count == 0:
-            return _generate_demo_disclosures()
-
-        # Get the data
+        # Get the data with politician details joined
         response = (
             client.table("trading_disclosures")
             .select("*")
@@ -89,14 +83,48 @@ def get_disclosures_data() -> pd.DataFrame:
         )
 
         if not response.data:
-            return _generate_demo_disclosures()
+            st.info(
+                "📊 No trading disclosures found in database. Data collection may be in progress."
+            )
+            return pd.DataFrame()
 
         df = pd.DataFrame(response.data)
+
+        # Get politician details and join
+        if not df.empty and "politician_id" in df.columns:
+            politician_ids = df["politician_id"].dropna().unique()
+            if len(politician_ids) > 0:
+                pol_response = (
+                    client.table("politicians")
+                    .select("id, full_name, party, state_or_country")
+                    .in_("id", list(politician_ids))
+                    .execute()
+                )
+                politicians = {p["id"]: p for p in pol_response.data}
+
+                # Add politician details
+                df["politician_name"] = df["politician_id"].map(
+                    lambda x: politicians.get(x, {}).get("full_name", "Unknown")
+                )
+                df["politician_party"] = df["politician_id"].map(
+                    lambda x: politicians.get(x, {}).get("party", "Unknown")
+                )
+                df["politician_state"] = df["politician_id"].map(
+                    lambda x: politicians.get(x, {}).get("state_or_country", "Unknown")
+                )
+
+                # Map column names for compatibility
+                df["ticker_symbol"] = df["asset_ticker"]
+                df["amount"] = df["amount_exact"].fillna(
+                    (df["amount_range_min"] + df["amount_range_max"]) / 2
+                )
+
         return df
 
     except Exception as e:
+        st.error(f"❌ Error fetching disclosures: {e}")
         logger.error(f"Failed to fetch disclosures: {e}")
-        return _generate_demo_disclosures()
+        return pd.DataFrame()
 
 
 def _generate_demo_disclosures() -> pd.DataFrame:

mcli/self/self_cmd.py

@@ -102,79 +102,8 @@ def restore_command_state(hash_value):
     return True
 
 
-# Create a Click group for all command management
-@self_app.group("commands")
-def commands_group():
-    """Manage CLI commands and command state."""
-    pass
-
-
-# Move the command-state group under commands_group
-@commands_group.group("state")
-def command_state():
-    """Manage command state lockfile and history."""
-    pass
-
-
-@command_state.command("list")
-def list_states():
-    """List all saved command states (hash, timestamp, #commands)."""
-    states = load_lockfile()
-    if not states:
-        click.echo("No command states found.")
-        return
-    table = Table(title="Command States")
-    table.add_column("Hash", style="cyan")
-    table.add_column("Timestamp", style="green")
-    table.add_column("# Commands", style="yellow")
-    for state in states:
-        table.add_row(state["hash"][:8], state["timestamp"], str(len(state["commands"])))
-    console.print(table)
-
-
-@command_state.command("restore")
-@click.argument("hash_value")
-def restore_state(hash_value):
-    """Restore to a previous command state by hash."""
-    if restore_command_state(hash_value):
-        click.echo(f"Restored to state {hash_value[:8]}")
-    else:
-        click.echo(f"State {hash_value[:8]} not found.", err=True)
-
-
-@command_state.command("write")
-@click.argument("json_file", required=False, type=click.Path(exists=False))
-def write_state(json_file):
-    """Write a new command state to the lockfile from a JSON file or the current app state."""
-    import traceback
-
-    print("[DEBUG] write_state called")
-    print(f"[DEBUG] LOCKFILE_PATH: {LOCKFILE_PATH}")
-    try:
-        if json_file:
-            print(f"[DEBUG] Loading command state from file: {json_file}")
-            with open(json_file, "r") as f:
-                commands = json.load(f)
-            click.echo(f"Loaded command state from {json_file}.")
-        else:
-            print("[DEBUG] Snapshotting current command state.")
-            commands = get_current_command_state()
-        state_hash = hash_command_state(commands)
-        new_state = {
-            "hash": state_hash,
-            "timestamp": datetime.utcnow().isoformat() + "Z",
-            "commands": commands,
-        }
-        append_lockfile(new_state)
-        print(f"[DEBUG] Wrote new command state {state_hash[:8]} to lockfile at {LOCKFILE_PATH}")
-        click.echo(f"Wrote new command state {state_hash[:8]} to lockfile.")
-    except Exception as e:
-        print(f"[ERROR] Exception in write_state: {e}")
-        print(traceback.format_exc())
-        click.echo(f"[ERROR] Failed to write command state: {e}", err=True)
-
-
 # On CLI startup, check and update lockfile if needed
+# NOTE: The commands group has been moved to mcli.app.commands_cmd for better organization
 
 
 def check_and_update_command_lockfile():
@@ -250,76 +179,7 @@ def {name}_command(name: str = "World"):
     return template
 
 
-@self_app.command("search")
-@click.argument("query", required=False)
-@click.option("--full", "-f", is_flag=True, help="Show full command paths and descriptions")
-def search(query, full):
-    """
-    Search for available commands using fuzzy matching.
-
-    Similar to telescope in neovim, this allows quick fuzzy searching
-    through all available commands in mcli.
-
-    If no query is provided, lists all commands.
-    """
-    # Collect all commands from the application
-    commands = collect_commands()
-
-    # Display the commands in a table
-    table = Table(title="mcli Commands")
-    table.add_column("Command", style="green")
-    table.add_column("Group", style="blue")
-    if full:
-        table.add_column("Path", style="dim")
-        table.add_column("Description", style="yellow")
-
-    if query:
-        filtered_commands = []
-
-        # Try to use fuzzywuzzy for better matching if available
-        if process:
-            # Extract command names for matching
-            command_names = [
-                f"{cmd['group']}.{cmd['name']}" if cmd["group"] else cmd["name"] for cmd in commands
-            ]
-            matches = process.extract(query, command_names, limit=10)
-
-            # Filter to matched commands
-            match_indices = [command_names.index(match[0]) for match in matches if match[1] > 50]
-            filtered_commands = [commands[i] for i in match_indices]
-        else:
-            # Fallback to simple substring matching
-            filtered_commands = [
-                cmd
-                for cmd in commands
-                if query.lower() in cmd["name"].lower()
-                or (cmd["group"] and query.lower() in cmd["group"].lower())
-            ]
-
-        commands = filtered_commands
-
-    # Sort commands by group then name
-    commands.sort(key=lambda c: (c["group"] if c["group"] else "", c["name"]))
-
-    # Add rows to the table
-    for cmd in commands:
-        if full:
-            table.add_row(
-                cmd["name"],
-                cmd["group"] if cmd["group"] else "-",
-                cmd["path"],
-                cmd["help"] if cmd["help"] else "",
-            )
-        else:
-            table.add_row(cmd["name"], cmd["group"] if cmd["group"] else "-")
-
-    console.print(table)
-
-    if not commands:
-        logger.info("No commands found matching the search query")
-        click.echo("No commands found matching the search query")
-
-    return 0
+# NOTE: search command has been moved to mcli.app.commands_cmd for better organization
 
 
 def collect_commands() -> List[Dict[str, Any]]:
@@ -575,110 +435,7 @@ logger = get_logger()
             pass
 
 
-@self_app.command("extract-workflow-commands")
-@click.option(
-    "--output", "-o", type=click.Path(), help="Output file (default: workflow-commands.json)"
-)
-def extract_workflow_commands(output):
-    """
-    Extract workflow commands from Python modules to JSON format.
-
-    This command helps migrate existing workflow commands to portable JSON format.
-    """
-    import inspect
-    from pathlib import Path
-
-    output_file = Path(output) if output else Path("workflow-commands.json")
-
-    workflow_commands = []
-
-    # Try to get workflow from the main app
-    try:
-        from mcli.app.main import create_app
-
-        app = create_app()
-
-        # Check if workflow group exists
-        if "workflow" in app.commands:
-            workflow_group = app.commands["workflow"]
-
-            # Force load lazy group if needed
-            if hasattr(workflow_group, "_load_group"):
-                workflow_group = workflow_group._load_group()
-
-            if hasattr(workflow_group, "commands"):
-                for cmd_name, cmd_obj in workflow_group.commands.items():
-                    # Extract command information
-                    command_info = {
-                        "name": cmd_name,
-                        "group": "workflow",
-                        "description": cmd_obj.help or "Workflow command",
-                        "version": "1.0",
-                        "metadata": {"source": "workflow", "migrated": True},
-                    }
-
-                    # Create a template based on command type
-                    # Replace hyphens with underscores for valid Python function names
-                    safe_name = cmd_name.replace("-", "_")
-
-                    if isinstance(cmd_obj, click.Group):
-                        # For groups, create a template
-                        command_info[
-                            "code"
-                        ] = f'''"""
-{cmd_name} workflow command.
-"""
-import click
-
-@click.group(name="{cmd_name}")
-def app():
-    """{cmd_obj.help or 'Workflow command group'}"""
-    pass
-
-# Add your subcommands here
-'''
-                    else:
-                        # For regular commands, create a template
-                        command_info[
-                            "code"
-                        ] = f'''"""
-{cmd_name} workflow command.
-"""
-import click
-
-@click.command(name="{cmd_name}")
-def app():
-    """{cmd_obj.help or 'Workflow command'}"""
-    click.echo("Workflow command: {cmd_name}")
-    # Add your implementation here
-'''
-
-                    workflow_commands.append(command_info)
-
-        if workflow_commands:
-            import json
-
-            with open(output_file, "w") as f:
-                json.dump(workflow_commands, f, indent=2)
-
-            click.echo(f"✅ Extracted {len(workflow_commands)} workflow commands")
-            click.echo(f"📁 Saved to: {output_file}")
-            click.echo(
-                f"\n💡 These are templates. Import with: mcli self import-commands {output_file}"
-            )
-            click.echo("   Then customize the code in ~/.mcli/commands/<command>.json")
-            return 0
-        else:
-            click.echo("⚠️  No workflow commands found to extract")
-            return 1
-
-    except Exception as e:
-        logger.error(f"Failed to extract workflow commands: {e}")
-        click.echo(f"❌ Failed to extract workflow commands: {e}", err=True)
-        import traceback
-
-        click.echo(traceback.format_exc(), err=True)
-        return 1
+# NOTE: extract-workflow-commands has been moved to mcli.app.commands_cmd for better organization
 
 
 @click.group("plugin")
@@ -1280,6 +1037,8 @@ try:
 except ImportError as e:
     logger.debug(f"Could not load visual command: {e}")
 
+# NOTE: store command has been moved to mcli.app.commands_cmd for better organization
+
 # This part is important to make the command available to the CLI
 if __name__ == "__main__":
     self_app()