nextpy-framework 1.0.0__py3-none-any.whl

nextpy/core/builder.py

@@ -0,0 +1,237 @@
+"""
+NextPy Builder - Static Site Generation (SSG)
+Builds static HTML files to the out/ directory
+"""
+
+import os
+import shutil
+import asyncio
+from pathlib import Path
+from typing import Any, Dict, List, Optional
+from datetime import datetime
+
+from nextpy.core.router import Router, Route
+from nextpy.core.renderer import Renderer
+from nextpy.core.data_fetching import (
+    PageContext,
+    PropsResult,
+    execute_data_fetching,
+    get_static_paths_for_route,
+)
+
+
+class Builder:
+    """
+    Static Site Generator for NextPy
+    Builds all pages to static HTML in the out/ directory
+    """
+    
+    def __init__(
+        self,
+        pages_dir: str = "pages",
+        templates_dir: str = "templates",
+        public_dir: str = "public",
+        out_dir: str = "out",
+    ):
+        self.pages_dir = Path(pages_dir)
+        self.templates_dir = Path(templates_dir)
+        self.public_dir = Path(public_dir)
+        self.out_dir = Path(out_dir)
+        
+        self.router = Router(pages_dir, templates_dir)
+        self.renderer = Renderer(templates_dir, pages_dir, public_dir)
+        
+        self.build_manifest: Dict[str, Any] = {
+            "version": 1,
+            "pages": {},
+            "build_time": None,
+        }
+        
+    async def build(self, clean: bool = True) -> Dict[str, Any]:
+        """
+        Build all pages to static HTML
+        
+        Args:
+            clean: Whether to clean the output directory first
+            
+        Returns:
+            Build manifest with information about built pages
+        """
+        print("NextPy Build Starting...")
+        start_time = datetime.now()
+        
+        if clean and self.out_dir.exists():
+            shutil.rmtree(self.out_dir)
+            
+        self.out_dir.mkdir(parents=True, exist_ok=True)
+        
+        self._copy_public_files()
+        
+        self.router.scan_pages()
+        
+        await self._build_static_routes()
+        
+        await self._build_dynamic_routes()
+        
+        self._create_sitemap()
+        
+        self.build_manifest["build_time"] = datetime.now().isoformat()
+        self._write_manifest()
+        
+        duration = (datetime.now() - start_time).total_seconds()
+        print(f"\nBuild completed in {duration:.2f}s")
+        print(f"Output directory: {self.out_dir}")
+        
+        return self.build_manifest
+        
+    def _copy_public_files(self) -> None:
+        """Copy files from public/ to out/"""
+        if not self.public_dir.exists():
+            return
+            
+        for item in self.public_dir.rglob("*"):
+            if item.is_file():
+                relative = item.relative_to(self.public_dir)
+                dest = self.out_dir / relative
+                dest.parent.mkdir(parents=True, exist_ok=True)
+                shutil.copy2(item, dest)
+                
+        print(f"Copied public files to {self.out_dir}")
+        
+    async def _build_static_routes(self) -> None:
+        """Build all static (non-dynamic) routes"""
+        static_routes = self.router.get_static_routes()
+        
+        for route in static_routes:
+            if route.is_api:
+                continue
+                
+            await self._build_page(route)
+            
+    async def _build_dynamic_routes(self) -> None:
+        """Build dynamic routes using getStaticPaths"""
+        dynamic_routes = [r for r in self.router.routes if r.is_dynamic]
+        
+        for route in dynamic_routes:
+            if route.is_api:
+                continue
+                
+            if route.handler:
+                module = self._get_module_from_handler(route.handler)
+                if module:
+                    paths_result = await get_static_paths_for_route(module)
+                    
+                    for path_config in paths_result.paths:
+                        params = path_config.get("params", path_config)
+                        await self._build_page(route, params)
+                        
+    async def _build_page(
+        self, 
+        route: Route, 
+        params: Optional[Dict[str, str]] = None
+    ) -> None:
+        """Build a single page to static HTML"""
+        params = params or {}
+        
+        path = self._resolve_path(route.path, params)
+        
+        context = PageContext(
+            params=params,
+            query={},
+        )
+        
+        try:
+            props = {}
+            if route.handler:
+                module = self._get_module_from_handler(route.handler)
+                if module:
+                    props = await execute_data_fetching(module, context)
+                    
+            template_name = self._get_template_for_route(route)
+            
+            html = await self.renderer.render_async(
+                template_name,
+                context={**props, "params": params},
+            )
+            
+            output_path = self._get_output_path(path)
+            output_path.parent.mkdir(parents=True, exist_ok=True)
+            output_path.write_text(html)
+            
+            self.build_manifest["pages"][path] = {
+                "file": str(output_path),
+                "params": params,
+            }
+            
+            print(f"  Built: {path} -> {output_path}")
+            
+        except Exception as e:
+            print(f"  Error building {path}: {e}")
+            
+    def _resolve_path(self, route_path: str, params: Dict[str, str]) -> str:
+        """Resolve a dynamic route path with actual params"""
+        path = route_path
+        for key, value in params.items():
+            path = path.replace(f"(?P<{key}>[^/]+)", value)
+            path = path.replace(f"(?P<{key}>.+)", value)
+        return path
+        
+    def _get_template_for_route(self, route: Route) -> str:
+        """Get the template name for a route"""
+        relative = route.file_path.relative_to(self.pages_dir)
+        template_name = str(relative).replace(".py", ".html")
+        
+        template_path = self.templates_dir / template_name
+        if template_path.exists():
+            return template_name
+            
+        return "_page.html"
+        
+    def _get_output_path(self, path: str) -> Path:
+        """Get the output file path for a URL path"""
+        if path == "/":
+            return self.out_dir / "index.html"
+            
+        clean_path = path.strip("/")
+        return self.out_dir / clean_path / "index.html"
+        
+    def _get_module_from_handler(self, handler: Any) -> Optional[Any]:
+        """Get the module that contains the handler"""
+        if hasattr(handler, "__module__"):
+            import sys
+            return sys.modules.get(handler.__module__)
+        return None
+        
+    def _create_sitemap(self) -> None:
+        """Generate sitemap.xml"""
+        pages = self.build_manifest["pages"]
+        
+        sitemap_lines = [
+            '<?xml version="1.0" encoding="UTF-8"?>',
+            '<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">',
+        ]
+        
+        for path in pages:
+            sitemap_lines.append(f"  <url>")
+            sitemap_lines.append(f"    <loc>{path}</loc>")
+            sitemap_lines.append(f"    <lastmod>{datetime.now().strftime('%Y-%m-%d')}</lastmod>")
+            sitemap_lines.append(f"  </url>")
+            
+        sitemap_lines.append("</urlset>")
+        
+        sitemap_path = self.out_dir / "sitemap.xml"
+        sitemap_path.write_text("\n".join(sitemap_lines))
+        print(f"  Generated: sitemap.xml")
+        
+    def _write_manifest(self) -> None:
+        """Write the build manifest to the output directory"""
+        import json
+        manifest_path = self.out_dir / "_nextpy" / "build-manifest.json"
+        manifest_path.parent.mkdir(parents=True, exist_ok=True)
+        manifest_path.write_text(json.dumps(self.build_manifest, indent=2))
+
+
+async def build_project(**kwargs) -> Dict[str, Any]:
+    """Convenience function to build the project"""
+    builder = Builder(**kwargs)
+    return await builder.build()

nextpy/core/data_fetching.py

@@ -0,0 +1,221 @@
+"""
+NextPy Data Fetching - Server-side data fetching inspired by Next.js
+Implements:
+- getServerSideProps (SSR) - Fetch data on every request
+- getStaticProps (SSG) - Fetch data at build time
+- getStaticPaths - Generate dynamic routes at build time
+"""
+
+import asyncio
+import functools
+from typing import Any, Callable, Dict, List, Optional, TypeVar, Union
+from dataclasses import dataclass
+from pydantic import BaseModel
+
+
+class PropsResult(BaseModel):
+    """Result from getServerSideProps or getStaticProps"""
+    props: Dict[str, Any] = {}
+    redirect: Optional[Dict[str, str]] = None
+    not_found: bool = False
+    revalidate: Optional[int] = None
+
+
+class StaticPathsResult(BaseModel):
+    """Result from getStaticPaths"""
+    paths: List[Dict[str, Any]] = []
+    fallback: Union[bool, str] = False
+
+
+@dataclass
+class PageContext:
+    """Context passed to data fetching functions"""
+    params: Dict[str, str]
+    query: Dict[str, str]
+    req: Optional[Any] = None
+    res: Optional[Any] = None
+    preview: bool = False
+    preview_data: Optional[Dict[str, Any]] = None
+    locale: Optional[str] = None
+
+
+T = TypeVar("T", bound=Callable)
+
+
+def get_server_side_props(func: T) -> T:
+    """
+    Decorator to mark a function as getServerSideProps
+    This function will be called on every request
+    
+    Usage:
+        @get_server_side_props
+        async def get_data(context: PageContext) -> PropsResult:
+            data = await fetch_from_api()
+            return PropsResult(props={"data": data})
+    """
+    func._is_server_side_props = True
+    func._data_fetching_type = "ssr"
+    
+    @functools.wraps(func)
+    async def wrapper(context: PageContext) -> PropsResult:
+        if asyncio.iscoroutinefunction(func):
+            result = await func(context)
+        else:
+            result = func(context)
+            
+        if isinstance(result, dict):
+            result = PropsResult(**result)
+        elif not isinstance(result, PropsResult):
+            result = PropsResult(props={"data": result})
+            
+        return result
+        
+    wrapper._is_server_side_props = True
+    wrapper._data_fetching_type = "ssr"
+    return wrapper
+
+
+def get_static_props(func: T) -> T:
+    """
+    Decorator to mark a function as getStaticProps
+    This function will be called at build time (SSG)
+    
+    Usage:
+        @get_static_props
+        async def get_data(context: PageContext) -> PropsResult:
+            data = await fetch_from_cms()
+            return PropsResult(
+                props={"data": data},
+                revalidate=60  # ISR: regenerate every 60 seconds
+            )
+    """
+    func._is_static_props = True
+    func._data_fetching_type = "ssg"
+    
+    @functools.wraps(func)
+    async def wrapper(context: PageContext) -> PropsResult:
+        if asyncio.iscoroutinefunction(func):
+            result = await func(context)
+        else:
+            result = func(context)
+            
+        if isinstance(result, dict):
+            result = PropsResult(**result)
+        elif not isinstance(result, PropsResult):
+            result = PropsResult(props={"data": result})
+            
+        return result
+        
+    wrapper._is_static_props = True
+    wrapper._data_fetching_type = "ssg"
+    return wrapper
+
+
+def get_static_paths(func: T) -> T:
+    """
+    Decorator to mark a function as getStaticPaths
+    Used with dynamic routes to generate paths at build time
+    
+    Usage:
+        @get_static_paths
+        async def get_paths() -> StaticPathsResult:
+            posts = await fetch_all_posts()
+            return StaticPathsResult(
+                paths=[{"params": {"slug": p.slug}} for p in posts],
+                fallback=False
+            )
+    """
+    func._is_static_paths = True
+    
+    @functools.wraps(func)
+    async def wrapper() -> StaticPathsResult:
+        if asyncio.iscoroutinefunction(func):
+            result = await func()
+        else:
+            result = func()
+            
+        if isinstance(result, dict):
+            result = StaticPathsResult(**result)
+        elif isinstance(result, list):
+            result = StaticPathsResult(paths=result)
+        elif not isinstance(result, StaticPathsResult):
+            result = StaticPathsResult(paths=[])
+            
+        return result
+        
+    wrapper._is_static_paths = True
+    return wrapper
+
+
+async def execute_data_fetching(
+    module: Any,
+    context: PageContext
+) -> Dict[str, Any]:
+    """
+    Execute the appropriate data fetching function for a page module
+    Returns the props to pass to the template
+    """
+    props = {}
+    
+    for name in ["getServerSideProps", "get_server_side_props", "getStaticProps", "get_static_props"]:
+        if hasattr(module, name):
+            func = getattr(module, name)
+            
+            if asyncio.iscoroutinefunction(func):
+                result = await func(context)
+            else:
+                result = func(context)
+                
+            if isinstance(result, PropsResult):
+                if result.not_found:
+                    raise PageNotFoundError()
+                if result.redirect:
+                    raise RedirectError(
+                        result.redirect.get("destination", "/"),
+                        result.redirect.get("permanent", False)
+                    )
+                props.update(result.props)
+            elif isinstance(result, dict):
+                if "props" in result:
+                    props.update(result["props"])
+                else:
+                    props.update(result)
+            break
+            
+    return props
+
+
+async def get_static_paths_for_route(module: Any) -> StaticPathsResult:
+    """
+    Get static paths for a dynamic route module
+    """
+    for name in ["getStaticPaths", "get_static_paths"]:
+        if hasattr(module, name):
+            func = getattr(module, name)
+            
+            if asyncio.iscoroutinefunction(func):
+                result = await func()
+            else:
+                result = func()
+                
+            if isinstance(result, StaticPathsResult):
+                return result
+            elif isinstance(result, dict):
+                return StaticPathsResult(**result)
+            elif isinstance(result, list):
+                return StaticPathsResult(paths=result)
+                
+    return StaticPathsResult(paths=[], fallback=False)
+
+
+class PageNotFoundError(Exception):
+    """Raised when a page returns not_found: True"""
+    pass
+
+
+class RedirectError(Exception):
+    """Raised when a page returns a redirect"""
+    def __init__(self, destination: str, permanent: bool = False):
+        self.destination = destination
+        self.permanent = permanent
+        super().__init__(f"Redirect to {destination}")

nextpy/core/renderer.py

@@ -0,0 +1,252 @@
+"""
+NextPy Renderer - Server-side rendering with Jinja2
+Handles template rendering, layouts, and component composition
+"""
+
+import os
+from pathlib import Path
+from typing import Any, Dict, Optional, List
+from jinja2 import Environment, FileSystemLoader, select_autoescape, TemplateNotFound
+from markupsafe import Markup
+
+from nextpy.components.head import Head
+from nextpy.components.link import Link
+
+
+class Renderer:
+    """
+    Server-side renderer using Jinja2
+    Supports layouts, components, and template inheritance
+    """
+    
+    def __init__(
+        self, 
+        templates_dir: str = "templates",
+        pages_dir: str = "pages",
+        public_dir: str = "public"
+    ):
+        self.templates_dir = Path(templates_dir)
+        self.pages_dir = Path(pages_dir)
+        self.public_dir = Path(public_dir)
+        
+        loader = FileSystemLoader([
+            str(self.templates_dir),
+            str(self.pages_dir),
+        ])
+        
+        self.env = Environment(
+            loader=loader,
+            autoescape=select_autoescape(["html", "xml"]),
+            enable_async=True,
+        )
+        
+        self._register_globals()
+        self._register_filters()
+        
+    def _register_globals(self) -> None:
+        """Register global functions and components available in templates"""
+        self.env.globals["Head"] = Head
+        self.env.globals["Link"] = Link
+        self.env.globals["Markup"] = Markup
+        
+        self.env.globals["range"] = range
+        self.env.globals["len"] = len
+        self.env.globals["str"] = str
+        self.env.globals["int"] = int
+        self.env.globals["list"] = list
+        self.env.globals["dict"] = dict
+        self.env.globals["enumerate"] = enumerate
+        
+    def _register_filters(self) -> None:
+        """Register custom Jinja2 filters"""
+        self.env.filters["json"] = self._json_filter
+        self.env.filters["date"] = self._date_filter
+        self.env.filters["truncate_words"] = self._truncate_words_filter
+        
+    @staticmethod
+    def _json_filter(value: Any) -> str:
+        """Convert value to JSON string"""
+        import json
+        return json.dumps(value)
+        
+    @staticmethod
+    def _date_filter(value: Any, format_str: str = "%Y-%m-%d") -> str:
+        """Format a date value"""
+        from datetime import datetime
+        if isinstance(value, str):
+            value = datetime.fromisoformat(value)
+        if hasattr(value, "strftime"):
+            return value.strftime(format_str)
+        return str(value)
+        
+    @staticmethod
+    def _truncate_words_filter(value: str, num_words: int = 20) -> str:
+        """Truncate text to a number of words"""
+        words = value.split()
+        if len(words) <= num_words:
+            return value
+        return " ".join(words[:num_words]) + "..."
+        
+    def render(
+        self,
+        template_name: str,
+        context: Optional[Dict[str, Any]] = None,
+        layout: Optional[str] = None,
+    ) -> str:
+        """
+        Render a template with the given context
+        
+        Args:
+            template_name: Name of the template file
+            context: Dictionary of variables to pass to template
+            layout: Optional layout template to wrap the content
+            
+        Returns:
+            Rendered HTML string
+        """
+        context = context or {}
+        
+        context.setdefault("__page__", template_name)
+        context.setdefault("__layout__", layout)
+        
+        try:
+            template = self.env.get_template(template_name)
+        except TemplateNotFound:
+            template_path = self._find_template(template_name)
+            if template_path:
+                template = self.env.get_template(str(template_path))
+            else:
+                raise
+                
+        content = template.render(**context)
+        
+        if layout:
+            try:
+                layout_template = self.env.get_template(layout)
+                content = layout_template.render(content=Markup(content), **context)
+            except TemplateNotFound:
+                pass
+                
+        return content
+        
+    async def render_async(
+        self,
+        template_name: str,
+        context: Optional[Dict[str, Any]] = None,
+        layout: Optional[str] = None,
+    ) -> str:
+        """Async version of render"""
+        context = context or {}
+        
+        context.setdefault("__page__", template_name)
+        context.setdefault("__layout__", layout)
+        
+        try:
+            template = self.env.get_template(template_name)
+        except TemplateNotFound:
+            template_path = self._find_template(template_name)
+            if template_path:
+                template = self.env.get_template(str(template_path))
+            else:
+                raise
+                
+        content = await template.render_async(**context)
+        
+        if layout:
+            try:
+                layout_template = self.env.get_template(layout)
+                content = await layout_template.render_async(
+                    content=Markup(content), 
+                    **context
+                )
+            except TemplateNotFound:
+                pass
+                
+        return content
+        
+    def _find_template(self, template_name: str) -> Optional[Path]:
+        """Find a template by searching in multiple locations"""
+        search_paths = [
+            self.templates_dir / template_name,
+            self.templates_dir / f"{template_name}.html",
+            self.templates_dir / f"{template_name}.jinja2",
+        ]
+        
+        for path in search_paths:
+            if path.exists():
+                return path.relative_to(self.templates_dir)
+                
+        return None
+        
+    def render_component(
+        self, 
+        component_func: callable,
+        props: Optional[Dict[str, Any]] = None
+    ) -> str:
+        """
+        Render a Python component function
+        Components are functions that return HTML strings
+        """
+        props = props or {}
+        result = component_func(**props)
+        
+        if isinstance(result, str):
+            return result
+        elif hasattr(result, "__html__"):
+            return result.__html__()
+        else:
+            return str(result)
+            
+    def render_page(
+        self,
+        page_module: Any,
+        context: Optional[Dict[str, Any]] = None,
+        params: Optional[Dict[str, str]] = None,
+    ) -> str:
+        """
+        Render a page module (from pages/ directory)
+        
+        The page module can have:
+        - A template() function returning HTML
+        - A Page component class
+        - A get_template() function returning template name
+        """
+        context = context or {}
+        params = params or {}
+        
+        context["params"] = params
+        
+        if hasattr(page_module, "template"):
+            return page_module.template(**context)
+            
+        if hasattr(page_module, "Page"):
+            return self.render_component(page_module.Page, context)
+            
+        if hasattr(page_module, "get_template"):
+            template_name = page_module.get_template()
+            return self.render(template_name, context)
+            
+        page_name = getattr(page_module, "__name__", "page")
+        template_name = f"{page_name}.html"
+        return self.render(template_name, context)
+        
+    def get_layout_chain(self, page_path: Path) -> List[str]:
+        """
+        Get the chain of layouts for a page
+        Similar to Next.js app router layouts
+        """
+        layouts = []
+        current = page_path.parent
+        
+        while current != self.pages_dir.parent:
+            layout_file = current / "_layout.html"
+            if layout_file.exists():
+                layouts.append(str(layout_file.relative_to(self.templates_dir)))
+            current = current.parent
+            
+        layouts.reverse()
+        
+        if (self.templates_dir / "_base.html").exists():
+            layouts.insert(0, "_base.html")
+            
+        return layouts