mcli-framework 7.3.1__py3-none-any.whl → 7.4.0__py3-none-any.whl

mcli/ml/trading/alpaca_client.py

@@ -1,6 +1,7 @@
 """Alpaca Trading API client for executing trades"""
 
 import logging
+import os
 from datetime import datetime, timedelta
 from decimal import Decimal
 from typing import Dict, List, Optional, Tuple, Union
@@ -18,6 +19,10 @@ from alpaca.data.historical import StockHistoricalDataClient
 from alpaca.data.requests import StockBarsRequest
 from alpaca.data.timeframe import TimeFrame
 from pydantic import BaseModel, Field
+from dotenv import load_dotenv
+
+# Load environment variables
+load_dotenv()
 
 logger = logging.getLogger(__name__)
 
@@ -81,32 +86,44 @@ class AlpacaTradingClient:
         self.trading_client = TradingClient(
             api_key=config.api_key,
             secret_key=config.secret_key,
-            paper=config.paper_trading,
-            base_url=config.base_url
+            paper=config.paper_trading
         )
         self.data_client = StockHistoricalDataClient(
             api_key=config.api_key,
-            secret_key=config.secret_key,
-            base_url=config.data_url
+            secret_key=config.secret_key
         )
     
     def get_account(self) -> Dict:
         """Get account information"""
         try:
             account = self.trading_client.get_account()
-            return {
+
+            # Build response with safe attribute access
+            response = {
                 "account_id": account.id,
-                "equity": float(account.equity),
-                "cash": float(account.cash),
-                "buying_power": float(account.buying_power),
-                "portfolio_value": float(account.portfolio_value),
-                "unrealized_pl": float(account.unrealized_pl),
-                "realized_pl": float(account.realized_pl),
-                "currency": account.currency,
-                "status": account.status,
-                "trading_blocked": account.trading_blocked,
-                "pattern_day_trader": account.pattern_day_trader,
+                "equity": float(account.equity) if hasattr(account, 'equity') else 0.0,
+                "cash": float(account.cash) if hasattr(account, 'cash') else 0.0,
+                "buying_power": float(account.buying_power) if hasattr(account, 'buying_power') else 0.0,
+                "currency": account.currency if hasattr(account, 'currency') else "USD",
+                "status": account.status.value if hasattr(account.status, 'value') else str(account.status),
+                "trading_blocked": account.trading_blocked if hasattr(account, 'trading_blocked') else False,
+                "pattern_day_trader": account.pattern_day_trader if hasattr(account, 'pattern_day_trader') else False,
             }
+
+            # Add optional fields that may not exist in all account types
+            if hasattr(account, 'portfolio_value'):
+                response["portfolio_value"] = float(account.portfolio_value)
+            else:
+                response["portfolio_value"] = response["equity"]
+
+            if hasattr(account, 'long_market_value'):
+                response["unrealized_pl"] = float(account.long_market_value) - float(account.cash)
+            else:
+                response["unrealized_pl"] = 0.0
+
+            response["realized_pl"] = 0.0  # Not always available in paper accounts
+
+            return response
         except Exception as e:
             logger.error(f"Failed to get account info: {e}")
             raise
@@ -343,11 +360,58 @@ class AlpacaTradingClient:
             raise
 
 
-def create_trading_client(api_key: str, secret_key: str, paper_trading: bool = True) -> AlpacaTradingClient:
-    """Create a trading client with the given credentials"""
+def create_trading_client(api_key: str = None, secret_key: str = None, paper_trading: bool = True) -> AlpacaTradingClient:
+    """
+    Create a trading client with the given credentials or from environment variables
+
+    Args:
+        api_key: Alpaca API key (if None, loads from ALPACA_API_KEY env var)
+        secret_key: Alpaca secret key (if None, loads from ALPACA_SECRET_KEY env var)
+        paper_trading: Whether to use paper trading (default: True)
+
+    Returns:
+        AlpacaTradingClient instance
+    """
+    # Load from environment if not provided
+    if api_key is None:
+        api_key = os.getenv("ALPACA_API_KEY")
+    if secret_key is None:
+        secret_key = os.getenv("ALPACA_SECRET_KEY")
+
+    if not api_key or not secret_key:
+        raise ValueError(
+            "Alpaca API credentials not found. "
+            "Please provide api_key and secret_key, or set ALPACA_API_KEY and ALPACA_SECRET_KEY environment variables."
+        )
+
+    base_url = os.getenv("ALPACA_BASE_URL", "https://paper-api.alpaca.markets")
+
     config = TradingConfig(
         api_key=api_key,
         secret_key=secret_key,
+        base_url=base_url,
         paper_trading=paper_trading
     )
-    return AlpacaTradingClient(config)
+    return AlpacaTradingClient(config)
+
+
+def get_alpaca_config_from_env() -> Optional[Dict[str, str]]:
+    """
+    Get Alpaca configuration from environment variables
+
+    Returns:
+        Dictionary with API configuration or None if not configured
+    """
+    api_key = os.getenv("ALPACA_API_KEY")
+    secret_key = os.getenv("ALPACA_SECRET_KEY")
+    base_url = os.getenv("ALPACA_BASE_URL", "https://paper-api.alpaca.markets")
+
+    if not api_key or not secret_key:
+        return None
+
+    return {
+        "api_key": api_key,
+        "secret_key": secret_key,
+        "base_url": base_url,
+        "is_paper": "paper" in base_url.lower()
+    }

mcli/self/self_cmd.py

@@ -344,8 +344,38 @@ def collect_commands() -> List[Dict[str, Any]]:
                 module_name = ".".join(relative_path.with_suffix("").parts)
 
                 try:
-                    # Try to import the module
-                    module = importlib.import_module(module_name)
+                    # Suppress Streamlit warnings and logging during module import
+                    import warnings
+                    import logging
+                    import sys
+                    import os
+                    from contextlib import redirect_stderr
+                    from io import StringIO
+                    
+                    # Suppress Python warnings
+                    with warnings.catch_warnings():
+                        warnings.filterwarnings("ignore", message=".*missing ScriptRunContext.*")
+                        warnings.filterwarnings("ignore", message=".*No runtime found.*")
+                        warnings.filterwarnings("ignore", message=".*Session state does not function.*")
+                        warnings.filterwarnings("ignore", message=".*to view this Streamlit app.*")
+                        
+                        # Suppress Streamlit logger warnings
+                        streamlit_logger = logging.getLogger("streamlit")
+                        original_level = streamlit_logger.level
+                        streamlit_logger.setLevel(logging.CRITICAL)
+                        
+                        # Also suppress specific Streamlit sub-loggers
+                        logging.getLogger("streamlit.runtime.scriptrunner_utils.script_run_context").setLevel(logging.CRITICAL)
+                        logging.getLogger("streamlit.runtime.caching.cache_data_api").setLevel(logging.CRITICAL)
+                        
+                        # Redirect stderr to suppress Streamlit warnings
+                        with redirect_stderr(StringIO()):
+                            try:
+                                # Try to import the module
+                                module = importlib.import_module(module_name)
+                            finally:
+                                # Restore original logging level
+                                streamlit_logger.setLevel(original_level)
 
                     # Extract command and group objects
                     for name, obj in inspect.getmembers(module):
@@ -387,23 +417,177 @@ def collect_commands() -> List[Dict[str, Any]]:
     return commands
 
 
-@self_app.command("add-command")
+def open_editor_for_command(command_name: str, command_group: str, description: str) -> Optional[str]:
+    """
+    Open the user's default editor to allow them to write command logic.
+    
+    Args:
+        command_name: Name of the command
+        command_group: Group for the command
+        description: Description of the command
+        
+    Returns:
+        The Python code written by the user, or None if cancelled
+    """
+    import tempfile
+    import subprocess
+    import os
+    import sys
+    from pathlib import Path
+    
+    # Get the user's default editor
+    editor = os.environ.get('EDITOR')
+    if not editor:
+        # Try common editors in order of preference
+        for common_editor in ['vim', 'nano', 'code', 'subl', 'atom', 'emacs']:
+            if subprocess.run(['which', common_editor], capture_output=True).returncode == 0:
+                editor = common_editor
+                break
+    
+    if not editor:
+        click.echo("❌ No editor found. Please set the EDITOR environment variable or install vim/nano.")
+        return None
+    
+    # Create a temporary file with the template
+    template = get_command_template(command_name, command_group)
+    
+    # Add helpful comments to the template
+    enhanced_template = f'''"""
+{command_name} command for mcli.{command_group}.
+
+Description: {description}
+
+Instructions:
+1. Write your Python command logic below
+2. Use Click decorators for command definition
+3. Save and close the editor to create the command
+4. The command will be automatically converted to JSON format
+
+Example Click command structure:
+@click.command()
+@click.argument('name', default='World')
+def my_command(name):
+    \"\"\"My custom command.\"\"\"
+    click.echo(f"Hello, {{name}}!")
+"""
+import click
+from typing import Optional, List
+from pathlib import Path
+from mcli.lib.logger.logger import get_logger
+
+logger = get_logger()
+
+# Write your command logic here:
+# Replace this template with your actual command implementation
+
+{template.split('"""')[2].split('"""')[0] if '"""' in template else ''}
+
+# Your command implementation goes here:
+# Example:
+# @click.command()
+# @click.argument('name', default='World')
+# def {command_name}_command(name):
+#     \"\"\"{description}\"\"\"
+#     logger.info(f"Executing {command_name} command with name: {{name}}")
+#     click.echo(f"Hello, {{name}}! This is the {command_name} command.")
+'''
+    
+    # Create temporary file
+    with tempfile.NamedTemporaryFile(mode='w', suffix='.py', delete=False) as temp_file:
+        temp_file.write(enhanced_template)
+        temp_file_path = temp_file.name
+    
+    try:
+        # Check if we're in an interactive environment
+        if not sys.stdin.isatty() or not sys.stdout.isatty():
+            click.echo("❌ Editor requires an interactive terminal. Use --template flag for non-interactive mode.")
+            return None
+            
+        # Open editor
+        click.echo(f"📝 Opening {editor} to edit command logic...")
+        click.echo("💡 Write your Python command logic and save the file to continue.")
+        click.echo("💡 Press Ctrl+C to cancel command creation.")
+        
+        # Run the editor
+        result = subprocess.run([editor, temp_file_path], check=False)
+        
+        if result.returncode != 0:
+            click.echo("❌ Editor exited with error. Command creation cancelled.")
+            return None
+        
+        # Read the edited content
+        with open(temp_file_path, 'r') as f:
+            edited_code = f.read()
+        
+        # Check if the file was actually edited (not just the template)
+        if edited_code.strip() == enhanced_template.strip():
+            click.echo("⚠️  No changes detected. Command creation cancelled.")
+            return None
+        
+        # Extract the actual command code (remove the instructions)
+        lines = edited_code.split('\n')
+        code_lines = []
+        in_code_section = False
+        
+        for line in lines:
+            if line.strip().startswith('# Your command implementation goes here:'):
+                in_code_section = True
+                continue
+            if in_code_section:
+                code_lines.append(line)
+        
+        if not code_lines or not any(line.strip() for line in code_lines):
+            # Fallback: use the entire file content
+            code_lines = lines
+        
+        final_code = '\n'.join(code_lines).strip()
+        
+        if not final_code:
+            click.echo("❌ No command code found. Command creation cancelled.")
+            return None
+        
+        click.echo("✅ Command code captured successfully!")
+        return final_code
+        
+    except KeyboardInterrupt:
+        click.echo("\n❌ Command creation cancelled by user.")
+        return None
+    except Exception as e:
+        click.echo(f"❌ Error opening editor: {e}")
+        return None
+    finally:
+        # Clean up temporary file
+        try:
+            os.unlink(temp_file_path)
+        except OSError:
+            pass
+
+
+@self_app.command("add-command", deprecated=True)
 @click.argument("command_name", required=True)
 @click.option("--group", "-g", help="Command group (defaults to 'workflow')", default="workflow")
 @click.option(
     "--description", "-d", help="Description for the command", default="Custom command"
 )
-def add_command(command_name, group, description):
+@click.option(
+    "--template", "-t", is_flag=True, help="Use template mode (skip editor and use predefined template)"
+)
+def add_command(command_name, group, description, template):
     """
+    [DEPRECATED] Use 'mcli commands add' instead.
+
     Generate a new portable custom command saved to ~/.mcli/commands/.
 
-    Commands are automatically nested under the 'workflow' group by default,
-    making them portable and persistent across updates.
+    This command has been moved to 'mcli commands add' for better organization.
+    Please use the new command going forward.
 
     Example:
-        mcli self add-command my_command
-        mcli self add-command analytics --group data
+        mcli commands add my_command
+        mcli commands add analytics --group data
+        mcli commands add quick_cmd --template  # Use template without editor
     """
+    click.echo("[yellow]⚠️  DEPRECATED: This command has been moved to 'mcli commands add'[/yellow]")
+    click.echo("[yellow]   Please use: mcli commands add {} [options][/yellow]\n".format(command_name))
     command_name = command_name.lower().replace("-", "_")
 
     # Validate command name
@@ -448,7 +632,17 @@ def add_command(command_name, group, description):
             return 1
 
     # Generate command code
-    code = get_command_template(command_name, command_group)
+    if template:
+        # Use template mode - generate and save directly
+        code = get_command_template(command_name, command_group)
+        click.echo(f"📝 Using template for command: {command_name}")
+    else:
+        # Editor mode - open editor for user to write code
+        click.echo(f"🔧 Opening editor for command: {command_name}")
+        code = open_editor_for_command(command_name, command_group, description)
+        if code is None:
+            click.echo("❌ Command creation cancelled.")
+            return 1
 
     # Save the command
     saved_path = manager.save_command(
@@ -469,11 +663,16 @@ def add_command(command_name, group, description):
     return 0
 
 
-@self_app.command("list-commands")
+@self_app.command("list-commands", deprecated=True)
 def list_commands():
     """
+    [DEPRECATED] Use 'mcli commands list-custom' instead.
+
     List all custom commands stored in ~/.mcli/commands/.
     """
+    click.echo("[yellow]⚠️  DEPRECATED: This command has been moved to 'mcli commands list-custom'[/yellow]")
+    click.echo("[yellow]   Please use: mcli commands list-custom[/yellow]\n")
+
     manager = get_command_manager()
     commands = manager.load_all_commands()
 
@@ -507,13 +706,18 @@ def list_commands():
     return 0
 
 
-@self_app.command("remove-command")
+@self_app.command("remove-command", deprecated=True)
 @click.argument("command_name", required=True)
 @click.option("--yes", "-y", is_flag=True, help="Skip confirmation prompt")
 def remove_command(command_name, yes):
     """
+    [DEPRECATED] Use 'mcli commands remove' instead.
+
     Remove a custom command from ~/.mcli/commands/.
     """
+    click.echo("[yellow]⚠️  DEPRECATED: This command has been moved to 'mcli commands remove'[/yellow]")
+    click.echo(f"[yellow]   Please use: mcli commands remove {command_name}[/yellow]\n")
+
     manager = get_command_manager()
     command_file = manager.commands_dir / f"{command_name}.json"
 
@@ -537,14 +741,19 @@ def remove_command(command_name, yes):
         return 1
 
 
-@self_app.command("export-commands")
+@self_app.command("export-commands", deprecated=True)
 @click.argument("export_file", type=click.Path(), required=False)
 def export_commands(export_file):
     """
+    [DEPRECATED] Use 'mcli commands export' instead.
+
     Export all custom commands to a JSON file.
 
     If no file is specified, exports to commands-export.json in current directory.
     """
+    click.echo("[yellow]⚠️  DEPRECATED: This command has been moved to 'mcli commands export'[/yellow]")
+    click.echo(f"[yellow]   Please use: mcli commands export {export_file or '<file>'}[/yellow]\n")
+
     manager = get_command_manager()
 
     if not export_file:
@@ -563,13 +772,18 @@ def export_commands(export_file):
         return 1
 
 
-@self_app.command("import-commands")
+@self_app.command("import-commands", deprecated=True)
 @click.argument("import_file", type=click.Path(exists=True), required=True)
 @click.option("--overwrite", is_flag=True, help="Overwrite existing commands")
 def import_commands(import_file, overwrite):
     """
+    [DEPRECATED] Use 'mcli commands import' instead.
+
     Import custom commands from a JSON file.
     """
+    click.echo("[yellow]⚠️  DEPRECATED: This command has been moved to 'mcli commands import'[/yellow]")
+    click.echo(f"[yellow]   Please use: mcli commands import {import_file}[/yellow]\n")
+
     manager = get_command_manager()
     import_path = Path(import_file)
 
@@ -593,11 +807,16 @@ def import_commands(import_file, overwrite):
     return 0
 
 
-@self_app.command("verify-commands")
+@self_app.command("verify-commands", deprecated=True)
 def verify_commands():
     """
+    [DEPRECATED] Use 'mcli commands verify' instead.
+
     Verify that custom commands match the lockfile.
     """
+    click.echo("[yellow]⚠️  DEPRECATED: This command has been moved to 'mcli commands verify'[/yellow]")
+    click.echo("[yellow]   Please use: mcli commands verify[/yellow]\n")
+
     manager = get_command_manager()
 
     # First, ensure lockfile is up to date
@@ -631,11 +850,16 @@ def verify_commands():
     return 1
 
 
-@self_app.command("update-lockfile")
+@self_app.command("update-lockfile", deprecated=True)
 def update_lockfile():
     """
+    [DEPRECATED] Use 'mcli commands update-lockfile' instead.
+
     Update the commands lockfile with current state.
     """
+    click.echo("[yellow]⚠️  DEPRECATED: This command has been moved to 'mcli commands update-lockfile'[/yellow]")
+    click.echo("[yellow]   Please use: mcli commands update-lockfile[/yellow]\n")
+
     manager = get_command_manager()
 
     if manager.update_lockfile():
@@ -1557,7 +1781,7 @@ def update(check: bool, pre: bool, yes: bool, skip_ci_check: bool):
         console.print(f"[dim]{traceback.format_exc()}[/dim]")
 
 
-@self_app.command("import-script")
+@self_app.command("import-script", deprecated=True)
 @click.argument("script_path", type=click.Path(exists=True))
 @click.option("--name", "-n", help="Command name (defaults to script filename)")
 @click.option("--group", "-g", default="workflow", help="Command group")
@@ -1565,15 +1789,20 @@ def update(check: bool, pre: bool, yes: bool, skip_ci_check: bool):
 @click.option("--interactive", "-i", is_flag=True, help="Open in $EDITOR for review/editing")
 def import_script(script_path, name, group, description, interactive):
     """
+    [DEPRECATED] Use 'mcli commands import-script' instead.
+
     Import a Python script as a portable JSON command.
 
     Converts a Python script into a JSON command that can be loaded
     by mcli. The script should define Click commands.
 
     Examples:
-        mcli self import-script my_script.py
-        mcli self import-script my_script.py --name custom-cmd --interactive
+        mcli commands import-script my_script.py
+        mcli commands import-script my_script.py --name custom-cmd --interactive
     """
+    click.echo("[yellow]⚠️  DEPRECATED: This command has been moved to 'mcli commands import-script'[/yellow]")
+    click.echo(f"[yellow]   Please use: mcli commands import-script {script_path}[/yellow]\n")
+
     import subprocess
     import tempfile
 
@@ -1652,21 +1881,26 @@ def import_script(script_path, name, group, description, interactive):
     return 0
 
 
-@self_app.command("export-script")
+@self_app.command("export-script", deprecated=True)
 @click.argument("command_name")
 @click.option("--output", "-o", type=click.Path(), help="Output file path")
 @click.option("--standalone", "-s", is_flag=True, help="Make script standalone (add if __name__ == '__main__')")
 def export_script(command_name, output, standalone):
     """
+    [DEPRECATED] Use 'mcli commands export-script' instead.
+
     Export a JSON command to a Python script.
 
     Converts a portable JSON command back to a standalone Python script
     that can be edited and run independently.
 
     Examples:
-        mcli self export-script my-command
-        mcli self export-script my-command --output my_script.py --standalone
+        mcli commands export-script my-command
+        mcli commands export-script my-command --output my_script.py --standalone
     """
+    click.echo("[yellow]⚠️  DEPRECATED: This command has been moved to 'mcli commands export-script'[/yellow]")
+    click.echo(f"[yellow]   Please use: mcli commands export-script {command_name}[/yellow]\n")
+
     manager = get_command_manager()
 
     # Load the command
@@ -1720,20 +1954,25 @@ def export_script(command_name, output, standalone):
     return 0
 
 
-@self_app.command("edit-command")
+@self_app.command("edit-command", deprecated=True)
 @click.argument("command_name")
 @click.option("--editor", "-e", help="Editor to use (defaults to $EDITOR)")
 def edit_command(command_name, editor):
     """
+    [DEPRECATED] Use 'mcli commands edit' instead.
+
     Edit a command interactively using $EDITOR.
 
     Opens the command's Python code in your preferred editor,
     allows you to make changes, and saves the updated version.
 
     Examples:
-        mcli self edit-command my-command
-        mcli self edit-command my-command --editor code
+        mcli commands edit my-command
+        mcli commands edit my-command --editor code
     """
+    click.echo("[yellow]⚠️  DEPRECATED: This command has been moved to 'mcli commands edit'[/yellow]")
+    click.echo(f"[yellow]   Please use: mcli commands edit {command_name}[/yellow]\n")
+
     import subprocess
     import tempfile
 

{mcli_framework-7.3.1.dist-info → mcli_framework-7.4.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mcli-framework
-Version: 7.3.1
+Version: 7.4.0
 Summary: 🚀 High-performance CLI framework with Rust extensions, AI chat, and stunning visuals
 Author-email: Luis Fernandez de la Vara <luis@lefv.io>
 Maintainer-email: Luis Fernandez de la Vara <luis@lefv.io>
@@ -93,7 +93,7 @@ Requires-Dist: polars>=0.19.0
 Requires-Dist: pyarrow>=14.0.0
 Requires-Dist: yfinance>=0.2.18
 Requires-Dist: alpha-vantage>=2.3.1
-Requires-Dist: alpaca-py>=0.20.0
+Requires-Dist: alpaca-py==0.42.2
 Requires-Dist: cvxpy>=1.4.0
 Requires-Dist: python-jose[cryptography]>=3.3.0
 Requires-Dist: passlib[bcrypt]>=1.7.4
@@ -119,6 +119,7 @@ Requires-Dist: streamlit-autorefresh>=1.0.1
 Requires-Dist: typer>=0.9.0
 Requires-Dist: flask<3.0.0,>=2.3.0
 Requires-Dist: alpaca-trade-api>=0.26
+Requires-Dist: alpaca>=1.0.0
 Provides-Extra: gpu
 Requires-Dist: cupy-cuda12x>=12.3.0; extra == "gpu"
 Requires-Dist: nvidia-ml-py>=12.535.0; extra == "gpu"