nextpy-framework 1.0.0__py3-none-any.whl

nextpy/utils/file_upload.py

@@ -0,0 +1,65 @@
+"""
+NextPy File Upload Utilities
+Handle file uploads with validation and storage
+"""
+
+import os
+from pathlib import Path
+from typing import Optional
+from fastapi import UploadFile
+import shutil
+
+
+UPLOAD_DIR = Path("uploads")
+ALLOWED_EXTENSIONS = {".jpg", ".jpeg", ".png", ".gif", ".pdf", ".txt", ".doc", ".docx"}
+MAX_FILE_SIZE = 10 * 1024 * 1024  # 10MB
+
+
+async def upload_file(
+    file: UploadFile,
+    directory: str = "general",
+    max_size: int = MAX_FILE_SIZE,
+) -> Optional[str]:
+    """Upload file with validation"""
+    
+    # Validate extension
+    ext = Path(file.filename).suffix.lower()
+    if ext not in ALLOWED_EXTENSIONS:
+        raise ValueError(f"File type {ext} not allowed")
+    
+    # Create upload directory
+    upload_path = UPLOAD_DIR / directory
+    upload_path.mkdir(parents=True, exist_ok=True)
+    
+    # Save file
+    file_path = upload_path / file.filename
+    
+    try:
+        with open(file_path, "wb") as f:
+            content = await file.read()
+            if len(content) > max_size:
+                raise ValueError(f"File too large (max {max_size} bytes)")
+            f.write(content)
+        
+        return str(file_path)
+    except Exception as e:
+        if file_path.exists():
+            file_path.unlink()
+        raise e
+
+
+async def delete_file(file_path: str) -> bool:
+    """Delete uploaded file"""
+    try:
+        path = Path(file_path)
+        if path.exists():
+            path.unlink()
+            return True
+        return False
+    except Exception:
+        return False
+
+
+def get_upload_url(file_path: str) -> str:
+    """Get public URL for uploaded file"""
+    return f"/uploads/{file_path}"

nextpy/utils/logging.py

@@ -0,0 +1,52 @@
+"""
+NextPy Logging Utilities
+Structured logging for debugging and monitoring
+"""
+
+import logging
+from datetime import datetime
+from typing import Any
+
+
+class Logger:
+    """Simple logging wrapper"""
+    
+    def __init__(self, name: str):
+        self.logger = logging.getLogger(name)
+        
+        if not self.logger.handlers:
+            handler = logging.StreamHandler()
+            formatter = logging.Formatter(
+                '%(asctime)s - %(name)s - %(levelname)s - %(message)s'
+            )
+            handler.setFormatter(formatter)
+            self.logger.addHandler(handler)
+            self.logger.setLevel(logging.INFO)
+    
+    def info(self, message: str, **kwargs):
+        """Log info message"""
+        self.logger.info(f"{message} {self._format_kwargs(kwargs)}")
+    
+    def error(self, message: str, **kwargs):
+        """Log error message"""
+        self.logger.error(f"{message} {self._format_kwargs(kwargs)}")
+    
+    def debug(self, message: str, **kwargs):
+        """Log debug message"""
+        self.logger.debug(f"{message} {self._format_kwargs(kwargs)}")
+    
+    def warning(self, message: str, **kwargs):
+        """Log warning message"""
+        self.logger.warning(f"{message} {self._format_kwargs(kwargs)}")
+    
+    @staticmethod
+    def _format_kwargs(kwargs: dict) -> str:
+        """Format kwargs for logging"""
+        if not kwargs:
+            return ""
+        return " | " + " ".join(f"{k}={v}" for k, v in kwargs.items())
+
+
+def get_logger(name: str) -> Logger:
+    """Get logger instance"""
+    return Logger(name)

nextpy/utils/search.py

@@ -0,0 +1,59 @@
+"""
+NextPy Search Utilities
+Simple full-text search functionality
+"""
+
+from typing import List, Dict, Any
+import re
+
+
+def simple_search(query: str, items: List[Dict[str, Any]], fields: List[str]) -> List[Dict[str, Any]]:
+    """Simple full-text search across multiple fields"""
+    query_lower = query.lower()
+    results = []
+    
+    for item in items:
+        for field in fields:
+            if field in item:
+                value = str(item.get(field, "")).lower()
+                if query_lower in value:
+                    results.append(item)
+                    break
+    
+    return results
+
+
+def fuzzy_search(query: str, items: List[Dict[str, Any]], field: str) -> List[Dict[str, Any]]:
+    """Fuzzy search with scoring"""
+    def fuzzy_match(pattern: str, text: str) -> int:
+        """Calculate fuzzy match score"""
+        pattern = pattern.lower()
+        text = text.lower()
+        score = 0
+        j = 0
+        
+        for i, char in enumerate(pattern):
+            pos = text.find(char, j)
+            if pos == -1:
+                return 0
+            score += 1 / (pos - j + 1)
+            j = pos + 1
+        
+        return score
+    
+    results = []
+    for item in items:
+        text = str(item.get(field, ""))
+        score = fuzzy_match(query, text)
+        if score > 0:
+            results.append((item, score))
+    
+    # Sort by score descending
+    results.sort(key=lambda x: x[1], reverse=True)
+    return [item for item, score in results]
+
+
+def search_highlight(query: str, text: str) -> str:
+    """Highlight search terms in text"""
+    pattern = re.compile(re.escape(query), re.IGNORECASE)
+    return pattern.sub(f'<mark>{query}</mark>', text)

nextpy/utils/seo.py

@@ -0,0 +1,85 @@
+"""
+NextPy SEO Utilities
+Helpers for SEO optimization, structured data, sitemaps
+"""
+
+from typing import Dict, List, Any, Optional
+import json
+from datetime import datetime
+
+
+def create_article_schema(
+    title: str,
+    description: str,
+    image: str,
+    author: str,
+    date_published: datetime,
+    date_modified: Optional[datetime] = None,
+    url: str = ""
+) -> Dict[str, Any]:
+    """Create structured data for article"""
+    return {
+        "@context": "https://schema.org",
+        "@type": "Article",
+        "headline": title,
+        "description": description,
+        "image": image,
+        "author": {
+            "@type": "Person",
+            "name": author
+        },
+        "datePublished": date_published.isoformat(),
+        "dateModified": (date_modified or date_published).isoformat(),
+        "url": url
+    }
+
+
+def create_organization_schema(
+    name: str,
+    url: str,
+    logo: str,
+    contact_url: Optional[str] = None
+) -> Dict[str, Any]:
+    """Create structured data for organization"""
+    return {
+        "@context": "https://schema.org",
+        "@type": "Organization",
+        "name": name,
+        "url": url,
+        "logo": logo,
+        "contactPoint": {
+            "@type": "ContactPoint",
+            "contactType": "Customer Service",
+            "url": contact_url
+        } if contact_url else None
+    }
+
+
+def generate_sitemap(routes: List[Dict[str, Any]]) -> str:
+    """Generate XML sitemap from routes"""
+    sitemap = '<?xml version="1.0" encoding="UTF-8"?>\n'
+    sitemap += '<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">\n'
+    
+    for route in routes:
+        sitemap += "  <url>\n"
+        sitemap += f"    <loc>{route.get('url', '')}</loc>\n"
+        if route.get('lastmod'):
+            sitemap += f"    <lastmod>{route['lastmod']}</lastmod>\n"
+        if route.get('priority'):
+            sitemap += f"    <priority>{route['priority']}</priority>\n"
+        sitemap += "  </url>\n"
+    
+    sitemap += "</urlset>"
+    return sitemap
+
+
+def generate_robots_txt(sitemap_url: str) -> str:
+    """Generate robots.txt content"""
+    return f"""User-agent: *
+Allow: /
+Disallow: /admin/
+Disallow: /api/
+Disallow: /_nextpy/
+
+Sitemap: {sitemap_url}
+"""

nextpy/utils/validators.py

@@ -0,0 +1,58 @@
+"""
+NextPy Validation Utilities
+Type-safe validation helpers using Pydantic
+"""
+
+from pydantic import BaseModel, EmailStr, HttpUrl
+from typing import Optional, List, Dict, Any
+
+
+class ContactForm(BaseModel):
+    """Contact form validation"""
+    name: str
+    email: EmailStr
+    message: str
+    subject: Optional[str] = None
+
+
+class BlogPost(BaseModel):
+    """Blog post validation"""
+    title: str
+    slug: str
+    content: str
+    excerpt: Optional[str] = None
+    featured_image: Optional[HttpUrl] = None
+    author: str
+    tags: List[str] = []
+    published: bool = False
+
+
+class User(BaseModel):
+    """User profile validation"""
+    email: EmailStr
+    username: str
+    full_name: str
+    bio: Optional[str] = None
+    avatar_url: Optional[HttpUrl] = None
+
+
+class LoginForm(BaseModel):
+    """Login form validation"""
+    email: EmailStr
+    password: str
+    remember_me: bool = False
+
+
+class SignupForm(BaseModel):
+    """Signup form validation"""
+    email: EmailStr
+    username: str
+    password: str
+    confirm_password: str
+    agree_to_terms: bool = False
+
+
+def validate_slug(slug: str) -> bool:
+    """Validate URL-safe slug format"""
+    import re
+    return bool(re.match(r"^[a-z0-9]+(?:-[a-z0-9]+)*$", slug))

nextpy/websocket.py

@@ -0,0 +1,76 @@
+"""
+NextPy WebSocket Support
+Real-time communication with clients
+"""
+
+from fastapi import WebSocket
+from typing import Set, Dict, Callable, Any
+import json
+
+
+class ConnectionManager:
+    """Manage WebSocket connections"""
+    
+    def __init__(self):
+        self.active_connections: Set[WebSocket] = set()
+        self.subscribers: Dict[str, Set[WebSocket]] = {}
+    
+    async def connect(self, websocket: WebSocket):
+        """Accept new connection"""
+        await websocket.accept()
+        self.active_connections.add(websocket)
+    
+    async def disconnect(self, websocket: WebSocket):
+        """Remove connection"""
+        self.active_connections.discard(websocket)
+        for subs in self.subscribers.values():
+            subs.discard(websocket)
+    
+    async def broadcast(self, message: Dict[str, Any]):
+        """Send message to all connections"""
+        for connection in self.active_connections:
+            try:
+                await connection.send_json(message)
+            except:
+                pass
+    
+    async def subscribe(self, websocket: WebSocket, channel: str):
+        """Subscribe connection to channel"""
+        if channel not in self.subscribers:
+            self.subscribers[channel] = set()
+        self.subscribers[channel].add(websocket)
+    
+    async def publish(self, channel: str, message: Dict[str, Any]):
+        """Publish message to channel subscribers"""
+        if channel in self.subscribers:
+            for connection in self.subscribers[channel]:
+                try:
+                    await connection.send_json(message)
+                except:
+                    pass
+
+
+# Global manager instance
+manager = ConnectionManager()
+
+
+async def handle_websocket(websocket: WebSocket):
+    """Handle WebSocket connection"""
+    await manager.connect(websocket)
+    try:
+        while True:
+            data = await websocket.receive_text()
+            message = json.loads(data)
+            
+            # Route message to appropriate handler
+            msg_type = message.get("type")
+            if msg_type == "subscribe":
+                await manager.subscribe(websocket, message.get("channel"))
+            elif msg_type == "publish":
+                await manager.publish(message.get("channel"), message.get("payload"))
+            elif msg_type == "broadcast":
+                await manager.broadcast(message.get("payload"))
+    except:
+        pass
+    finally:
+        await manager.disconnect(websocket)