createsonline 0.1.26__py3-none-any.whl

createsonline/config/database.py

@@ -0,0 +1,179 @@
+# createsonline/config/database.py
+"""
+CREATESONLINE Database Configuration
+Wrapper around the database abstraction layer for configuration management.
+Supports SQLite, PostgreSQL, and MySQL database connections.
+
+The actual database connection is handled by createsonline.database.abstraction.Database
+"""
+import os
+from typing import Optional, Dict, Any
+from urllib.parse import urlparse
+
+
+class DatabaseConfig:
+    """Database configuration manager"""
+    
+    # Supported database engines
+    SUPPORTED_ENGINES = ['sqlite', 'postgresql', 'mysql', 'mariadb']
+    
+    @staticmethod
+    def get_database_url() -> str:
+        """
+        Get database URL from environment variable or config
+        
+        This integrates with createsonline.database.abstraction.Database which
+        uses the same DATABASE_URL environment variable.
+        
+        Environment variable priority:
+        1. DATABASE_URL - Complete database URL (used by Database class)
+        2. DATABASE_ENGINE - Type of database (sqlite, postgresql, mysql)
+        3. Uses SQLite as default
+        
+        Supported formats:
+        - sqlite:///./db.sqlite3
+        - postgresql://user:password@localhost:5432/dbname
+        - postgresql+psycopg2://user:password@localhost:5432/dbname
+        - mysql+pymysql://user:password@localhost:3306/dbname
+        - mysql://user:password@localhost:3306/dbname
+        
+        Returns:
+            Database URL string
+        """
+        # Check for complete DATABASE_URL first (same as Database.abstraction)
+        database_url = os.getenv('DATABASE_URL')
+        if database_url:
+            return database_url
+        
+        # Build from individual components
+        engine = os.getenv('DATABASE_ENGINE', 'sqlite').lower()
+        
+        if engine == 'sqlite':
+            db_path = os.getenv('DATABASE_PATH', './db.sqlite3')
+            return f'sqlite:///{db_path}'
+        
+        elif engine in ['postgresql', 'postgres']:
+            return DatabaseConfig._build_postgresql_url()
+        
+        elif engine in ['mysql', 'mariadb']:
+            return DatabaseConfig._build_mysql_url()
+        
+        else:
+            raise ValueError(f"Unsupported database engine: {engine}")
+    
+    @staticmethod
+    def _build_postgresql_url() -> str:
+        """Build PostgreSQL connection URL from environment variables"""
+        user = os.getenv('DB_USER', 'postgres')
+        password = os.getenv('DB_PASSWORD', 'postgres')
+        host = os.getenv('DB_HOST', 'localhost')
+        port = os.getenv('DB_PORT', '5432')
+        database = os.getenv('DB_NAME', 'createsonline')
+        
+        # Use psycopg2 driver (can be overridden)
+        driver = os.getenv('DB_DRIVER', 'psycopg2')
+        
+        if password:
+            return f'postgresql+{driver}://{user}:{password}@{host}:{port}/{database}'
+        else:
+            return f'postgresql+{driver}://{user}@{host}:{port}/{database}'
+    
+    @staticmethod
+    def _build_mysql_url() -> str:
+        """Build MySQL/MariaDB connection URL from environment variables"""
+        user = os.getenv('DB_USER', 'root')
+        password = os.getenv('DB_PASSWORD', '')
+        host = os.getenv('DB_HOST', 'localhost')
+        port = os.getenv('DB_PORT', '3306')
+        database = os.getenv('DB_NAME', 'createsonline')
+        
+        # Default to pymysql driver for compatibility
+        driver = os.getenv('DB_DRIVER', 'pymysql')
+        
+        if password:
+            return f'mysql+{driver}://{user}:{password}@{host}:{port}/{database}'
+        else:
+            return f'mysql+{driver}://{user}@{host}:{port}/{database}'
+    
+    @staticmethod
+    def get_connection_info() -> Dict[str, Any]:
+        """
+        Get parsed connection information
+        
+        Returns:
+            Dictionary with connection details
+        """
+        url = DatabaseConfig.get_database_url()
+        parsed = urlparse(url)
+        
+        return {
+            'engine': parsed.scheme.split('+')[0],
+            'driver': parsed.scheme.split('+')[1] if '+' in parsed.scheme else None,
+            'user': parsed.username,
+            'password': parsed.password,
+            'host': parsed.hostname,
+            'port': parsed.port,
+            'database': parsed.path.lstrip('/'),
+            'url': url
+        }
+    
+    @staticmethod
+    def validate_connection() -> bool:
+        """
+        Validate database connection without running full migrations
+        
+        Returns:
+            True if connection is valid, False otherwise
+        """
+        try:
+            from createsonline.database.abstraction import Database
+            db = Database.get_instance()
+            # Try to create a session and execute a simple query
+            with db.session() as session:
+                session.execute("SELECT 1")
+            return True
+        except Exception as e:
+            print(f"Database connection error: {e}")
+            return False
+    
+    @staticmethod
+    def get_environment_template() -> str:
+        """
+        Get template for .env file with database configuration examples
+        
+        Returns:
+            String with .env template
+        """
+        return """# CREATESONLINE Database Configuration
+
+# Option 1: Complete Database URL (uncomment and use one)
+# DATABASE_URL=sqlite:///./db.sqlite3
+# DATABASE_URL=postgresql://user:password@localhost:5432/createsonline
+# DATABASE_URL=mysql+pymysql://root:password@localhost:3306/createsonline
+
+# Option 2: Individual Components (used if DATABASE_URL not set)
+# Database Engine: sqlite, postgresql, mysql, mariadb
+DATABASE_ENGINE=sqlite
+
+# SQLite Configuration (used when DATABASE_ENGINE=sqlite)
+DATABASE_PATH=./db.sqlite3
+
+# PostgreSQL Configuration (used when DATABASE_ENGINE=postgresql)
+# DB_USER=postgres
+# DB_PASSWORD=your_password
+# DB_HOST=localhost
+# DB_PORT=5432
+# DB_NAME=createsonline
+# DB_DRIVER=psycopg2
+
+# MySQL/MariaDB Configuration (used when DATABASE_ENGINE=mysql)
+# DB_USER=root
+# DB_PASSWORD=your_password
+# DB_HOST=localhost
+# DB_PORT=3306
+# DB_NAME=createsonline
+# DB_DRIVER=pymysql
+"""
+
+
+__all__ = ['DatabaseConfig']

createsonline/config/docs.py

@@ -0,0 +1,384 @@
+"""
+CREATESONLINE API Documentation Generator
+
+Generates beautiful HTML API documentation from route definitions.
+"""
+import json
+from datetime import datetime
+import platform
+import sys
+from typing import Dict, Any
+
+
+class APIDocumentationGenerator:
+    """Generate HTML API documentation for CREATESONLINE applications"""
+    
+    def __init__(self, app):
+        self.app = app
+    
+    def generate_beautiful_api_docs(self):
+        """Generate beautiful HTML API documentation with dynamic backend data"""
+        spec = self._build_api_spec()
+        html_content = self._render_html_template(spec)
+        return self._create_html_response(html_content)
+    
+    def _build_api_spec(self) -> Dict[str, Any]:
+        """Build OpenAPI specification"""
+        return {
+            "openapi": "3.0.0",
+            "info": {
+                "title": self.app.title,
+                "description": self.app.description,
+                "version": self.app.version,
+                "x-framework": "CREATESONLINE",
+                "x-ai-enabled": len(self.app._ai_features) > 0,
+                "x-mode": "internal",
+                "x-timestamp": datetime.utcnow().isoformat(),
+                "x-python-version": f"{sys.version_info.major}.{sys.version_info.minor}.{sys.version_info.micro}",
+                "x-platform": platform.system(),
+                "x-architecture": platform.machine()
+            },
+            "servers": [
+                {
+                    "url": "/",
+                    "description": "CREATESONLINE Development Server",
+                    "variables": {
+                        "protocol": {"default": "http", "enum": ["http", "https"]},
+                        "host": {"default": "127.0.0.1:8000"}
+                    }
+                }
+            ],
+            "paths": self._generate_enhanced_api_paths(),
+            "components": {
+                "schemas": self._generate_api_schemas(),
+                "securitySchemes": {
+                    "ApiKeyAuth": {"type": "apiKey", "in": "header", "name": "X-API-Key"},
+                    "BearerAuth": {"type": "http", "scheme": "bearer"}
+                }
+            },
+            "x-system-info": {
+                "framework": "CREATESONLINE",
+                "mode": "AI-Native",
+                "features": self.app._ai_features,
+                "total_routes": len(self.app._internal_routes),
+                "ai_routes": len([r for r in self.app._internal_routes.keys() if 'ai' in r.lower()]),
+                "admin_routes": len([r for r in self.app._internal_routes.keys() if 'admin' in r.lower()]),
+                "startup_time": datetime.utcnow().isoformat(),
+                "health_status": "operational",
+                "debug_mode": self.app.debug
+            }
+        }
+    
+    def _generate_enhanced_api_paths(self) -> Dict[str, Any]:
+        """Generate OpenAPI paths from registered routes"""
+        paths = {}
+        for path in self.app._internal_routes.keys():
+            route_info = self.app._internal_routes[path]
+            method = route_info.get('method', 'GET').lower()
+            
+            if path not in paths:
+                paths[path] = {}
+            
+            paths[path][method] = {
+                "summary": self._get_route_description(path, method),
+                "tags": self._get_route_tags(path),
+                "parameters": self._get_route_parameters(path),
+                "responses": {
+                    "200": {
+                        "description": "Success",
+                        "content": {
+                            "application/json": {
+                                "example": self._get_example_response(path, method)
+                            }
+                        }
+                    }
+                },
+                "x-code-samples": self._generate_code_samples(path, method)
+            }
+        
+        return paths
+    
+    def _get_route_description(self, path: str, method: str) -> str:
+        """Get route description"""
+        if 'admin' in path:
+            return "Admin interface"
+        elif 'health' in path:
+            return "Health check endpoint"
+        elif 'framework' in path:
+            return "Framework information"
+        return f"{method.upper()} {path}"
+    
+    def _get_route_tags(self, path: str) -> list:
+        """Get route tags"""
+        tags = []
+        if 'admin' in path:
+            tags.append('Admin')
+        if 'ai' in path:
+            tags.append('AI')
+        if not tags:
+            tags.append('API')
+        return tags
+    
+    def _get_route_parameters(self, path: str) -> list:
+        """Extract path parameters"""
+        import re
+        params = []
+        pattern = r'\{([^}]+)\}'
+        for match in re.finditer(pattern, path):
+            param_name = match.group(1)
+            params.append({
+                "name": param_name,
+                "in": "path",
+                "required": True,
+                "schema": {"type": "string"},
+                "description": f"The {param_name} parameter"
+            })
+        return params
+    
+    def _get_example_response(self, path: str, method: str) -> Dict[str, Any]:
+        """Generate example response"""
+        return {
+            "status": "success",
+            "data": f"Response from {method.upper()} {path}",
+            "timestamp": datetime.utcnow().isoformat()
+        }
+    
+    def _generate_api_schemas(self) -> Dict[str, Any]:
+        """Generate OpenAPI schemas"""
+        return {
+            "Error": {
+                "type": "object",
+                "properties": {
+                    "status": {"type": "string"},
+                    "message": {"type": "string"},
+                    "code": {"type": "integer"}
+                }
+            },
+            "Success": {
+                "type": "object",
+                "properties": {
+                    "status": {"type": "string"},
+                    "data": {"type": "object"},
+                    "timestamp": {"type": "string"}
+                }
+            }
+        }
+    
+    def _generate_code_samples(self, path: str, method: str) -> list:
+        """Generate code samples for endpoint"""
+        base_url = "http://localhost:8000"
+        return [
+            {
+                "lang": "curl",
+                "source": f'curl -X {method.upper()} "{base_url}{path}" \\\n  -H "Accept: application/json"'
+            },
+            {
+                "lang": "javascript",
+                "source": f'fetch("{base_url}{path}", {{\n  method: "{method.upper()}",\n  headers: {{"Accept": "application/json"}}\n}})'
+            },
+            {
+                "lang": "python",
+                "source": f'import requests\nresponse = requests.{method.lower()}("{base_url}{path}")\nprint(response.json())'
+            }
+        ]
+    
+    def _render_html_template(self, spec: Dict[str, Any]) -> str:
+        """Render HTML documentation template"""
+        return f"""
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>{self.app.title} - API Documentation</title>
+    <style>
+        * {{ margin: 0; padding: 0; box-sizing: border-box; }}
+        
+        body {{
+            font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif;
+            background: linear-gradient(135deg, #000000 0%, #ffffff 100%);
+            color: #333;
+            min-height: 100vh;
+        }}
+        
+        .header {{
+            background: linear-gradient(135deg, #000000 0%, #1a1a1a 100%);
+            color: white;
+            padding: 4rem 2rem;
+            text-align: center;
+            border-bottom: 1px solid #333;
+        }}
+        
+        .header h1 {{
+            font-size: 2.5rem;
+            margin-bottom: 1rem;
+        }}
+        
+        .container {{
+            max-width: 1200px;
+            margin: 0 auto;
+            padding: 2rem;
+        }}
+        
+        .api-section {{
+            background: white;
+            border-radius: 8px;
+            padding: 2rem;
+            margin-bottom: 2rem;
+            box-shadow: 0 2px 8px rgba(0,0,0,0.1);
+            border: 1px solid #e5e5e5;
+        }}
+        
+        .section-title {{
+            font-size: 1.5rem;
+            margin-bottom: 1rem;
+            color: #000;
+            border-bottom: 2px solid #6366f1;
+            padding-bottom: 0.5rem;
+        }}
+        
+        .endpoint {{
+            border: 1px solid #e5e5e5;
+            border-radius: 6px;
+            padding: 1.5rem;
+            margin-bottom: 1rem;
+            background: #f9f9f9;
+        }}
+        
+        .endpoint-method {{
+            display: inline-block;
+            padding: 0.25rem 0.75rem;
+            border-radius: 4px;
+            font-weight: bold;
+            margin-right: 1rem;
+            font-size: 0.875rem;
+        }}
+        
+        .method-get {{ background: #10b981; color: white; }}
+        .method-post {{ background: #3b82f6; color: white; }}
+        .method-put {{ background: #f59e0b; color: white; }}
+        .method-delete {{ background: #ef4444; color: white; }}
+        
+        .endpoint-path {{
+            font-family: 'Monaco', 'Courier New', monospace;
+            font-weight: 600;
+            color: #333;
+        }}
+        
+        .code-block {{
+            background: #1e1e1e;
+            color: #d4d4d4;
+            padding: 1rem;
+            border-radius: 6px;
+            overflow-x: auto;
+            font-family: 'Monaco', monospace;
+            font-size: 0.875rem;
+            line-height: 1.5;
+            margin-top: 1rem;
+        }}
+        
+        .badge {{
+            display: inline-block;
+            padding: 0.25rem 0.75rem;
+            background: #6366f1;
+            color: white;
+            border-radius: 20px;
+            font-size: 0.75rem;
+            margin-right: 0.5rem;
+            margin-bottom: 0.5rem;
+        }}
+        
+        .system-info {{
+            display: grid;
+            grid-template-columns: repeat(auto-fit, minmax(200px, 1fr));
+            gap: 1rem;
+            margin-top: 2rem;
+        }}
+        
+        .info-card {{
+            background: linear-gradient(135deg, #6366f1, #4f46e5);
+            color: white;
+            padding: 1.5rem;
+            border-radius: 8px;
+            text-align: center;
+        }}
+        
+        .info-value {{
+            font-size: 2rem;
+            font-weight: bold;
+            margin-bottom: 0.5rem;
+        }}
+        
+        .info-label {{
+            font-size: 0.875rem;
+            opacity: 0.9;
+        }}
+    </style>
+</head>
+<body>
+    <div class="header">
+        <h1>{self.app.title}</h1>
+        <p>{self.app.description}</p>
+    </div>
+    
+    <div class="container">
+        <div class="api-section">
+            <h2 class="section-title">📊 System Information</h2>
+            <div class="system-info">
+                <div class="info-card">
+                    <div class="info-value">{spec['x-system-info']['total_routes']}</div>
+                    <div class="info-label">Total Endpoints</div>
+                </div>
+                <div class="info-card">
+                    <div class="info-value">{spec['x-system-info']['ai_routes']}</div>
+                    <div class="info-label">AI-Powered Routes</div>
+                </div>
+                <div class="info-card">
+                    <div class="info-value">v{self.app.version}</div>
+                    <div class="info-label">Version</div>
+                </div>
+                <div class="info-card">
+                    <div class="info-value">{sys.version_info.major}.{sys.version_info.minor}</div>
+                    <div class="info-label">Python</div>
+                </div>
+            </div>
+        </div>
+        
+        <div class="api-section">
+            <h2 class="section-title">🔌 API Endpoints</h2>
+            {self._render_endpoints_html(spec)}
+        </div>
+    </div>
+</body>
+</html>
+"""
+    
+    def _render_endpoints_html(self, spec: Dict[str, Any]) -> str:
+        """Render endpoints in HTML"""
+        html = ""
+        for path, methods in spec.get('paths', {}).items():
+            for method, details in methods.items():
+                if method.startswith('x-'):
+                    continue
+                method_class = f"method-{method.lower()}"
+                html += f"""
+        <div class="endpoint">
+            <div>
+                <span class="endpoint-method {method_class}">{method.upper()}</span>
+                <span class="endpoint-path">{path}</span>
+            </div>
+            <p>{details.get('summary', 'No description')}</p>
+            {f'<div class="code-block">curl -X {method.upper()} "{path}"</div>' if path else ''}
+        </div>
+        """
+        return html
+    
+    def _create_html_response(self, content: str):
+        """Create HTML response object"""
+        class HTMLResponse:
+            def __init__(self, content, status_code=200, headers=None):
+                self.content = content
+                self.status_code = status_code
+                self.headers = headers or {'content-type': 'text/html'}
+        
+        return HTMLResponse(content)