platzky 1.0.1__tar.gz → 1.1.0__tar.gz

{platzky-1.0.1 → platzky-1.1.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: platzky
-Version: 1.0.1
+Version: 1.1.0
 Summary: Not only blog engine
 License: MIT
 License-File: LICENSE

{platzky-1.0.1 → platzky-1.1.0}/platzky/admin/fake_login.py

@@ -6,7 +6,8 @@ environments as it bypasses proper authentication and authorization controls.
 """
 
 import os
-from typing import Any, Callable
+from collections.abc import Callable
+from typing import Any
 
 from flask import Blueprint, flash, redirect, render_template_string, session, url_for
 from flask_wtf import FlaskForm

platzky-1.1.0/platzky/blog/blog.py

@@ -0,0 +1,112 @@
+import logging
+from collections.abc import Callable
+from os.path import dirname
+from typing import Any
+
+from flask import Blueprint, abort, make_response, render_template, request
+from markupsafe import Markup
+from werkzeug.exceptions import HTTPException
+from werkzeug.wrappers import Response
+
+from . import comment_form
+
+logger = logging.getLogger(__name__)
+
+
+def create_blog_blueprint(db, blog_prefix: str, locale_func):
+    url_prefix = blog_prefix
+    blog = Blueprint(
+        "blog",
+        __name__,
+        url_prefix=url_prefix,
+        template_folder=f"{dirname(__file__)}/../templates",
+    )
+
+    @blog.app_template_filter()
+    def markdown(text):
+        return Markup(text)
+
+    @blog.errorhandler(404)
+    def page_not_found(_e: HTTPException) -> tuple[str, int]:
+        """Handle 404 Not Found errors in blog routes.
+
+        Args:
+            _e: HTTPException object containing error details (unused)
+
+        Returns:
+            Tuple of rendered 404 template and HTTP 404 status code
+        """
+        return render_template("404.html", title="404"), 404
+
+    @blog.route("/", methods=["GET"])
+    def all_posts() -> str:
+        lang = locale_func()
+        posts = db.get_all_posts(lang)
+        if not posts:
+            abort(404)
+        posts_sorted = sorted(posts, reverse=True)
+        return render_template("blog.html", posts=posts_sorted)
+
+    @blog.route("/feed", methods=["GET"])
+    def get_feed() -> Response:
+        lang = locale_func()
+        response = make_response(render_template("feed.xml", posts=db.get_all_posts(lang)))
+        response.headers["Content-Type"] = "application/xml"
+        return response
+
+    @blog.route("/<post_slug>", methods=["POST"])
+    def post_comment(post_slug: str) -> str:
+        comment = request.form.to_dict()
+        db.add_comment(
+            post_slug=post_slug,
+            author_name=comment["author_name"],
+            comment=comment["comment"],
+        )
+        return get_post(post_slug=post_slug)
+
+    def _get_content_or_404(
+        getter_func: Callable[[str], Any],
+        slug: str,
+    ) -> Any:
+        """Helper to fetch content from database or abort with 404.
+
+        Args:
+            getter_func: Database getter function (e.g., db.get_post, db.get_page)
+            slug: Content slug to fetch
+
+        Returns:
+            The fetched content object
+
+        Raises:
+            HTTPException: 404 if content not found
+        """
+        try:
+            return getter_func(slug)
+        except ValueError as e:
+            logger.debug("Content not found for slug '%s': %s", slug, e)
+            abort(404)
+
+    @blog.route("/<post_slug>", methods=["GET"])
+    def get_post(post_slug: str) -> str:
+        post = _get_content_or_404(db.get_post, post_slug)
+        return render_template(
+            "post.html",
+            post=post,
+            post_slug=post_slug,
+            form=comment_form.CommentForm(),
+            comment_sent=request.args.get("comment_sent"),
+        )
+
+    @blog.route("/page/<path:page_slug>", methods=["GET"])
+    def get_page(page_slug: str) -> str:
+        page = _get_content_or_404(db.get_page, page_slug)
+        cover_image_url = page.coverImage.url if page.coverImage.url else None
+        return render_template("page.html", page=page, cover_image=cover_image_url)
+
+    @blog.route("/tag/<path:tag>", methods=["GET"])
+    def get_posts_from_tag(tag: str) -> str:
+        lang = locale_func()
+        posts = db.get_posts_by_tag(tag, lang)
+        return render_template("blog.html", posts=posts, subtitle=f" - tag: {tag}")
+
+    return blog

{platzky-1.0.1 → platzky-1.1.0}/platzky/db/db.py

@@ -1,6 +1,7 @@
 from abc import ABC, abstractmethod
+from collections.abc import Callable
 from functools import partial
-from typing import Any, Callable
+from typing import Any
 
 from pydantic import BaseModel, Field
 

{platzky-1.0.1 → platzky-1.1.0}/platzky/db/json_db.py

@@ -1,5 +1,5 @@
 import datetime
-from typing import Any, Dict
+from typing import Any
 
 from pydantic import Field
 
@@ -12,7 +12,7 @@ def db_config_type():
 
 
 class JsonDbConfig(DBConfig):
-    data: Dict[str, Any] = Field(alias="DATA")
+    data: dict[str, Any] = Field(alias="DATA")
 
 
 def get_db(config):
@@ -30,9 +30,9 @@ def db_from_config(config: JsonDbConfig):
 
 
 class Json(DB):
-    def __init__(self, data: Dict[str, Any]):
+    def __init__(self, data: dict[str, Any]):
         super().__init__()
-        self.data: Dict[str, Any] = data
+        self.data: dict[str, Any] = data
         self.module_name = "json_db"
         self.db_name = "JsonDb"
 
@@ -62,7 +62,10 @@ class Json(DB):
         list_of_pages = (
             page for page in self._get_site_content().get("pages") if page["slug"] == slug
         )
-        page = Post.model_validate(next(list_of_pages))
+        wanted_page = next(list_of_pages, None)
+        if wanted_page is None:
+            raise ValueError(f"Page with slug {slug} not found")
+        page = Post.model_validate(wanted_page)
         return page
 
     def get_menu_items_in_lang(self, lang) -> list[MenuItem]:
@@ -101,10 +104,15 @@ class Json(DB):
         return self._get_site_content().get("secondary_color", "navy")
 
     def add_comment(self, author_name, comment, post_slug):
+        # Store dates in UTC with timezone info for consistency with MongoDB backend
+        # This ensures accurate time delta calculations regardless of server timezone
+        # Legacy dates without timezone info are still supported for backward compatibility
+        now_utc = datetime.datetime.now(datetime.timezone.utc).isoformat(timespec="seconds")
+
         comment = {
             "author": str(author_name),
             "comment": str(comment),
-            "date": datetime.datetime.now().strftime("%Y-%m-%dT%H:%M:%S"),
+            "date": now_utc,
         }
 
         post_index = next(

{platzky-1.0.1 → platzky-1.1.0}/platzky/engine.py

@@ -1,6 +1,7 @@
 import os
+from collections.abc import Callable
 from concurrent.futures import ThreadPoolExecutor, TimeoutError
-from typing import Any, Callable, Dict, List, Tuple
+from typing import Any
 
 from flask import Blueprint, Flask, jsonify, make_response, request, session
 from flask_babel import Babel
@@ -18,7 +19,7 @@ class Engine(Flask):
         self.login_methods = []
         self.dynamic_body = ""
         self.dynamic_head = ""
-        self.health_checks: List[Tuple[str, Callable[[], None]]] = []
+        self.health_checks: list[tuple[str, Callable[[], None]]] = []
         self.telemetry_instrumented: bool = False
         directory = os.path.dirname(os.path.realpath(__file__))
         locale_dir = os.path.join(directory, "locale")
@@ -31,7 +32,7 @@ class Engine(Flask):
         )
         self._register_default_health_endpoints()
 
-        self.cms_modules: List[CmsModule] = []
+        self.cms_modules: list[CmsModule] = []
         # TODO add plugins as CMS Module - all plugins should be visible from
         # admin page at least as configuration
 
@@ -94,7 +95,7 @@ class Engine(Flask):
         @health_bp.route("/health/readiness")
         def readiness():
             """Readiness check - can the app serve traffic?"""
-            health_status: Dict[str, Any] = {"status": "ready", "checks": {}}
+            health_status: dict[str, Any] = {"status": "ready", "checks": {}}
             status_code = 200
 
             executor = ThreadPoolExecutor(max_workers=1)

platzky-1.1.0/platzky/models.py

@@ -0,0 +1,217 @@
+import datetime
+import warnings
+from typing import Annotated
+
+import humanize
+from pydantic import BaseModel, BeforeValidator, Field
+
+
+def _parse_date_string(v: str | datetime.datetime) -> datetime.datetime:
+    """Parse date string to datetime for backward compatibility.
+
+    Handles string dates in various ISO 8601 formats for backward compatibility.
+    Emits deprecation warning when parsing strings.
+
+    In version 2.0.0, only datetime objects will be accepted.
+
+    Args:
+        v: Either a datetime object or an ISO 8601 date string
+
+    Returns:
+        Timezone-aware datetime object
+
+    Raises:
+        ValueError: If the date string cannot be parsed
+    """
+    if isinstance(v, datetime.datetime):
+        # If already a datetime object, ensure it's timezone-aware
+        if v.tzinfo is None:
+            # Naive datetime - make timezone-aware using UTC
+            return v.replace(tzinfo=datetime.timezone.utc)
+        return v
+
+    # v must be a string (based on type annotation)
+    # Emit deprecation warning for string dates
+    warnings.warn(
+        f"Passing date as string ('{v}') is deprecated. "
+        "Please use datetime objects instead. "
+        "String support will be removed in version 2.0.0.",
+        DeprecationWarning,
+        stacklevel=2,
+    )
+
+    # Check for timezone in the original string (before any manipulation)
+    # Check for: +HH:MM, -HH:MM, or Z suffix
+    time_part = v.split("T")[-1] if "T" in v else ""
+    has_timezone = (
+        v.endswith("Z")
+        or "+" in time_part
+        or ("-" in time_part and ":" in time_part.split("-")[-1])
+    )
+
+    # Normalize 'Z' suffix to '+00:00' for fromisoformat
+    normalized = v.replace("Z", "+00:00") if v.endswith("Z") else v
+
+    if has_timezone:
+        # Parse timezone-aware datetime (handles microseconds automatically)
+        return datetime.datetime.fromisoformat(normalized)
+    else:
+        # Legacy format: naive datetime - make timezone-aware using UTC
+        warnings.warn(
+            f"Naive datetime '{v}' interpreted as UTC. "
+            "Explicitly specify timezone in future versions for clarity.",
+            DeprecationWarning,
+            stacklevel=2,
+        )
+        try:
+            parsed = datetime.datetime.fromisoformat(normalized)
+            return parsed.replace(tzinfo=datetime.timezone.utc)
+        except ValueError:
+            # Fallback: date-only format
+            parsed_date = datetime.date.fromisoformat(normalized)
+            return datetime.datetime.combine(
+                parsed_date, datetime.time.min, tzinfo=datetime.timezone.utc
+            )
+
+
+# Type alias for datetime fields that accept strings for backward compatibility
+# Input: str | datetime.datetime
+# Output (after validation): datetime.datetime
+DateTimeField = Annotated[
+    datetime.datetime,
+    BeforeValidator(_parse_date_string),
+    # This allows str at the type-checker level while ensuring datetime after validation
+]
+
+
+class CmsModule(BaseModel):
+    """Represents a CMS module with basic metadata."""
+
+    name: str
+    description: str
+    template: str
+    slug: str
+
+
+# CmsModuleGroup is also a CmsModule, but it contains other CmsModules
+class CmsModuleGroup(CmsModule):
+    """Represents a group of CMS modules, inheriting module properties."""
+
+    modules: list[CmsModule] = []
+
+
+class Image(BaseModel):
+    """Represents an image with URL and alternate text.
+
+    Attributes:
+        url: URL path to the image resource
+        alternateText: Descriptive text for accessibility and SEO
+    """
+
+    url: str = ""
+    alternateText: str = ""
+
+
+class MenuItem(BaseModel):
+    """Represents a navigation menu item.
+
+    Attributes:
+        name: Display name of the menu item
+        url: Target URL for the menu item link
+    """
+
+    name: str
+    url: str
+
+
+class Comment(BaseModel):
+    """Represents a user comment on a blog post or page.
+
+    Attributes:
+        author: Name of the comment author
+        comment: The comment text content
+        date: Datetime when the comment was posted (timezone-aware recommended)
+    """
+
+    author: str
+    comment: str
+    date: DateTimeField
+
+    @property
+    def time_delta(self) -> str:
+        """Calculate human-readable time since the comment was posted.
+
+        Uses timezone-aware datetimes to ensure accurate time delta calculations.
+
+        Returns:
+            Human-friendly time description (e.g., "2 hours ago", "3 days ago")
+        """
+        # self.date is already a datetime object (parsed by field_validator)
+        # Always use timezone-aware datetime for consistency
+        now = datetime.datetime.now(datetime.timezone.utc)
+        return humanize.naturaltime(now - self.date)
+
+
+class Post(BaseModel):
+    """Represents a blog post with metadata, content, and comments.
+
+    Attributes:
+        author: Name of the post author
+        slug: URL-friendly unique identifier for the post
+        title: Post title
+        contentInMarkdown: Post content in Markdown format
+        comments: List of comments on this post
+        excerpt: Short summary or preview of the post
+        tags: List of tags for categorization
+        language: Language code for the post content
+        coverImage: Cover image for the post
+        date: Datetime when the post was published (timezone-aware recommended)
+    """
+
+    author: str
+    slug: str
+    title: str
+    contentInMarkdown: str
+    comments: list[Comment]
+    excerpt: str
+    tags: list[str]
+    language: str
+    coverImage: Image
+    date: DateTimeField
+
+    def __lt__(self, other: object) -> bool:
+        """Compare posts by date for sorting.
+
+        Uses datetime comparison to ensure robust and correct ordering.
+
+        Args:
+            other: Another Post instance to compare against
+
+        Returns:
+            True if this post's date is earlier than the other post's date,
+            or NotImplemented if comparing with a non-Post object
+        """
+        if isinstance(other, Post):
+            return self.date < other.date
+        return NotImplemented
+
+
+Page = Post  # Page is an alias for Post (static pages use the same structure)
+
+
+class Color(BaseModel):
+    """Represents an RGBA color value.
+
+    Attributes:
+        r: Red component (0-255)
+        g: Green component (0-255)
+        b: Blue component (0-255)
+        a: Alpha/transparency component (0-255, where 255 is fully opaque)
+    """
+
+    r: int = Field(default=0, ge=0, le=255, description="Red component (0-255)")
+    g: int = Field(default=0, ge=0, le=255, description="Green component (0-255)")
+    b: int = Field(default=0, ge=0, le=255, description="Blue component (0-255)")
+    a: int = Field(
+        default=255, ge=0, le=255, description="Alpha component (0-255, where 255 is fully opaque)"
+    )