createsonline 0.1.26__py3-none-any.whl

createsonline/static/test_script.js

@@ -0,0 +1,15 @@
+console.log('🚀 CREATESONLINE v0.1.4 - Dynamic routing active!');
+
+// Display feature announcement
+setTimeout(() => {
+    const features = [
+        '✅ Automatic static file serving',
+        '✅ No manual route configuration',
+        '✅ Smart MIME type detection', 
+        '✅ Built-in file caching',
+        '✅ Security: Path traversal protection'
+    ];
+    
+    console.log('\n🎯 Dynamic Static File Routing Features:');
+    features.forEach(feature => console.log(`  ${feature}`));
+}, 100);

createsonline/static/test_styles.css

@@ -0,0 +1,59 @@
+body {
+    font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, "Helvetica Neue", Arial, sans-serif;
+    max-width: 800px;
+    margin: 50px auto;
+    padding: 20px;
+    background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
+    color: #fff;
+}
+
+.container {
+    background: rgba(255, 255, 255, 0.1);
+    backdrop-filter: blur(10px);
+    border-radius: 20px;
+    padding: 40px;
+    box-shadow: 0 8px 32px rgba(0, 0, 0, 0.1);
+}
+
+h1 {
+    font-size: 2.5em;
+    margin-bottom: 20px;
+    text-align: center;
+}
+
+h2 {
+    color: #ffd700;
+    margin-top: 0;
+}
+
+.feature-box {
+    background: rgba(255, 255, 255, 0.05);
+    border-left: 4px solid #ffd700;
+    padding: 20px;
+    margin-top: 30px;
+    border-radius: 10px;
+}
+
+ul {
+    list-style: none;
+    padding-left: 0;
+}
+
+li {
+    padding: 8px 0;
+    padding-left: 30px;
+    position: relative;
+}
+
+li::before {
+    content: "âœ"";
+    position: absolute;
+    left: 0;
+    color: #4ade80;
+    font-weight: bold;
+}
+
+p {
+    font-size: 1.2em;
+    line-height: 1.6;
+}

createsonline/static_files.py

@@ -0,0 +1,365 @@
+# createsonline/static_files.py
+"""
+CREATESONLINE Dynamic Static File Serving System
+
+Automatically serves HTML, CSS, JS, and other static files
+with intelligent MIME type detection and caching.
+"""
+
+import os
+import mimetypes
+from pathlib import Path
+from typing import Dict, Optional, Tuple
+import logging
+
+logger = logging.getLogger("createsonline.static")
+
+# Initialize mimetypes
+mimetypes.init()
+
+# Additional MIME types for modern web
+CUSTOM_MIME_TYPES = {
+    '.html': 'text/html',
+    '.htm': 'text/html',
+    '.css': 'text/css',
+    '.js': 'application/javascript',
+    '.json': 'application/json',
+    '.xml': 'application/xml',
+    '.svg': 'image/svg+xml',
+    '.woff': 'font/woff',
+    '.woff2': 'font/woff2',
+    '.ttf': 'font/ttf',
+    '.eot': 'application/vnd.ms-fontobject',
+    '.png': 'image/png',
+    '.jpg': 'image/jpeg',
+    '.jpeg': 'image/jpeg',
+    '.gif': 'image/gif',
+    '.ico': 'image/x-icon',
+    '.webp': 'image/webp',
+    '.mp4': 'video/mp4',
+    '.webm': 'video/webm',
+    '.mp3': 'audio/mpeg',
+    '.wav': 'audio/wav',
+    '.pdf': 'application/pdf',
+    '.zip': 'application/zip',
+    '.txt': 'text/plain',
+    '.md': 'text/markdown',
+}
+
+
+class StaticFileHandler:
+    """
+    Dynamic static file serving with intelligent routing
+    """
+    
+    def __init__(self, static_dirs: list = None, template_dirs: list = None):
+        """
+        Initialize static file handler
+        
+        Args:
+            static_dirs: List of directories to serve static files from
+            template_dirs: List of directories to serve templates/HTML from
+        """
+        self._static_dirs = static_dirs
+        self._template_dirs = template_dirs
+        
+        # Cache for file existence checks
+        self._file_cache = {}
+        
+        logger.info("Static file handler initialized")
+    
+    @property
+    def static_dirs(self):
+        """Lazily evaluate static directories using Django-style settings"""
+        if self._static_dirs is not None:
+            return self._static_dirs
+        
+        # Import settings here to avoid circular imports
+        from .config.settings import settings
+        
+        # Use STATICFILES_DIRS from settings (Django-style)
+        staticfiles_dirs = settings.STATICFILES_DIRS
+        
+        if staticfiles_dirs:
+            # Add subdirectories for better organization
+            dirs = []
+            for base_dir in staticfiles_dirs:
+                dirs.append(base_dir)
+                # Also add common subdirectories
+                for subdir in ['css', 'js', 'images', 'img', 'icons']:
+                    sub_path = base_dir / subdir
+                    if sub_path.exists():
+                        dirs.append(sub_path)
+            return dirs
+        
+        # Fallback to current directory (backward compatibility)
+        cwd = Path.cwd()
+        dirs = [
+            cwd / "static",
+            cwd / "static" / "css",
+            cwd / "static" / "js",
+            cwd / "static" / "images",
+            cwd / "static" / "icons",
+        ]
+        return dirs
+    
+    @property
+    def template_dirs(self):
+        """Lazily evaluate template directories using Django-style settings"""
+        if self._template_dirs is not None:
+            return self._template_dirs
+        
+        # Import settings here to avoid circular imports
+        from .config.settings import settings
+        
+        # Use TEMPLATE_DIRS from settings
+        template_dirs = settings.TEMPLATE_DIRS
+        
+        if template_dirs:
+            return template_dirs
+        
+        # Fallback
+        cwd = Path.cwd()
+        return [cwd / "templates"]
+    
+    def get_mime_type(self, file_path: str) -> str:
+        """
+        Get MIME type for a file with fallback support
+        
+        Args:
+            file_path: Path to the file
+            
+        Returns:
+            MIME type string
+        """
+        ext = os.path.splitext(file_path)[1].lower()
+        
+        # Check custom types first
+        if ext in CUSTOM_MIME_TYPES:
+            return CUSTOM_MIME_TYPES[ext]
+        
+        # Fall back to system mimetypes
+        mime_type, _ = mimetypes.guess_type(file_path)
+        
+        # Default to octet-stream if unknown
+        return mime_type or 'application/octet-stream'
+    
+    def find_file(self, relative_path: str) -> Optional[Path]:
+        """
+        Find a file in static or template directories
+        
+        Args:
+            relative_path: Relative path to the file
+            
+        Returns:
+            Absolute Path object if found, None otherwise
+        """
+        # Check cache first
+        if relative_path in self._file_cache:
+            cached_path = self._file_cache[relative_path]
+            if cached_path and cached_path.exists():
+                return cached_path
+        
+        # Remove leading slash if present
+        relative_path = relative_path.lstrip('/')
+        
+        # Strip /static/ prefix if present (URLs come as /static/css/file.css)
+        # but we want to search in static_dirs which already points to static/
+        search_path = relative_path
+        if search_path.startswith('static/'):
+            search_path = search_path[7:]  # Remove 'static/' prefix
+            logger.debug(f"Stripped 'static/' prefix: '{relative_path}' -> '{search_path}'")
+        
+        # PRIORITY 1: Check project root for root-level static files
+        # (favicon.svg, logo.png, site.webmanifest, robots.txt, etc.)
+        project_root = Path.cwd()
+        root_file = project_root / search_path
+        if root_file.exists() and root_file.is_file():
+            # Security check: ensure it's a known static file type
+            static_extensions = {'.svg', '.ico', '.png', '.jpg', '.jpeg', '.gif', 
+                               '.webp', '.webmanifest', '.json', '.txt', '.xml'}
+            if root_file.suffix.lower() in static_extensions:
+                self._file_cache[relative_path] = root_file
+                logger.debug(f"Found root-level file: {root_file}")
+                return root_file
+        
+        # PRIORITY 2: Check static directories
+        for static_dir in self.static_dirs:
+            file_path = Path(static_dir) / search_path
+            logger.debug(f"Checking: {file_path} (exists={file_path.exists()})")
+            if file_path.exists() and file_path.is_file():
+                self._file_cache[relative_path] = file_path
+                logger.debug(f"Found file: {file_path}")
+                return file_path
+        
+        # PRIORITY 3: Check template directories
+        for template_dir in self.template_dirs:
+            file_path = Path(template_dir) / search_path
+            if file_path.exists() and file_path.is_file():
+                self._file_cache[relative_path] = file_path
+                return file_path
+        
+        # Cache miss
+        self._file_cache[relative_path] = None
+        return None
+    
+    def serve_file(self, relative_path: str) -> Tuple[bytes, int, Dict[str, str]]:
+        """
+        Serve a static file
+        
+        Args:
+            relative_path: Relative path to the file
+            
+        Returns:
+            Tuple of (content, status_code, headers)
+        """
+        file_path = self.find_file(relative_path)
+        
+        if not file_path:
+            error_content = f"File not found: {relative_path}".encode()
+            return error_content, 404, {'Content-Type': 'text/plain'}
+        
+        try:
+            # Security check - ensure file is within allowed directories
+            resolved_path = file_path.resolve()
+            allowed = False
+            
+            # Allow project root for root-level static files
+            project_root = Path.cwd().resolve()
+            if str(resolved_path).startswith(str(project_root)):
+                # Check if it's a known static file type
+                static_extensions = {'.svg', '.ico', '.png', '.jpg', '.jpeg', '.gif', 
+                                   '.webp', '.webmanifest', '.json', '.txt', '.xml',
+                                   '.css', '.js', '.woff', '.woff2', '.ttf'}
+                if resolved_path.suffix.lower() in static_extensions:
+                    allowed = True
+            
+            # Also check configured static/template directories
+            if not allowed:
+                for static_dir in self.static_dirs + self.template_dirs:
+                    if str(resolved_path).startswith(str(Path(static_dir).resolve())):
+                        allowed = True
+                        break
+            
+            if not allowed:
+                error_content = b"Access denied"
+                return error_content, 403, {'Content-Type': 'text/plain'}
+            
+            # Read file content
+            with open(file_path, 'rb') as f:
+                content = f.read()
+            
+            # Get MIME type
+            mime_type = self.get_mime_type(str(file_path))
+            
+            # Prepare headers
+            headers = {
+                'Content-Type': mime_type,
+                'Content-Length': str(len(content)),
+                'Cache-Control': 'public, max-age=3600',  # Cache for 1 hour
+            }
+            
+            # Add additional headers for specific file types
+            if mime_type.startswith('text/'):
+                headers['Content-Type'] = f"{mime_type}; charset=utf-8"
+            
+            logger.debug(f"Serving file: {relative_path} ({mime_type}, {len(content)} bytes)")
+            
+            return content, 200, headers
+            
+        except Exception as e:
+            logger.error(f"Error serving file {relative_path}: {e}")
+            error_content = f"Error reading file: {str(e)}".encode()
+            return error_content, 500, {'Content-Type': 'text/plain'}
+    
+    def list_files(self, directory: str = "") -> Dict[str, list]:
+        """
+        List all files in static directories (for debugging)
+        
+        Args:
+            directory: Subdirectory to list (empty for all)
+            
+        Returns:
+            Dictionary with file listings
+        """
+        files = {
+            'static': [],
+            'templates': []
+        }
+        
+        # List static files
+        for static_dir in self.static_dirs:
+            base_dir = Path(static_dir) / directory
+            if base_dir.exists():
+                for file_path in base_dir.rglob('*'):
+                    if file_path.is_file():
+                        rel_path = file_path.relative_to(static_dir)
+                        files['static'].append(str(rel_path))
+        
+        # List template files
+        for template_dir in self.template_dirs:
+            base_dir = Path(template_dir) / directory
+            if base_dir.exists():
+                for file_path in base_dir.rglob('*'):
+                    if file_path.is_file():
+                        rel_path = file_path.relative_to(template_dir)
+                        files['templates'].append(str(rel_path))
+        
+        return files
+
+
+# Global static file handler instance
+static_handler = StaticFileHandler()
+
+
+def configure_static_handler(static_dirs: list = None, template_dirs: list = None):
+    """
+    Manually configure the global static handler (optional).
+    
+    By default, the handler auto-discovers directories using Django-style settings.
+    Only use this if you need to override the auto-discovery.
+    
+    Args:
+        static_dirs: List of static file directories
+        template_dirs: List of template directories
+    """
+    global static_handler
+    
+    if static_dirs:
+        print(f"[DEBUG] Manually configuring static_handler with: {[str(d) for d in static_dirs]}")
+        static_handler._static_dirs = static_dirs
+    
+    if template_dirs:
+        static_handler._template_dirs = template_dirs
+    
+    static_handler._file_cache = {}  # Clear cache
+
+
+def serve_static(path: str) -> Tuple[bytes, int, Dict[str, str]]:
+    """
+    Convenience function to serve static files
+    
+    Args:
+        path: Path to the file
+        
+    Returns:
+        Tuple of (content, status_code, headers)
+    """
+    return static_handler.serve_file(path)
+
+
+def serve_template(path: str) -> Tuple[bytes, int, Dict[str, str]]:
+    """
+    Convenience function to serve HTML templates
+    
+    Args:
+        path: Path to the template
+        
+    Returns:
+        Tuple of (content, status_code, headers)
+    """
+    # Ensure .html extension
+    if not path.endswith('.html'):
+        path = f"{path}.html"
+    
+    return static_handler.serve_file(path)

createsonline/templates/404.html

@@ -0,0 +1,100 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>404 - Page Not Found</title>
+    
+    <link rel="icon" type="image/svg+xml" href="/favicon.svg">
+    <link rel="icon" type="image/x-icon" href="/favicon.ico">
+    
+    <style>
+        * {
+            margin: 0;
+            padding: 0;
+            box-sizing: border-box;
+        }
+        
+        body {
+            font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, 'Helvetica Neue', sans-serif;
+            background: #0a0a0a;
+            color: #ffffff;
+            min-height: 100vh;
+            display: flex;
+            align-items: center;
+            justify-content: center;
+            padding: 20px;
+        }
+        
+        .container {
+            max-width: 600px;
+            width: 100%;
+            text-align: center;
+            background: #1a1a1a;
+            padding: 60px 40px;
+            border-radius: 16px;
+            border: 1px solid #2a2a2a;
+        }
+        
+        .error-code {
+            font-size: 8em;
+            font-weight: 700;
+            background: linear-gradient(135deg, #ffffff 0%, #666666 100%);
+            -webkit-background-clip: text;
+            -webkit-text-fill-color: transparent;
+            background-clip: text;
+            margin-bottom: 20px;
+            line-height: 1;
+        }
+        
+        h1 {
+            font-size: 2em;
+            margin-bottom: 15px;
+            color: #ffffff;
+        }
+        
+        p {
+            color: #999999;
+            font-size: 1.1em;
+            margin-bottom: 40px;
+            line-height: 1.6;
+        }
+        
+        .btn {
+            display: inline-block;
+            padding: 15px 35px;
+            background: #ffffff;
+            color: #000000;
+            text-decoration: none;
+            border-radius: 8px;
+            font-weight: 600;
+            transition: all 0.3s ease;
+        }
+        
+        .btn:hover {
+            background: #f0f0f0;
+            transform: translateY(-2px);
+            box-shadow: 0 10px 25px rgba(255, 255, 255, 0.2);
+        }
+        
+        @media (max-width: 600px) {
+            .error-code {
+                font-size: 5em;
+            }
+            h1 {
+                font-size: 1.5em;
+            }
+        }
+    </style>
+</head>
+<body>
+    <div class="container">
+        <div class="error-code">404</div>
+        <h1>Page Not Found</h1>
+        <p>
+            The page you're looking for doesn't exist or has been moved.
+        </p>
+        <a href="/" class="btn">Go Home</a>
+    </div>
+</body>
+</html>

createsonline/templates/admin_login.html

@@ -0,0 +1,169 @@
+{% extends "base.html" %}
+
+{% block title %}Admin Login - CREATESONLINE{% endblock %}
+
+{% block extra_style %}
+h1 {
+    font-size: 2em;
+    color: #000000;
+    margin-bottom: 10px;
+    text-align: center;
+    font-weight: 300;
+    letter-spacing: -0.5px;
+}
+
+h1::after {
+    content: '';
+    display: block;
+    width: 40px;
+    height: 2px;
+    background: #000000;
+    margin: 15px auto 0;
+}
+
+.subtitle {
+    text-align: center;
+    color: #666666;
+    font-size: 0.95em;
+    margin-bottom: 45px;
+    font-weight: 300;
+    line-height: 1.6;
+}
+
+.form-group {
+    margin-bottom: 30px;
+    position: relative;
+}
+
+label {
+    display: block;
+    color: #000000;
+    font-size: 0.85em;
+    margin-bottom: 10px;
+    font-weight: 600;
+    text-transform: uppercase;
+    letter-spacing: 1px;
+}
+
+input[type="text"],
+input[type="password"] {
+    width: 100%;
+    padding: 15px 18px;
+    border: 2px solid #e0e0e0;
+    background: #ffffff;
+    font-size: 1em;
+    transition: all 0.3s cubic-bezier(0.16, 1, 0.3, 1);
+    font-family: inherit;
+    color: #000000;
+}
+
+input[type="text"]:focus,
+input[type="password"]:focus {
+    outline: none;
+    background: #fafafa;
+    border-color: #000000;
+    transform: translateY(-2px);
+    box-shadow: 0 4px 12px rgba(0, 0, 0, 0.1);
+}
+
+button {
+    width: 100%;
+    padding: 18px;
+    background: #000000;
+    color: white;
+    border: 2px solid #000000;
+    font-size: 1em;
+    font-weight: 600;
+    cursor: pointer;
+    transition: all 0.3s cubic-bezier(0.16, 1, 0.3, 1);
+    text-transform: uppercase;
+    letter-spacing: 1.5px;
+    font-family: inherit;
+    margin-top: 10px;
+    position: relative;
+    overflow: hidden;
+}
+
+button::before {
+    content: '';
+    position: absolute;
+    top: 0;
+    left: -100%;
+    width: 100%;
+    height: 100%;
+    background: linear-gradient(90deg, transparent, rgba(255, 255, 255, 0.2), transparent);
+    transition: left 0.5s;
+}
+
+button:hover::before {
+    left: 100%;
+}
+
+button:hover {
+    background: #ffffff;
+    color: #000000;
+    transform: translateY(-2px);
+    box-shadow: 0 8px 20px rgba(0, 0, 0, 0.2);
+}
+
+button:active {
+    transform: translateY(0);
+}
+
+.back-link {
+    text-align: center;
+    margin-top: 35px;
+    padding-top: 30px;
+    border-top: 1px solid #e0e0e0;
+}
+
+.back-link a {
+    color: #666666;
+    text-decoration: none;
+    font-size: 0.9em;
+    transition: all 0.3s ease;
+    font-weight: 300;
+}
+
+.back-link a:hover {
+    color: #000000;
+}
+
+.container {
+    max-width: 480px;
+    padding: 60px 50px;
+}
+
+@media (max-width: 480px) {
+    .container {
+        padding: 40px 30px;
+    }
+    
+    h1 {
+        font-size: 1.6em;
+    }
+}
+{% endblock %}
+
+{% block content %}
+<h1>Admin Login</h1>
+<p class="subtitle">Enter your credentials to access the admin panel</p>
+
+<form method="POST" action="/admin/login">
+    <div class="form-group">
+        <label for="username">Username</label>
+        <input type="text" id="username" name="username" required>
+    </div>
+    
+    <div class="form-group">
+        <label for="password">Password</label>
+        <input type="password" id="password" name="password" required>
+    </div>
+    
+    <button type="submit">Sign In</button>
+</form>
+
+<div class="back-link">
+    <a href="/">Back to Home</a>
+</div>
+{% endblock %}