platzky 0.3.0__tar.gz → 0.3.3__tar.gz

{platzky-0.3.0 → platzky-0.3.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: platzky
-Version: 0.3.0
+Version: 0.3.3
 Summary: Not only blog engine
 License: MIT
 Requires-Python: >=3.10,<4.0
@@ -16,10 +16,12 @@ Requires-Dist: Flask-Minify (>=0.42,<0.43)
 Requires-Dist: Flask-WTF (>=1.2.1,<2.0.0)
 Requires-Dist: PyYAML (>=6.0,<7.0)
 Requires-Dist: aiohttp (>=3.9.5,<4.0.0)
+Requires-Dist: deprecation (>=2.1.0,<3.0.0)
 Requires-Dist: google-cloud-storage (>=2.5.0,<3.0.0)
 Requires-Dist: gql (>=3.4.0,<4.0.0)
 Requires-Dist: humanize (>=4.9.0,<5.0.0)
 Requires-Dist: pydantic (>=2.7.1,<3.0.0)
+Requires-Dist: pygithub (>=2.6.1,<3.0.0)
 Description-Content-Type: text/markdown
 
 ![Github Actions](https://github.com/platzky/platzky/actions/workflows/tests.yml/badge.svg?event=push&branch=main)

platzky-0.3.3/platzky/__init__.py

@@ -0,0 +1,3 @@
+from platzky.engine import Engine as Engine
+from platzky.platzky import create_app_from_config as create_app_from_config
+from platzky.platzky import create_engine as create_engine

platzky-0.3.3/platzky/admin/admin.py

@@ -0,0 +1,33 @@
+from os.path import dirname
+
+from flask import Blueprint, render_template, session
+
+
+def create_admin_blueprint(login_methods, db, locale_func):
+    admin = Blueprint(
+        "admin",
+        __name__,
+        url_prefix="/admin",
+        template_folder=f"{dirname(__file__)}/templates",
+    )
+
+    @admin.route("/", methods=["GET"])
+    def admin_panel_home():
+        user = session.get("user", None)
+
+        if not user:
+            return render_template("login.html", login_methods=login_methods)
+
+        cms_modules = {"plugins": [plugin.get("name") for plugin in db.get_plugins_data()]}
+        return render_template("admin.html", user=user, cms_modules=cms_modules)
+
+    @admin.route("/module/<module_name>", methods=["GET"])
+    def module_settings(module_name):
+        user = session.get("user", None)
+
+        if not user:
+            return render_template("login.html", login_methods=login_methods)
+
+        return render_template("module.html", user=user, module_name=module_name)
+
+    return admin

platzky-0.3.3/platzky/admin/fake_login.py

@@ -0,0 +1,82 @@
+"""
+Fake login functionality for development environments only.
+
+WARNING: This module provides fake login functionality and should NEVER be used in production
+environments as it bypasses proper authentication and authorization controls.
+"""
+
+import os
+from typing import Any, Callable
+
+from flask import Blueprint, flash, redirect, session, url_for
+from markupsafe import Markup
+
+ROLE_ADMIN = "admin"
+ROLE_NONADMIN = "nonadmin"
+VALID_ROLES = [ROLE_ADMIN, ROLE_NONADMIN]
+
+
+def get_fake_login_html() -> Callable[[], str]:
+    """Return a callable that generates HTML for fake login buttons."""
+
+    def generate_html() -> str:
+        admin_url = url_for("admin.handle_fake_login", role="admin")
+        nonadmin_url = url_for("admin.handle_fake_login", role="nonadmin")
+
+        # Rest of the code remains the same
+        html = f"""
+        <div class="col-md-6 mb-4">
+          <div class="card">
+            <div class="card-header">
+              Development Login
+            </div>
+            <div class="card-body">
+              <p class="text-danger"><strong>Warning:</strong> For development only</p>
+              <div class="d-flex justify-content-around">
+                <form method="post" action="{admin_url}" style="display: inline;">
+                  <input type="hidden" name="csrf_token" value="{{ csrf_token() }}">
+                  <button type="submit" class="btn btn-primary">Login as Admin</button>
+                </form>
+                <form method="post" action="{nonadmin_url}" style="display: inline;">
+                  <input type="hidden" name="csrf_token" value="{{ csrf_token() }}">
+                  <button type="submit" class="btn btn-secondary">Login as Non-Admin</button>
+                </form>
+              </div>
+            </div>
+          </div>
+        </div>
+        """
+        return Markup(html)
+
+    return generate_html
+
+
+def setup_fake_login_routes(admin_blueprint: Blueprint) -> Blueprint:
+    """Add fake login routes to the provided admin_blueprint."""
+
+    env = os.environ
+    is_testing = "PYTEST_CURRENT_TEST" in env.keys() or env.get("FLASK_DEBUG") in (
+        "1",
+        "true",
+        "True",
+        True,
+    )
+
+    if not is_testing:
+        raise RuntimeError(
+            "SECURITY ERROR: Fake login routes are enabled outside of a testing environment! "
+            "This functionality must only be used during development or testing."
+        )
+
+    @admin_blueprint.route("/fake-login/<role>", methods=["POST"])
+    def handle_fake_login(role: str) -> Any:
+        if role not in VALID_ROLES:
+            flash(f"Invalid role: {role}. Must be one of: {', '.join(VALID_ROLES)}", "error")
+            return redirect(url_for("admin.admin_panel_home"))
+        if role == ROLE_ADMIN:
+            session["user"] = {"username": ROLE_ADMIN, "role": ROLE_ADMIN}
+        else:
+            session["user"] = {"username": "user", "role": ROLE_NONADMIN}
+        return redirect(url_for("admin.admin_panel_home"))
+
+    return admin_blueprint

platzky-0.3.3/platzky/admin/templates/admin.html

@@ -0,0 +1,30 @@
+{% extends "base.html" %}
+
+{% block description %}
+{{ _("This is the admin page. You can manage your posts here.") }}
+{% endblock %}
+
+{% block content %}
+
+<div class="admin-contents mx-auto w-75">
+  <h1>{% block title %}Admin{% endblock %}</h1>
+  {% if user %}
+    <div class="alert alert-success" role="alert">You're logged in</div>
+  {% endif %}
+</div>
+
+{% endblock %}
+
+{% block left_panel %}
+<div id="admin-panel">
+  <p>User: {{ user.username }}</p>
+  {% for cms_module_name, cms_entries in cms_modules.items() %}
+  <div class="cms-module mb-2">
+    <p>{{ cms_module_name }}</p>
+    {% for cms_entry in cms_entries %}
+    <a href="{{ url_for('admin.module', name=cms_entry) }}" class="cms-entry btn btn-primary btn-block mb-2">{{ cms_entry }}</a>
+    {% endfor %}
+  </div>
+  {% endfor %}
+</div>
+{% endblock %}

platzky-0.3.3/platzky/admin/templates/login.html

@@ -0,0 +1,23 @@
+{% extends "base.html" %}
+
+{% block description %}
+{{ _("This is the login page. You can log in here.") }}
+
+{% endblock %}
+
+{% block content %}
+
+<div class="login-contents mx-auto w-75">
+  <h1>{% block title %}Login{% endblock %}</h1>
+
+  <div class="row align-items-center">
+
+{% for method in login_methods %}
+        {{ method() }}
+
+{% endfor %}
+
+  </div>
+</div>
+
+{% endblock %}

platzky-0.3.3/platzky/admin/templates/module.html

@@ -0,0 +1,9 @@
+{% extends "admin.html" %}
+
+{% block content %}
+
+<div class="module-contents mx-auto w-75">
+  <h1>{% block title %}{% module_name %}{% endblock %}</h1>
+</div>
+
+{% endblock %}

{platzky-0.3.0 → platzky-0.3.3}/platzky/blog/blog.py

@@ -51,7 +51,6 @@ def create_blog_blueprint(db, blog_prefix: str, locale_func):
 
     @blog.route("/<post_slug>", methods=["GET"])
     def get_post(post_slug):
-        post = db.get_post(post_slug)
         try:
             post = db.get_post(post_slug)
             return render_template(

platzky-0.3.3/platzky/db/README.md

@@ -0,0 +1,70 @@
+# Platzky Database Modules
+
+This directory contains the database abstraction layer for the Platzky application. The database modules provide a consistent interface for accessing content regardless of where it's stored.
+
+## Architecture
+
+The database layer is built on an abstract base class (DB) that defines a common interface. Multiple implementations are provided for different storage backends:
+
+- **Json**: Base implementation for JSON data sources
+- **JsonFile**: Local JSON file storage
+- **GithubJsonDb**: JSON files stored in GitHub repository
+- **GoogleJsonDb**: JSON files stored in Google Cloud Storage
+- **GraphQL**: Content stored in a GraphQL API
+
+
+## Configuration
+
+Database configuration is specified in your application config file. Each database type has its own configuration schema.
+
+### JSON File Database
+
+```yaml
+DB:
+  TYPE: json_file
+  PATH: "/path/to/data.json"
+
+```
+### GitHub JSON Database
+
+```yaml
+DB:
+  TYPE: github_json
+  REPO_NAME: "username/repository"
+  GITHUB_TOKEN: "your_github_token"
+  BRANCH_NAME: "main"
+  PATH_TO_FILE: "data.json"
+```
+
+### Google JSON Database
+
+```yaml
+DB:
+  TYPE: google_json
+  BUCKET_NAME: "your-bucket-name"
+  SOURCE_BLOB_NAME: "data.json"
+```
+
+### GraphQL Database
+
+```yaml
+DB:
+  TYPE: graph_ql
+  CMS_ENDPOINT: "https://your-graphql-endpoint.com/api"
+  CMS_TOKEN: "your_graphql_token"
+```
+
+## Usage
+
+The database is automatically initialized based on your configuration. The application will use the appropriate database implementation
+
+```python
+from platzky.db.db_loader import get_db
+
+# db_config is loaded from your application config
+db = get_db(db_config)
+
+# Now you can use any of the standard DB methods
+posts = db.get_all_posts("en")
+menu_items = db.get_menu_items_in_lang("en")
+```

{platzky-0.3.0 → platzky-0.3.3}/platzky/db/db.py

@@ -4,7 +4,7 @@ from typing import Any, Callable
 
 from pydantic import BaseModel, Field
 
-from ..models import Color, MenuItem, Page, Post
+from platzky.models import Color, MenuItem, Page, Post
 
 
 class DB(ABC):

platzky-0.3.3/platzky/db/github_json_db.py

@@ -0,0 +1,69 @@
+import json
+
+import requests
+from github import Github
+from pydantic import Field
+
+from platzky.db.db import DBConfig
+from platzky.db.json_db import Json as JsonDB
+
+
+def db_config_type():
+    return GithubJsonDbConfig
+
+
+class GithubJsonDbConfig(DBConfig):
+    github_token: str = Field(alias="GITHUB_TOKEN")
+    repo_name: str = Field(alias="REPO_NAME")
+    path_to_file: str = Field(alias="PATH_TO_FILE")
+    branch_name: str = Field(alias="BRANCH_NAME", default="main")
+
+
+def db_from_config(config: GithubJsonDbConfig):
+    return GithubJsonDb(
+        config.github_token, config.repo_name, config.branch_name, config.path_to_file
+    )
+
+
+def get_db(config):
+    github_json_db_config = GithubJsonDbConfig.model_validate(config)
+    return GithubJsonDb(
+        github_json_db_config.github_token,
+        github_json_db_config.repo_name,
+        github_json_db_config.branch_name,
+        github_json_db_config.path_to_file,
+    )
+
+
+class GithubJsonDb(JsonDB):
+    def __init__(self, github_token: str, repo_name: str, branch_name: str, path_to_file: str):
+        self.branch_name = branch_name
+        self.repo = Github(github_token).get_repo(repo_name)
+        self.file_path = path_to_file
+
+        try:
+            file_content = self.repo.get_contents(self.file_path, ref=self.branch_name)
+
+            if isinstance(file_content, list):
+                raise ValueError(f"Path '{self.file_path}' points to a directory, not a file")
+
+            if file_content.content:
+                raw_data = file_content.decoded_content.decode("utf-8")
+            else:
+
+                download_url = file_content.download_url
+                response = requests.get(download_url, timeout=40)
+                response.raise_for_status()
+                raw_data = response.text
+
+            self.data = json.loads(raw_data)
+
+        except (json.JSONDecodeError, requests.RequestException) as e:
+            raise ValueError(f"Error parsing JSON content: {e}")
+        except Exception as e:
+            raise ValueError(f"Error retrieving GitHub content: {e}")
+
+        super().__init__(self.data)
+
+        self.module_name = "github_json_db"
+        self.db_name = "GithubJsonDb"

{platzky-0.3.0 → platzky-0.3.3}/platzky/db/google_json_db.py

@@ -3,8 +3,8 @@ import json
 from google.cloud.storage import Client
 from pydantic import Field
 
-from .db import DBConfig
-from .json_db import Json
+from platzky.db.db import DBConfig
+from platzky.db.json_db import Json
 
 
 def db_config_type():
@@ -47,8 +47,3 @@ class GoogleJsonDb(Json):
 
         self.module_name = "google_json_db"
         self.db_name = "GoogleJsonDb"
-
-    def __save_entry(self, entry):
-        data = get_data(self.blob)
-        data["data"].append(entry)
-        self.blob.upload_from_string(json.dumps(data), content_type="application/json")

{platzky-0.3.0 → platzky-0.3.3}/platzky/db/graph_ql_db.py

@@ -6,8 +6,8 @@ from gql.transport.aiohttp import AIOHTTPTransport
 from gql.transport.exceptions import TransportQueryError
 from pydantic import Field
 
-from ..models import Color, Post
-from .db import DB, DBConfig
+from platzky.db.db import DB, DBConfig
+from platzky.models import Color, Post
 
 
 def db_config_type():
@@ -29,7 +29,7 @@ def db_from_config(config: GraphQlDbConfig):
 
 def _standarize_comment(
     comment,
-):  # TODO add tests for checking stadarization of comments
+):
     return {
         "author": comment["author"],
         "comment": comment["comment"],
@@ -37,7 +37,7 @@ def _standarize_comment(
     }
 
 
-def _standarize_post(post):  # TODO add tests for checking stadarization of posts
+def _standarize_post(post):
     return {
         "author": post["author"]["name"],
         "slug": post["slug"],

{platzky-0.3.0 → platzky-0.3.3}/platzky/db/json_db.py

@@ -3,8 +3,8 @@ from typing import Any, Dict
 
 from pydantic import Field
 
-from ..models import MenuItem, Post
-from .db import DB, DBConfig
+from platzky.db.db import DB, DBConfig
+from platzky.models import MenuItem, Post
 
 
 def db_config_type():
@@ -73,7 +73,11 @@ class Json(DB):
         return menu_items_list
 
     def get_posts_by_tag(self, tag, lang):
-        return (post for post in self._get_site_content()["posts"] if tag in post["tags"])
+        return (
+            post
+            for post in self._get_site_content()["posts"]
+            if tag in post["tags"] and post["language"] == lang
+        )
 
     def _get_site_content(self):
         content = self.data.get("site_content")

{platzky-0.3.0 → platzky-0.3.3}/platzky/db/json_file_db.py

@@ -2,8 +2,8 @@ import json
 
 from pydantic import Field
 
-from .db import DBConfig
-from .json_db import Json
+from platzky.db.db import DBConfig
+from platzky.db.json_db import Json
 
 
 def db_config_type():

platzky-0.3.3/platzky/engine.py

@@ -0,0 +1,61 @@
+import os
+
+from flask import Flask, request, session
+from flask_babel import Babel
+
+from platzky.config import Config
+
+
+class Engine(Flask):
+    def __init__(self, config: Config, db, import_name):
+        super().__init__(import_name)
+        self.config.from_mapping(config.model_dump(by_alias=True))
+        self.db = db
+        self.notifiers = []
+        self.login_methods = []
+        self.dynamic_body = ""
+        self.dynamic_head = ""
+        directory = os.path.dirname(os.path.realpath(__file__))
+        locale_dir = os.path.join(directory, "locale")
+        config.translation_directories.append(locale_dir)
+        babel_translation_directories = ";".join(config.translation_directories)
+        self.babel = Babel(
+            self,
+            locale_selector=self.get_locale,
+            default_translation_directories=babel_translation_directories,
+        )
+
+    def notify(self, message: str):
+        for notifier in self.notifiers:
+            notifier(message)
+
+    def add_notifier(self, notifier):
+        self.notifiers.append(notifier)
+
+    # TODO login_method should be interface
+    def add_login_method(self, login_method):
+        self.login_methods.append(login_method)
+
+    def add_dynamic_body(self, body: str):
+        self.dynamic_body += body
+
+    def add_dynamic_head(self, body: str):
+        self.dynamic_head += body
+
+    def get_locale(self) -> str:
+        domain = request.headers.get("Host", "localhost")
+        domain_to_lang = self.config.get("DOMAIN_TO_LANG")
+
+        languages = self.config.get("LANGUAGES", {}).keys()
+        backup_lang = session.get(
+            "language",
+            request.accept_languages.best_match(languages, "en"),
+        )
+
+        if domain_to_lang:
+            lang = domain_to_lang.get(domain, backup_lang)
+        else:
+            lang = backup_lang
+
+        session["language"] = lang
+        return lang

{platzky-0.3.0 → platzky-0.3.3}/platzky/platzky.py

@@ -1,71 +1,20 @@
-import os
 import typing as t
 import urllib.parse
 
-from flask import Flask, redirect, render_template, request, session
-from flask_babel import Babel
+from flask import redirect, render_template, request, session
 from flask_minify import Minify
 
-from .blog import blog
-from .config import (
+from platzky.admin import admin
+from platzky.blog import blog
+from platzky.config import (
     Config,
     languages_dict,
 )
-from .db.db_loader import get_db
-from .plugin_loader import plugify
-from .seo import seo
-from .www_handler import redirect_nonwww_to_www, redirect_www_to_nonwww
-
-
-class Engine(Flask):
-    def __init__(self, config: Config, db, import_name):
-        super().__init__(import_name)
-        self.config.from_mapping(config.model_dump(by_alias=True))
-        self.db = db
-        self.notifiers = []
-        self.dynamic_body = ""
-        self.dynamic_head = ""
-        directory = os.path.dirname(os.path.realpath(__file__))
-        locale_dir = os.path.join(directory, "locale")
-        config.translation_directories.append(locale_dir)
-
-        babel_translation_directories = ";".join(config.translation_directories)
-        self.babel = Babel(
-            self,
-            locale_selector=self.get_locale,
-            default_translation_directories=babel_translation_directories,
-        )
-
-    def notify(self, message: str):
-        for notifier in self.notifiers:
-            notifier(message)
-
-    def add_notifier(self, notifier):
-        self.notifiers.append(notifier)
-
-    def add_dynamic_body(self, body: str):
-        self.dynamic_body += body
-
-    def add_dynamic_head(self, body: str):
-        self.dynamic_head += body
-
-    def get_locale(self) -> str:
-        domain = request.headers["Host"]
-        domain_to_lang = self.config.get("DOMAIN_TO_LANG")
-
-        languages = self.config.get("LANGUAGES", {}).keys()
-        backup_lang = session.get(
-            "language",
-            request.accept_languages.best_match(languages, "en"),
-        )
-
-        if domain_to_lang:
-            lang = domain_to_lang.get(domain, backup_lang)
-        else:
-            lang = backup_lang
-
-        session["language"] = lang
-        return lang
+from platzky.db.db_loader import get_db
+from platzky.engine import Engine
+from platzky.plugin.plugin_loader import plugify
+from platzky.seo import seo
+from platzky.www_handler import redirect_nonwww_to_www, redirect_www_to_nonwww
 
 
 def create_engine(config: Config, db) -> Engine:
@@ -132,7 +81,19 @@ def create_engine(config: Config, db) -> Engine:
 
 
 def create_app_from_config(config: Config) -> Engine:
-    engine = create_engine_from_config(config)
+    db = get_db(config.db)
+    engine = create_engine(config, db)
+
+    admin_blueprint = admin.create_admin_blueprint(
+        login_methods=engine.login_methods, db=engine.db, locale_func=engine.get_locale
+    )
+
+    if config.feature_flags and config.feature_flags.get("FAKE_LOGIN", False):
+        from platzky.admin.fake_login import get_fake_login_html, setup_fake_login_routes
+
+        engine.login_methods.append(get_fake_login_html())
+        admin_blueprint = setup_fake_login_routes(admin_blueprint)
+
     blog_blueprint = blog.create_blog_blueprint(
         db=engine.db,
         blog_prefix=config.blog_prefix,
@@ -141,6 +102,7 @@ def create_app_from_config(config: Config) -> Engine:
     seo_blueprint = seo.create_seo_blueprint(
         db=engine.db, config=engine.config, locale_func=engine.get_locale
     )
+    engine.register_blueprint(admin_blueprint)
     engine.register_blueprint(blog_blueprint)
     engine.register_blueprint(seo_blueprint)
 
@@ -148,12 +110,6 @@ def create_app_from_config(config: Config) -> Engine:
     return engine
 
 
-def create_engine_from_config(config: Config) -> Engine:
-    """Create an engine from a config."""
-    db = get_db(config.db)
-    return create_engine(config, db)
-
-
 def create_app(config_path: str) -> Engine:
     config = Config.parse_yaml(config_path)
     return create_app_from_config(config)

platzky-0.3.3/platzky/plugin/plugin.py

@@ -0,0 +1,66 @@
+import logging
+from abc import ABC, abstractmethod
+from typing import Any, Dict, Generic, Type, TypeVar
+
+from pydantic import BaseModel, ConfigDict
+
+from platzky.platzky import Engine as PlatzkyEngine
+
+logger = logging.getLogger(__name__)
+
+
+class PluginError(Exception):
+    """Exception raised for plugin-related errors."""
+
+    pass
+
+
+class ConfigPluginError(PluginError):
+    """Exception raised for plugin configuration-related errors."""
+
+    pass
+
+
+class PluginBaseConfig(BaseModel):
+    """Base Pydantic model for plugin configurations.
+
+    Plugin developers should extend this class to define their own configuration schema.
+    """
+
+    model_config = ConfigDict(extra="allow")
+
+
+T = TypeVar("T", bound=PluginBaseConfig)
+
+
+class PluginBase(Generic[T], ABC):
+    """Abstract base class for plugins.
+
+    Plugin developers must extend this class to implement their plugins.
+    """
+
+    @classmethod
+    def get_config_model(cls) -> Type[PluginBaseConfig]:
+        return PluginBaseConfig
+
+    def __init__(self, config: Dict[str, Any]):
+        try:
+            config_class = self.get_config_model()
+            self.config = config_class.model_validate(config)
+        except Exception as e:
+            raise ConfigPluginError(f"Invalid configuration: {e}") from e
+
+    @abstractmethod
+    def process(self, app: PlatzkyEngine) -> PlatzkyEngine:
+        """Process the plugin with the given app.
+
+        Args:
+            app: The Flask application instance
+
+        Returns:
+            Platzky Engine with processed plugins
+
+        Raises:
+            PluginError: If plugin processing fails
+        """
+        pass

platzky-0.3.3/platzky/plugin/plugin_loader.py

@@ -0,0 +1,109 @@
+import importlib.util
+import inspect
+import logging
+from typing import Any, Optional, Type
+
+import deprecation
+
+from platzky.engine import Engine
+from platzky.plugin.plugin import PluginBase, PluginError
+
+logger = logging.getLogger(__name__)
+
+
+def find_plugin(plugin_name: str) -> Any:
+    """Find plugin by name and return it as module.
+
+    Args:
+        plugin_name: name of plugin to find
+
+    Raises:
+        PluginError: if plugin cannot be imported
+
+    Returns:
+        module of plugin
+    """
+    try:
+        return importlib.import_module(f"platzky_{plugin_name}")
+    except ImportError as e:
+        raise PluginError(
+            f"Plugin {plugin_name} not found. Ensure it's installed and follows "
+            f"the 'platzky_<plugin_name>' naming convention"
+        ) from e
+
+
+def _is_class_plugin(plugin_module: Any) -> Optional[Type[PluginBase[Any]]]:
+    """Check if the plugin module contains a PluginBase implementation.
+
+    Args:
+        plugin_module: The imported plugin module
+
+    Returns:
+        The plugin class if found, None otherwise
+    """
+    # Look for classes in the module that inherit from PluginBase
+    for _, obj in inspect.getmembers(plugin_module):
+        if inspect.isclass(obj) and issubclass(obj, PluginBase) and obj != PluginBase:
+            return obj
+    return None
+
+
+@deprecation.deprecated(
+    deprecated_in="0.3.1",
+    removed_in="0.4.0",
+    current_version=None,  # You should replace this with the current version
+    details="Legacy plugin style using the entrypoint process() function is deprecated. "
+    "Please migrate to the PluginBase interface.",
+)
+def _process_legacy_plugin(plugin_module, app, plugin_config, plugin_name):
+    """Process a legacy plugin using the entrypoint approach."""
+    app = plugin_module.process(app, plugin_config)
+    logger.info(f"Processed legacy plugin: {plugin_name}")
+    return app
+
+
+def plugify(app: Engine) -> Engine:
+    """Load plugins and run their entrypoints.
+
+    Supports both class-based plugins (PluginBase) and legacy entrypoint plugins.
+
+    Args:
+        app: Platzky Engine instance
+
+    Returns:
+        Platzky Engine with processed plugins
+
+    Raises:
+        PluginError: if plugin processing fails
+    """
+    plugins_data = app.db.get_plugins_data()
+
+    for plugin_data in plugins_data:
+        plugin_config = plugin_data["config"]
+        plugin_name = plugin_data["name"]
+
+        try:
+            plugin_module = find_plugin(plugin_name)
+
+            # Check if this is a class-based plugin
+            plugin_class = _is_class_plugin(plugin_module)
+
+            if plugin_class:
+                # Handle new class-based plugins
+                plugin_instance = plugin_class(plugin_config)
+                app = plugin_instance.process(app)
+                logger.info(f"Processed class-based plugin: {plugin_name}")
+            elif hasattr(plugin_module, "process"):
+                # Handle legacy entrypoint plugins with deprecation warning
+                app = _process_legacy_plugin(plugin_module, app, plugin_config, plugin_name)
+            else:
+                raise PluginError(
+                    f"Plugin {plugin_name} doesn't implement either the PluginBase interface "
+                    f"or provide a process() function"
+                )
+
+        except Exception as e:
+            logger.error(f"Error processing plugin {plugin_name}: {e}")
+            raise PluginError(f"Error processing plugin {plugin_name}: {e}") from e
+
+    return app

{platzky-0.3.0 → platzky-0.3.3}/platzky/templates/base.html

@@ -14,6 +14,17 @@
 {% block body_meta %}
 {% include "body_meta.html" %}
 {% endblock %}
+
+{% with messages = get_flashed_messages(with_categories=true) %}
+  {% if messages %}
+    <div class="flash-messages">
+      {% for category, message in messages %}
+        <div class="alert alert-{{ category }}">{{ message }}</div>
+      {% endfor %}
+    </div>
+  {% endif %}
+{% endwith %}
+
 <div class="container-fluid d-flex flex-column h-100 g-0">
   <div class="row header-row bg-light g-0">
     <nav class="navbar navbar-expand-lg navbar-light px-3 py-1" id="mainNav">

{platzky-0.3.0 → platzky-0.3.3}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "platzky"
-version = "0.3.0"
+version = "0.3.3"
 description = "Not only blog engine"
 authors = []
 license = "MIT"
@@ -18,6 +18,8 @@ Flask-Minify = "^0.42"
 google-cloud-storage = "^2.5.0"
 humanize = "^4.9.0"
 pydantic = "^2.7.1"
+deprecation = "^2.1.0"
+pygithub = "^2.6.1"
 
 [tool.poetry.group.dev.dependencies]
 pytest = "^8.2.1"

platzky-0.3.0/platzky/__init__.py

@@ -1,3 +0,0 @@
-from .platzky import Engine as Engine
-from .platzky import create_app_from_config as create_app_from_config
-from .platzky import create_engine as create_engine

platzky-0.3.0/platzky/plugin_loader.py

@@ -1,43 +0,0 @@
-import importlib.util
-import logging
-
-logger = logging.getLogger(__name__)
-
-
-class PluginError(Exception):
-    pass
-
-
-def find_plugin(plugin_name):
-    """Find plugin by name and return it as module.
-    :param plugin_name: name of plugin to find
-    :raises PluginError: if plugin cannot be imported
-    :return: module of plugin
-    """
-    try:
-        return importlib.import_module(f"platzky_{plugin_name}")
-    except ImportError as e:
-        raise PluginError(
-            f"Plugin {plugin_name} not found. Ensure it's installed and follows "
-            f"the 'platzky_<plugin_name>' naming convention"
-        ) from e
-
-
-def plugify(app):
-    """Load plugins and run their entrypoints.
-    :param app: Flask app
-    :return: Flask app
-    """
-
-    plugins_data = app.db.get_plugins_data()
-
-    for plugin_data in plugins_data:
-        plugin_config = plugin_data["config"]
-        plugin_name = plugin_data["name"]
-        try:
-            plugin = find_plugin(plugin_name)
-            plugin.process(app, plugin_config)
-        except Exception as e:
-            raise PluginError(f"Error processing plugin {plugin_name}: {e}") from e
-
-    return app