nextpy-framework 1.0.0__py3-none-any.whl

nextpy/core/router.py

@@ -0,0 +1,233 @@
+"""
+NextPy Router - File-based routing system inspired by Next.js
+Supports:
+- File-based routing (pages/index.py -> /)
+- Dynamic routes (pages/[slug].py -> /:slug)
+- Nested routes (pages/blog/[id].py -> /blog/:id)
+- Catch-all routes (pages/[...path].py -> /*)
+- API routes (pages/api/*.py)
+"""
+
+import os
+import re
+import importlib.util
+from pathlib import Path
+from typing import Dict, List, Optional, Callable, Any, Tuple
+from dataclasses import dataclass, field
+from pydantic import BaseModel
+
+
+class RouteParams(BaseModel):
+    """Type-safe route parameters"""
+    params: Dict[str, str] = {}
+    query: Dict[str, str] = {}
+
+
+@dataclass
+class Route:
+    """Represents a single route in the application"""
+    path: str
+    file_path: Path
+    handler: Optional[Callable] = None
+    is_dynamic: bool = False
+    is_api: bool = False
+    is_catch_all: bool = False
+    param_names: List[str] = field(default_factory=list)
+    pattern: Optional[re.Pattern] = None
+    
+    def matches(self, url_path: str) -> Optional[Dict[str, str]]:
+        """Check if this route matches the given URL path"""
+        if self.pattern:
+            match = self.pattern.match(url_path)
+            if match:
+                return match.groupdict()
+        elif self.path == url_path:
+            return {}
+        return None
+
+
+@dataclass  
+class DynamicRoute(Route):
+    """A route with dynamic segments like [slug] or [...path]"""
+    is_dynamic: bool = True
+
+
+class Router:
+    """
+    File-based router that scans the pages directory
+    and creates routes similar to Next.js
+    """
+    
+    def __init__(self, pages_dir: str = "pages", templates_dir: str = "templates"):
+        self.pages_dir = Path(pages_dir)
+        self.templates_dir = Path(templates_dir)
+        self.routes: List[Route] = []
+        self.api_routes: List[Route] = []
+        self._route_cache: Dict[str, Route] = {}
+        
+    def scan_pages(self) -> None:
+        """Scan the pages directory and register all routes"""
+        if not self.pages_dir.exists():
+            return
+            
+        for file_path in self.pages_dir.rglob("*.py"):
+            if file_path.name.startswith("_"):
+                continue
+                
+            route = self._create_route_from_file(file_path)
+            if route:
+                if route.is_api:
+                    self.api_routes.append(route)
+                else:
+                    self.routes.append(route)
+                    
+        self._sort_routes()
+        
+    def _create_route_from_file(self, file_path: Path) -> Optional[Route]:
+        """Create a Route object from a Python file"""
+        relative_path = file_path.relative_to(self.pages_dir)
+        parts = list(relative_path.parts)
+        
+        is_api = parts[0] == "api" if parts else False
+        
+        route_parts = []
+        param_names = []
+        is_dynamic = False
+        is_catch_all = False
+        
+        for part in parts:
+            if part.endswith(".py"):
+                part = part[:-3]
+                
+            if part == "index":
+                continue
+                
+            catch_all_match = re.match(r"\[\.\.\.(\w+)\]", part)
+            dynamic_match = re.match(r"\[(\w+)\]", part)
+            
+            if catch_all_match:
+                param_name = catch_all_match.group(1)
+                param_names.append(param_name)
+                route_parts.append(f"(?P<{param_name}>.+)")
+                is_dynamic = True
+                is_catch_all = True
+            elif dynamic_match:
+                param_name = dynamic_match.group(1)
+                param_names.append(param_name)
+                route_parts.append(f"(?P<{param_name}>[^/]+)")
+                is_dynamic = True
+            else:
+                route_parts.append(re.escape(part))
+                
+        if is_api and route_parts and route_parts[0] == "api":
+            route_parts = route_parts[1:]
+            
+        path = "/" + "/".join(route_parts) if route_parts else "/"
+        
+        if is_api:
+            path = "/api" + path if path != "/" else "/api"
+            
+        pattern = None
+        if is_dynamic:
+            pattern_str = "^" + path.replace("/", r"\/") + "$"
+            pattern_str = re.sub(r"\\\(\?P", "(?P", pattern_str)
+            pattern_str = pattern_str.replace(r"\[", "[").replace(r"\]", "]")
+            pattern_str = pattern_str.replace(r"\+", "+")
+            try:
+                pattern = re.compile(pattern_str)
+            except re.error:
+                pattern = re.compile("^" + path + "$")
+                
+        handler = self._load_handler(file_path)
+        
+        route_class = DynamicRoute if is_dynamic else Route
+        return route_class(
+            path=path,
+            file_path=file_path,
+            handler=handler,
+            is_dynamic=is_dynamic,
+            is_api=is_api,
+            is_catch_all=is_catch_all,
+            param_names=param_names,
+            pattern=pattern,
+        )
+        
+    def _load_handler(self, file_path: Path) -> Optional[Callable]:
+        """Dynamically load the handler function from a page file"""
+        try:
+            spec = importlib.util.spec_from_file_location(
+                file_path.stem, 
+                file_path
+            )
+            if spec and spec.loader:
+                module = importlib.util.module_from_spec(spec)
+                spec.loader.exec_module(module)
+                
+                for func_name in ["handler", "page", "get", "post", "default"]:
+                    if hasattr(module, func_name):
+                        return getattr(module, func_name)
+                        
+                if hasattr(module, "Page"):
+                    return module.Page
+                    
+        except Exception as e:
+            print(f"Error loading handler from {file_path}: {e}")
+            
+        return None
+        
+    def _sort_routes(self) -> None:
+        """Sort routes so static routes come before dynamic ones"""
+        def route_priority(route: Route) -> Tuple[int, int, str]:
+            if route.is_catch_all:
+                return (2, len(route.param_names), route.path)
+            elif route.is_dynamic:
+                return (1, len(route.param_names), route.path)
+            else:
+                return (0, 0, route.path)
+                
+        self.routes.sort(key=route_priority)
+        self.api_routes.sort(key=route_priority)
+        
+    def match(self, url_path: str) -> Optional[Tuple[Route, Dict[str, str]]]:
+        """Find a route that matches the given URL path"""
+        url_path = url_path.rstrip("/") or "/"
+        
+        if url_path in self._route_cache:
+            route = self._route_cache[url_path]
+            params = route.matches(url_path) or {}
+            return (route, params)
+            
+        routes = self.api_routes if url_path.startswith("/api") else self.routes
+        
+        for route in routes:
+            params = route.matches(url_path)
+            if params is not None:
+                if not route.is_dynamic:
+                    self._route_cache[url_path] = route
+                return (route, params)
+                
+        return None
+        
+    def get_all_routes(self) -> List[Route]:
+        """Get all registered routes"""
+        return self.routes + self.api_routes
+        
+    def get_static_routes(self) -> List[Route]:
+        """Get only static (non-dynamic) routes for SSG"""
+        return [r for r in self.routes if not r.is_dynamic]
+        
+    def reload_route(self, file_path: Path) -> None:
+        """Reload a specific route (for hot reload)"""
+        self.routes = [r for r in self.routes if r.file_path != file_path]
+        self.api_routes = [r for r in self.api_routes if r.file_path != file_path]
+        self._route_cache.clear()
+        
+        if file_path.exists():
+            route = self._create_route_from_file(file_path)
+            if route:
+                if route.is_api:
+                    self.api_routes.append(route)
+                else:
+                    self.routes.append(route)
+                    
+        self._sort_routes()

nextpy/core/sync.py

@@ -0,0 +1,34 @@
+"""
+NextPy Sync Support
+Allow pages to be written with sync functions instead of async
+"""
+
+import asyncio
+import inspect
+from typing import Callable, Any, Dict
+
+
+def sync_to_async(func: Callable) -> Callable:
+    """Convert sync function to async"""
+    if inspect.iscoroutinefunction(func):
+        return func
+    
+    async def wrapper(*args, **kwargs):
+        loop = asyncio.get_event_loop()
+        return await loop.run_in_executor(None, func, *args, **kwargs)
+    
+    return wrapper
+
+
+async def run_sync(func: Callable, *args, **kwargs) -> Any:
+    """Run sync function in async context"""
+    if inspect.iscoroutinefunction(func):
+        return await func(*args, **kwargs)
+    
+    loop = asyncio.get_event_loop()
+    return await loop.run_in_executor(None, func, *args, **kwargs)
+
+
+def supports_sync(func: Callable) -> bool:
+    """Check if function supports sync"""
+    return not inspect.iscoroutinefunction(func)

nextpy/db.py

@@ -0,0 +1,121 @@
+"""
+NextPy Database Layer
+Support for SQLite, PostgreSQL, MySQL with SQLAlchemy ORM
+"""
+
+import os
+from typing import Optional, Dict, Any
+from sqlalchemy import create_engine
+from sqlalchemy.orm import sessionmaker, Session
+from sqlalchemy.ext.declarative import declarative_base
+
+Base = declarative_base()
+
+
+class DatabaseConfig:
+    """Database configuration manager"""
+    
+    def __init__(self, database_url: Optional[str] = None):
+        self.database_url = database_url or os.getenv("DATABASE_URL", "sqlite:///./nextpy.db")
+        self.echo = os.getenv("DB_ECHO", "false").lower() == "true"
+        self.pool_size = int(os.getenv("DB_POOL_SIZE", "5"))
+        self.max_overflow = int(os.getenv("DB_MAX_OVERFLOW", "10"))
+        
+    def get_engine(self):
+        """Get SQLAlchemy engine"""
+        if self.database_url.startswith("sqlite"):
+            return create_engine(
+                self.database_url,
+                echo=self.echo,
+                connect_args={"check_same_thread": False}
+            )
+        else:
+            return create_engine(
+                self.database_url,
+                echo=self.echo,
+                pool_size=self.pool_size,
+                max_overflow=self.max_overflow,
+                pool_pre_ping=True
+            )
+
+
+class Database:
+    """Database manager with connection pooling"""
+    
+    def __init__(self, database_url: Optional[str] = None):
+        self.config = DatabaseConfig(database_url)
+        self.engine = self.config.get_engine()
+        self.SessionLocal = sessionmaker(bind=self.engine, expire_on_commit=False)
+        
+    def get_session(self) -> Session:
+        """Get database session"""
+        return self.SessionLocal()
+    
+    def create_tables(self):
+        """Create all tables"""
+        Base.metadata.create_all(self.engine)
+    
+    def drop_tables(self):
+        """Drop all tables (development only)"""
+        Base.metadata.drop_all(self.engine)
+    
+    def close(self):
+        """Close connection pool"""
+        self.engine.dispose()
+
+
+# Global database instance
+_db: Optional[Database] = None
+
+
+def init_db(database_url: Optional[str] = None) -> Database:
+    """Initialize global database instance"""
+    global _db
+    _db = Database(database_url)
+    _db.create_tables()
+    return _db
+
+
+def get_db() -> Database:
+    """Get global database instance"""
+    if _db is None:
+        raise RuntimeError("Database not initialized. Call init_db() first.")
+    return _db
+
+
+def get_session() -> Session:
+    """Get database session"""
+    return get_db().get_session()
+
+
+# Models example
+from sqlalchemy import Column, Integer, String, DateTime, Text, Boolean
+from datetime import datetime
+
+
+class User(Base):
+    """User model"""
+    __tablename__ = "users"
+    
+    id = Column(Integer, primary_key=True)
+    email = Column(String(255), unique=True, index=True)
+    username = Column(String(255), unique=True, index=True)
+    full_name = Column(String(255))
+    hashed_password = Column(String(255))
+    is_active = Column(Boolean, default=True)
+    created_at = Column(DateTime, default=datetime.utcnow)
+
+
+class Post(Base):
+    """Blog post model"""
+    __tablename__ = "posts"
+    
+    id = Column(Integer, primary_key=True)
+    title = Column(String(255), index=True)
+    slug = Column(String(255), unique=True, index=True)
+    content = Column(Text)
+    excerpt = Column(String(500))
+    author_id = Column(Integer, index=True)
+    published = Column(Boolean, default=False)
+    created_at = Column(DateTime, default=datetime.utcnow)
+    updated_at = Column(DateTime, default=datetime.utcnow, onupdate=datetime.utcnow)

nextpy/dev_server.py

@@ -0,0 +1,69 @@
+"""
+NextPy Enhanced Development Server with hot reload and optimization
+"""
+
+import asyncio
+from watchdog.observers import Observer
+from watchdog.events import FileSystemEventHandler
+from pathlib import Path
+from typing import Callable, List, Optional, Dict, Any
+
+
+class OptimizedDevServer(FileSystemEventHandler):
+    """Development server with file watching and hot reload"""
+    
+    def __init__(self, on_change: Callable[[str], None]):
+        self.on_change = on_change
+        self.debounce_timer: Optional[asyncio.Timer] = None
+        self.debounce_delay: float = 0.5  # seconds
+    
+    def on_modified(self, event: Any) -> None:
+        """Handle file modification"""
+        if event.is_directory:
+            return
+        
+        # Debounce rapid changes
+        if self.debounce_timer:
+            self.debounce_timer.cancel()
+        
+        self.debounce_timer = asyncio.Timer(
+            self.debounce_delay,
+            lambda: self.on_change(event.src_path)
+        )
+        self.debounce_timer.start()
+    
+    @staticmethod
+    def watch_directories(paths: List[Path], on_change: Callable[[str], None]) -> Observer:
+        """Watch multiple directories for changes"""
+        observer = Observer()
+        handler = OptimizedDevServer(on_change)
+        
+        for path in paths:
+            observer.schedule(handler, str(path), recursive=True)
+        
+        observer.start()
+        return observer
+
+
+class DevServerStats:
+    """Track development server statistics"""
+    
+    def __init__(self) -> None:
+        self.hot_reloads: int = 0
+        self.build_time: float = 0
+        self.files_changed: List[str] = []
+    
+    def record_reload(self, file_path: str, build_time: float) -> None:
+        """Record a hot reload event"""
+        self.hot_reloads += 1
+        self.build_time = build_time
+        self.files_changed.append(file_path)
+    
+    def get_stats(self) -> Dict[str, Any]:
+        """Get server statistics"""
+        return {
+            "hot_reloads": self.hot_reloads,
+            "last_build_time_ms": round(self.build_time * 1000, 2),
+            "files_changed": len(self.files_changed),
+            "recent_changes": self.files_changed[-5:]
+        }

nextpy/dev_tools.py

@@ -0,0 +1,157 @@
+"""
+NextPy Development Tools - Generators and scaffolding
+"""
+
+from pathlib import Path
+from typing import Optional, List, Tuple
+
+
+class PageGenerator:
+    """Generate page files from templates"""
+    
+    @staticmethod
+    def create_page(name: str, pages_dir: Path = Path("pages")) -> Tuple[Path, Path]:
+        """Generate a new page file"""
+        name_clean = name.replace("-", "_").lower()
+        page_file = pages_dir / f"{name_clean}.py"
+        
+        content = f'''"""
+{name} page
+"""
+
+def get_template():
+    return "{name_clean}.html"
+
+
+async def get_server_side_props(context):
+    return {{
+        "props": {{
+            "title": "{name}",
+            "description": "Page description"
+        }}
+    }}
+'''
+        
+        page_file.write_text(content)
+        
+        # Create template
+        template_file = Path("templates") / f"{name_clean}.html"
+        template_content = f'''{% extends "_base.html" %}
+
+{% block content %}
+<div class="max-w-6xl mx-auto py-12 px-4">
+    <h1 class="text-4xl font-bold mb-4">{{{{ title }}}}</h1>
+    <p class="text-gray-600 mb-8">{{{{ description }}}}</p>
+    
+    <!-- Your content here -->
+</div>
+{% endblock %}
+'''
+        template_file.write_text(template_content)
+        
+        return page_file, template_file
+
+
+class APIGenerator:
+    """Generate API route files"""
+    
+    @staticmethod
+    def create_api(name: str, methods: Optional[List[str]] = None, api_dir: Path = Path("pages/api")) -> Path:
+        """Generate API endpoint"""
+        if methods is None:
+            methods = ["GET"]
+        
+        name_clean = name.replace("-", "_").lower()
+        api_file = api_dir / f"{name_clean}.py"
+        
+        method_stubs: List[str] = []
+        for method in methods:
+            method_lower = method.lower()
+            if method == "GET":
+                method_stubs.append(f'''async def {method_lower}(request):
+    """GET /{name_clean}"""
+    return {{"data": "hello"}}
+''')
+            elif method == "POST":
+                method_stubs.append(f'''async def {method_lower}(request):
+    """POST /{name_clean}"""
+    data = await request.json()
+    return {{"created": data}}
+''')
+            elif method in ["PUT", "DELETE"]:
+                method_stubs.append(f'''async def {method_lower}(request):
+    """{method} /{name_clean}"""
+    return {{"{method_lower.lower()}_id": 1}}
+''')
+        
+        content = f'''"""
+{name} API endpoint
+"""
+
+{chr(10).join(method_stubs)}
+'''
+        
+        api_file.write_text(content)
+        return api_file
+
+
+class ComponentGenerator:
+    """Generate component files"""
+    
+    @staticmethod
+    def create_component(name: str, templates_dir: Path = Path("templates/components")) -> Path:
+        """Generate a new component"""
+        name_clean = name.replace("-", "_").lower()
+        component_file = templates_dir / f"{name_clean}.html"
+        
+        content = f'''{{%- macro {name_clean}(label, items=[], **kwargs) -}}
+<!-- {name} component -->
+<div class="component-{name_clean}">
+    <h3>{{{{ label }}}}</h3>
+    {{% for item in items %}}
+    <div class="item">{{{{ item }}}}</div>
+    {{% endfor %}}
+</div>
+{{%- endmacro %}}
+'''
+        
+        component_file.write_text(content)
+        return component_file
+
+
+class ModelGenerator:
+    """Generate database models"""
+    
+    @staticmethod
+    def create_model(name: str, fields: Optional[dict] = None, models_dir: Path = Path("models")) -> Path:
+        """Generate database model"""
+        if fields is None:
+            fields = {"id": "Integer, primary_key=True", "name": "String(255)"}
+        
+        models_dir.mkdir(exist_ok=True)
+        model_file = models_dir / f"{name.lower()}.py"
+        
+        field_stubs: List[str] = []
+        for field_name, field_type in fields.items():
+            field_stubs.append(f"    {field_name} = Column({field_type})")
+        
+        content = f'''"""
+{name} model
+"""
+
+from nextpy.db import Base
+from sqlalchemy import Column, String, Integer, DateTime, Text
+from datetime import datetime
+
+
+class {name}(Base):
+    """{{docstring}}"""
+    __tablename__ = "{name.lower()}s"
+    
+{chr(10).join(field_stubs)}
+    created_at = Column(DateTime, default=datetime.utcnow)
+    updated_at = Column(DateTime, default=datetime.utcnow, onupdate=datetime.utcnow)
+'''
+        
+        model_file.write_text(content)
+        return model_file

nextpy/errors.py

@@ -0,0 +1,70 @@
+"""
+NextPy Error Handling
+Custom exceptions and error utilities
+"""
+
+from typing import Optional, Dict, Any
+
+
+class NextPyException(Exception):
+    """Base NextPy exception"""
+    pass
+
+
+class RouteNotFound(NextPyException):
+    """Route not found"""
+    pass
+
+
+class TemplateNotFound(NextPyException):
+    """Template not found"""
+    pass
+
+
+class DatabaseError(NextPyException):
+    """Database connection error"""
+    pass
+
+
+class AuthenticationError(NextPyException):
+    """Authentication failed"""
+    pass
+
+
+class ValidationError(NextPyException):
+    """Validation failed"""
+    
+    def __init__(self, message: str, errors: Optional[Dict[str, str]] = None):
+        self.message = message
+        self.errors = errors or {}
+        super().__init__(message)
+
+
+class RateLimitError(NextPyException):
+    """Rate limit exceeded"""
+    pass
+
+
+def handle_error(error: Exception) -> Dict[str, Any]:
+    """Convert error to response dict"""
+    if isinstance(error, ValidationError):
+        return {
+            "error": error.message,
+            "details": error.errors,
+            "status": 400
+        }
+    elif isinstance(error, AuthenticationError):
+        return {
+            "error": str(error),
+            "status": 401
+        }
+    elif isinstance(error, RateLimitError):
+        return {
+            "error": str(error),
+            "status": 429
+        }
+    else:
+        return {
+            "error": str(error),
+            "status": 500
+        }