nextpy-framework 1.1.0__tar.gz

nextpy_framework-1.1.0/.nextpy_framework/nextpy/__init__.py

@@ -0,0 +1,52 @@
+"""
+NextPy - A Python web framework inspired by Next.js
+File-based routing, SSR, SSG, and more with FastAPI + Jinja2
+"""
+
+__version__ = "1.0.1"
+
+from nextpy.core.router import Router, Route, DynamicRoute
+from nextpy.core.renderer import Renderer
+from nextpy.core.data_fetching import (
+    get_server_side_props,
+    get_static_props,
+    get_static_paths,
+)
+from nextpy.components.head import Head
+from nextpy.components.link import Link
+from nextpy.server.app import create_app
+from nextpy.hooks import (
+    useState,
+    useEffect,
+    useContext,
+    useReducer,
+    useCallback,
+    useMemo,
+    useRef,
+    useGlobalState,
+    component,
+)
+
+__all__ = [
+    "Router",
+    "Route", 
+    "DynamicRoute",
+    "Renderer",
+    "get_server_side_props",
+    "get_static_props",
+    "get_static_paths",
+    "Head",
+    "Link",
+    "create_app",
+    "useState",
+    "useEffect",
+    "useContext",
+    "useReducer",
+    "useCallback",
+    "useMemo",
+    "useRef",
+    "useGlobalState",
+    "component",
+    "maintainers",
+    "main"
+]

nextpy_framework-1.1.0/.nextpy_framework/nextpy/auth.py

@@ -0,0 +1,94 @@
+"""
+NextPy Authentication - JWT and Session support
+"""
+
+import jwt
+from datetime import datetime, timedelta
+from typing import Optional, Dict, Any
+from functools import wraps
+from fastapi import HTTPException, Request
+from nextpy.config import settings
+
+
+class AuthManager:
+    """Handle JWT and session authentication"""
+    
+    @staticmethod
+    def create_token(user_id: int, expires_delta: Optional[timedelta] = None) -> str:
+        """Create JWT token"""
+        if expires_delta is None:
+            expires_delta = timedelta(hours=settings.jwt_expiration_hours)
+        
+        expire = datetime.utcnow() + expires_delta
+        payload = {"user_id": user_id, "exp": expire}
+        
+        return jwt.encode(payload, settings.jwt_secret, algorithm=settings.jwt_algorithm)
+    
+    @staticmethod
+    def verify_token(token: str) -> Optional[int]:
+        """Verify JWT token and return user_id"""
+        try:
+            payload = jwt.decode(token, settings.jwt_secret, algorithms=[settings.jwt_algorithm])
+            user_id = payload.get("user_id")
+            if user_id is None:
+                return None
+            return user_id
+        except jwt.ExpiredSignatureError:
+            raise HTTPException(status_code=401, detail="Token expired")
+        except jwt.InvalidTokenError:
+            raise HTTPException(status_code=401, detail="Invalid token")
+    
+    @staticmethod
+    def get_token_from_request(request: Request) -> Optional[str]:
+        """Extract token from Authorization header"""
+        auth_header = request.headers.get("Authorization", "")
+        if auth_header.startswith("Bearer "):
+            return auth_header[7:]
+        return None
+
+
+def require_auth(func):
+    """Decorator to require authentication"""
+    @wraps(func)
+    async def wrapper(request: Request, *args, **kwargs):
+        token = AuthManager.get_token_from_request(request)
+        if not token:
+            raise HTTPException(status_code=401, detail="Missing token")
+        
+        user_id = AuthManager.verify_token(token)
+        request.state.user_id = user_id
+        return await func(request, *args, **kwargs)
+    
+    return wrapper
+
+
+# Session storage (in-memory, use Redis for production)
+_sessions: Dict[str, Dict[str, Any]] = {}
+
+
+def create_session(user_id: int) -> str:
+    """Create session"""
+    import uuid
+    session_id = str(uuid.uuid4())
+    _sessions[session_id] = {
+        "user_id": user_id,
+        "created_at": datetime.utcnow(),
+        "expires_at": datetime.utcnow() + timedelta(hours=24)
+    }
+    return session_id
+
+
+def get_session(session_id: str) -> Optional[Dict[str, Any]]:
+    """Get session"""
+    session = _sessions.get(session_id)
+    if session and session["expires_at"] > datetime.utcnow():
+        return session
+    return None
+
+
+def delete_session(session_id: str) -> bool:
+    """Delete session"""
+    if session_id in _sessions:
+        del _sessions[session_id]
+        return True
+    return False

nextpy_framework-1.1.0/.nextpy_framework/nextpy/builder.py

@@ -0,0 +1,123 @@
+"""
+NextPy Build Optimizer - Fast builds with caching and parallel processing
+"""
+
+import asyncio
+from pathlib import Path
+from typing import List, Dict, Any, Optional
+import hashlib
+import json
+from datetime import datetime
+
+
+class BuildCache:
+    """Smart build caching to skip unchanged files"""
+    
+    def __init__(self, cache_dir: str = ".nextpy_cache"):
+        self.cache_dir = Path(cache_dir)
+        self.cache_dir.mkdir(exist_ok=True)
+        self.cache_file = self.cache_dir / "build_cache.json"
+        self.cache: Dict[str, str] = self._load_cache()
+    
+    def _load_cache(self) -> Dict[str, str]:
+        if self.cache_file.exists():
+            with open(self.cache_file) as f:
+                return json.load(f)
+        return {}
+    
+    def _save_cache(self) -> None:
+        with open(self.cache_file, "w") as f:
+            json.dump(self.cache, f)
+    
+    def get_hash(self, file_path: str) -> str:
+        """Get SHA256 hash of file"""
+        with open(file_path, "rb") as f:
+            return hashlib.sha256(f.read()).hexdigest()
+    
+    def is_changed(self, file_path: str) -> bool:
+        """Check if file has changed since last build"""
+        current_hash = self.get_hash(file_path)
+        cached_hash = self.cache.get(file_path)
+        
+        if cached_hash == current_hash:
+            return False
+        
+        self.cache[file_path] = current_hash
+        self._save_cache()
+        return True
+    
+    def clear(self) -> None:
+        """Clear cache"""
+        self.cache = {}
+        if self.cache_file.exists():
+            self.cache_file.unlink()
+
+
+class ParallelBuilder:
+    """Build with parallel processing for faster builds"""
+    
+    @staticmethod
+    async def build_pages(pages: List[Path], concurrency: int = 4) -> List[Dict[str, Any]]:
+        """Build multiple pages in parallel"""
+        results: List[Dict[str, Any]] = []
+        semaphore = asyncio.Semaphore(concurrency)
+        
+        async def build_page(page: Path) -> Dict[str, Any]:
+            async with semaphore:
+                return await ParallelBuilder._build_single_page(page)
+        
+        tasks = [build_page(page) for page in pages]
+        results = await asyncio.gather(*tasks)
+        return results
+    
+    @staticmethod
+    async def _build_single_page(page: Path) -> Dict[str, Any]:
+        """Build a single page"""
+        await asyncio.sleep(0.1)  # Simulate build work
+        return {
+            "page": str(page),
+            "status": "built",
+            "timestamp": datetime.now().isoformat()
+        }
+
+
+class BuildOptimizer:
+    """Optimize bundle size and build time"""
+    
+    @staticmethod
+    def analyze_bundle(output_dir: Path) -> Dict[str, Any]:
+        """Analyze built bundle size"""
+        total_size: int = 0
+        files: Dict[str, int] = {}
+        
+        for file in output_dir.rglob("*"):
+            if file.is_file():
+                size = file.stat().st_size
+                total_size += size
+                files[str(file.relative_to(output_dir))] = size
+        
+        # Sort by size
+        sorted_files = sorted(files.items(), key=lambda x: x[1], reverse=True)
+        
+        return {
+            "total_size": total_size,
+            "total_size_mb": round(total_size / 1024 / 1024, 2),
+            "files": dict(sorted_files[:10]),  # Top 10 largest
+            "file_count": len(files)
+        }
+    
+    @staticmethod
+    def compress_assets(output_dir: Path) -> int:
+        """Compress CSS and JS files"""
+        import gzip
+        compressed_count: int = 0
+        
+        for file in list(output_dir.rglob("*.js")) + list(output_dir.rglob("*.css")):
+            if file.is_file():
+                with open(file, "rb") as f_in:
+                    content = f_in.read()
+                with gzip.open(f"{file}.gz", "wb") as f_out:
+                    f_out.write(content)
+                compressed_count += 1
+        
+        return compressed_count