createsonline 0.1.26__py3-none-any.whl

createsonline/cli/commands/serve.py

@@ -0,0 +1,173 @@
+# createsonline/cli/commands/serve.py
+"""
+CREATESONLINE Server Commands - Pure Internal Implementation
+
+Provides serve, dev, and prod commands for running the framework.
+Uses CREATESONLINE's internal pure Python server - NO uvicorn needed!
+"""
+import os
+import sys
+from pathlib import Path
+
+# Internal console implementation (fallback for rich)
+try:
+    from rich.console import Console
+    from rich.panel import Panel
+    RICH_AVAILABLE = True
+    console = Console()
+except ImportError:
+    RICH_AVAILABLE = False
+    # Internal console fallback
+    class SimpleConsole:
+        def print(self, text, **kwargs):
+            if isinstance(text, str):
+                print(text)
+            else:
+                print(str(text))
+    console = SimpleConsole()
+
+# Internal dotenv fallback
+try:
+    from dotenv import load_dotenv
+    DOTENV_AVAILABLE = True
+except ImportError:
+    DOTENV_AVAILABLE = False
+    def load_dotenv():
+        """Internal dotenv fallback - reads .env file manually"""
+        env_file = Path('.env')
+        if env_file.exists():
+            with open(env_file, 'r') as f:
+                for line in f:
+                    line = line.strip()
+                    if line and not line.startswith('#') and '=' in line:
+                        key, value = line.split('=', 1)
+                        os.environ[key.strip()] = value.strip()
+
+def serve_command(host="0.0.0.0", port=8000, reload=True, workers=1, app_module="main:app"):
+    """🚀 Start CREATESONLINE development server - Pure Internal Implementation"""
+    
+    load_dotenv()
+    
+    if RICH_AVAILABLE:
+        console.print(Panel(
+            "[bold blue]🚀 CREATESONLINE Framework - Internal Server[/bold blue]\n"
+            "[cyan]AI-Native Web Framework[/cyan]\n\n"
+            f"[green]Server:[/green] http://{host}:{port}\n"
+            f"[green]Mode:[/green] {'Development' if reload else 'Production'}\n"
+            f"[green]Workers:[/green] {workers if not reload else 1}\n"
+            f"[green]App:[/green] {app_module}\n"
+            f"[yellow]Server:[/yellow] CREATESONLINE Internal (Pure Python)",
+            title="🌐 Server Starting",
+            border_style="blue"
+        ))
+    else:
+        print("🚀 CREATESONLINE Framework - Internal Server")
+        print("AI-Native Web Framework")
+        print(f"Server: http://{host}:{port}")
+        print(f"Mode: {'Development' if reload else 'Production'}")
+        print(f"Workers: {workers if not reload else 1}")
+        print(f"App: {app_module}")
+        print("Server: CREATESONLINE Internal (Pure Python)")
+    
+    # Use internal server - just run the app file directly
+    try:
+        if os.path.exists("main.py"):
+            sys.exit(os.system(f"{sys.executable} main.py"))
+        elif os.path.exists("app.py"):
+            sys.exit(os.system(f"{sys.executable} app.py"))
+        else:
+            console.print("❌ No main.py or app.py found. Create one to run your app.")
+            return
+    except KeyboardInterrupt:
+        console.print("\nServer stopped by user")
+    except Exception as e:
+        console.print(f"Server error: {e}")
+
+def dev_command(host="127.0.0.1", port=8000, app_module="main:app"):
+    """🔧 Start development server with auto-reload and debugging - Pure Independence"""
+    
+    load_dotenv()
+    
+    if RICH_AVAILABLE:
+        console.print(Panel(
+            "[bold green]🔧 CREATESONLINE Development Mode - Pure Independence[/bold green]\n"
+            "[cyan]Enhanced development experience - Zero external dependencies[/cyan]\n\n"
+            "[green]Features:[/green]\n"
+            "• Auto-reload on file changes\n"
+            "• Verbose logging\n" 
+            "• Error debugging\n"
+            "• Hot module reloading\n"
+            "• Pure internal implementation",
+            title="🛠️ Pure Development Server",
+            border_style="green"
+        ))
+    else:
+        print("🔧 CREATESONLINE Development Mode - Pure Independence")
+        print("Enhanced development experience - Zero external dependencies")
+        print("Features: Auto-reload, Verbose logging, Error debugging, Hot module reloading")
+    
+    # Use internal server - just run the app file directly
+    try:
+        if os.path.exists("main.py"):
+            sys.exit(os.system(f"{sys.executable} main.py"))
+        elif os.path.exists("app.py"):
+            sys.exit(os.system(f"{sys.executable} app.py"))
+        else:
+            console.print("❌ No main.py or app.py found. Create one to run your app.")
+            return
+    except KeyboardInterrupt:
+        console.print("\nDevelopment server stopped")
+    except Exception as e:
+        console.print(f"Development server error: {e}")
+
+def prod_command(host="0.0.0.0", port=8000, workers=4, app_module="main:app"):
+    """🏭 Start production server with optimized settings - Pure Independence"""
+    
+    load_dotenv()
+    
+    if RICH_AVAILABLE:
+        console.print(Panel(
+            "[bold red]🏭 CREATESONLINE Production Mode - Pure Independence[/bold red]\n"
+            "[cyan]Pure Independence - Optimized for performance and stability[/cyan]\n\n"
+            f"[green]Workers:[/green] {workers}\n"
+            f"[green]Host:[/green] {host}:{port}\n"
+            "[green]Features:[/green]\n"
+            "• Multiple worker processes\n"
+            "• Optimized logging\n"
+            "• Production error handling\n"
+            "• Pure internal implementation\n"
+            "• Zero external performance dependencies",
+            title="🚀 Production Server", 
+            border_style="red"
+        ))
+    else:
+        print("🏭 CREATESONLINE Production Mode - Pure Independence")
+        print("Pure Independence - Optimized for performance and stability")
+        print(f"Workers: {workers}")
+        print(f"Host: {host}:{port}")
+        print("Features: Multiple workers, Optimized logging, Production error handling")
+    
+    # Use internal server - just run the app file directly
+    try:
+        if os.path.exists("main.py"):
+            sys.exit(os.system(f"{sys.executable} main.py"))
+        elif os.path.exists("app.py"):
+            sys.exit(os.system(f"{sys.executable} app.py"))
+        else:
+            console.print("❌ No main.py or app.py found for production!")
+            console.print("Create your application file first")
+            sys.exit(1)
+    except KeyboardInterrupt:
+        console.print("\nProduction server stopped")
+    except Exception as e:
+        console.print(f"Production server error: {e}")
+
+# Internal command registry (no typer dependency)
+SERVE_COMMANDS = {
+    'start': serve_command,
+    'serve': serve_command,
+    'dev': dev_command,
+    'development': dev_command,
+    'prod': prod_command,
+    'production': prod_command
+}

createsonline/cli/commands/shell.py

@@ -0,0 +1,93 @@
+# createsonline/cli/commands/shell.py
+"""
+CREATESONLINE Interactive Shell
+
+Launch an interactive Python shell with CREATESONLINE imports.
+"""
+from rich.console import Console
+
+console = Console()
+
+def shell_command():
+    """🐚 Interactive CREATESONLINE shell with pre-loaded imports"""
+    
+    console.print("🐚 [bold blue]CREATESONLINE Interactive Shell[/bold blue]")
+    console.print("[cyan]Pre-loaded imports available:[/cyan]")
+    console.print("  • [yellow]createsonline[/yellow] - Main framework")
+    console.print("  • [yellow]createsonline.ai[/yellow] - AI capabilities") 
+    console.print("  • [yellow]app[/yellow] - Application instance (if main.py exists)")
+    console.print("  • [yellow]models[/yellow] - Database models (if available)")
+    console.print()
+    
+    # Prepare the shell environment
+    import sys
+    import os
+    
+    # Try to import createsonline
+    shell_globals = {}
+    shell_locals = {}
+    
+    try:
+        import createsonline
+        shell_globals['createsonline'] = createsonline
+        console.print("✅ [green]createsonline imported[/green]")
+    except ImportError:
+        console.print("⚠️ [yellow]createsonline not available[/yellow]")
+    
+    try:
+        import createsonline.ai as ai
+        shell_globals['ai'] = ai
+        console.print("✅ [green]createsonline.ai imported[/green]")
+    except ImportError:
+        console.print("⚠️ [yellow]createsonline.ai not available[/yellow]")
+    
+    # Try to import app from main.py
+    if os.path.exists("main.py"):
+        try:
+            sys.path.insert(0, os.getcwd())
+            import main
+            if hasattr(main, 'app'):
+                shell_globals['app'] = main.app
+                console.print("✅ [green]app imported from main.py[/green]")
+        except Exception as e:
+            console.print(f"⚠️ [yellow]Could not import app: {e}[/yellow]")
+    
+    # Try to import models
+    if os.path.exists("models"):
+        try:
+            import models
+            shell_globals['models'] = models
+            console.print("✅ [green]models imported[/green]")
+        except Exception:
+            pass
+    
+    # Common imports
+    shell_globals.update({
+        'os': os,
+        'sys': sys,
+        'Path': __import__('pathlib').Path,
+        'json': __import__('json'),
+        'asyncio': __import__('asyncio'),
+    })
+    
+    console.print()
+    console.print("[dim]Type 'exit()' or Ctrl+D to quit[/dim]")
+    console.print()
+    
+    # Launch the shell
+    try:
+        # Try IPython first (better experience)
+        try:
+            from IPython import start_ipython
+            start_ipython(argv=[], user_ns=shell_globals)
+        except ImportError:
+            # Fallback to standard Python shell
+            import code
+            code.interact(
+                banner="Python shell with CREATESONLINE",
+                local=shell_globals
+            )
+    except (EOFError, KeyboardInterrupt):
+        console.print("\n[yellow]Shell session ended[/yellow]")
+    except Exception as e:
+        console.print(f"[red]Shell error: {e}[/red]")

createsonline/cli/commands/users.py

@@ -0,0 +1,148 @@
+"""
+CREATESONLINE User Management Commands
+
+Create and manage users for the admin interface.
+Lazy imports are used to avoid hard dependencies when not needed.
+"""
+
+import logging
+
+_cli_logger = logging.getLogger("createsonline.cli.users")
+
+
+def createsuperuser_command():
+    """Create admin superuser interactively"""
+
+    # Import dependencies only when command is used
+    try:
+        import typer
+        from rich.console import Console
+        from rich.prompt import Prompt, Confirm
+        from rich.panel import Panel
+    except ImportError as e:
+        _cli_logger.error("This command requires additional dependencies. Install with: pip install rich typer")
+        # handled above
+        return
+
+    console = Console()
+
+    console.print(Panel(
+        "[bold blue]CREATESONLINE Admin User Creation[/bold blue]\n\n"
+        "[cyan]Create a superuser account for the admin interface.[/cyan]\n"
+        "[dim]This user will have full administrative privileges.[/dim]",
+        title="Create Superuser",
+        border_style="blue"
+    ))
+
+    # Get user information
+    try:
+        username = Prompt.ask("[cyan]Username[/cyan]", default="admin")
+        email = Prompt.ask("[cyan]Email address[/cyan]", default=f"{username}@example.com")
+        password = Prompt.ask("[cyan]Password[/cyan]", password=True)
+        password_confirm = Prompt.ask("[cyan]Confirm password[/cyan]", password=True)
+
+        if password != password_confirm:
+            console.print("[red]Passwords don't match![/red]")
+            raise typer.Exit(1)
+
+        # Confirm creation
+        console.print(f"\n[green]Creating superuser:[/green]")
+        console.print(f"  Username: [cyan]{username}[/cyan]")
+        console.print(f"  Email: [cyan]{email}[/cyan]")
+
+        if not Confirm.ask("\n[yellow]Create this superuser?[/yellow]"):
+            console.print("[yellow]Cancelled[/yellow]")
+            return
+
+        # Create the user
+        success = create_superuser(username, email, password, console)
+
+        if success:
+            console.print(Panel(
+                f"[bold green]✅ Superuser '{username}' created successfully![/bold green]\n\n"
+                "[cyan]You can now:[/cyan]\n"
+                "• Login to admin interface\n"
+                "• Manage users and permissions\n"
+                "• Configure application settings\n\n"
+                "[green]Admin URL:[/green] http://localhost:8000/admin/",
+                title="Success!",
+                border_style="green"
+            ))
+        else:
+            console.print("[red]Failed to create superuser[/red]")
+            raise typer.Exit(1)
+
+    except KeyboardInterrupt:
+        console.print("\n[yellow]Cancelled by user[/yellow]")
+    except Exception as e:
+        console.print(f"[red]Error creating superuser: {e}[/red]")
+        raise typer.Exit(1)
+
+
+def create_superuser(username: str, email: str, password: str, console=None) -> bool:
+    """Create a superuser in the database.
+
+    Returns True on success, False otherwise. Accepts optional `console`
+    for rich output; falls back to print when not provided.
+    """
+
+    try:
+        # Try to import and use the auth models
+        from createsonline.auth.models import User, Group, Permission, hash_password
+        from sqlalchemy import create_engine
+        from sqlalchemy.orm import sessionmaker
+        import os
+
+        # Get database URL from environment or use default
+        database_url = os.getenv("DATABASE_URL", "sqlite:///./app.db")
+
+        # Create database engine and session
+        engine = create_engine(database_url)
+
+        # Create tables if they don't exist
+        User.metadata.create_all(engine)
+
+        SessionLocal = sessionmaker(bind=engine)
+        session = SessionLocal()
+
+        try:
+            # Check if user already exists
+            existing_user = session.query(User).filter(User.username == username).first()
+            if existing_user:
+                (console.print(f"[yellow]User '{username}' already exists![/yellow]") if console else _cli_logger.info(f"User '{username}' already exists!"))
+                return False
+
+            # Hash the password
+            hashed_password = hash_password(password)
+
+            # Create the user
+            user = User(
+                username=username,
+                email=email,
+                password_hash=hashed_password,
+                is_active=True,
+                is_superuser=True,
+                is_staff=True
+            )
+
+            session.add(user)
+            session.commit()
+
+            (console.print(f"[green]User '{username}' created in database[/green]") if console else _cli_logger.info(f"User '{username}' created in database"))
+            return True
+
+        finally:
+            session.close()
+
+    except ImportError:
+        # Fallback to simple file-based storage for demo
+        _cli_logger.error("Database models not available. Configure your database and try again.")
+        return False
+    except Exception as e:
+        _cli_logger.error(f"Database error: {e}")
+        _cli_logger.info("User creation aborted due to configuration error.")
+        return False
+
+
+
+