platzky 0.2.18__tar.gz → 0.3.1__tar.gz

{platzky-0.2.18 → platzky-0.3.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: platzky
-Version: 0.2.18
+Version: 0.3.1
 Summary: Not only blog engine
 License: MIT
 Requires-Python: >=3.10,<4.0
@@ -16,10 +16,10 @@ 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: platzky-sendmail (>=0.1.1,<0.2.0)
 Requires-Dist: pydantic (>=2.7.1,<3.0.0)
 Description-Content-Type: text/markdown
 

platzky-0.3.1/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.1/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.1/platzky/admin/templates/admin.html

@@ -0,0 +1,29 @@
+{% 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">
+  {% 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.1/platzky/admin/templates/login.html

@@ -0,0 +1,21 @@
+{% 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 login_method in login_methods %}
+    {{ login_method | safe }}
+{% endfor %}
+  </div>
+</div>
+
+{% endblock %}

platzky-0.3.1/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.2.18 → platzky-0.3.1}/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.2.18 → platzky-0.3.1}/platzky/db/google_json_db.py

@@ -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.2.18 → platzky-0.3.1}/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.2.18 → platzky-0.3.1}/platzky/db/json_db.py

@@ -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.1/platzky/engine.py

@@ -0,0 +1,62 @@
+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.2.18 → platzky-0.3.1}/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:
@@ -133,6 +82,9 @@ def create_engine(config: Config, db) -> Engine:
 
 def create_app_from_config(config: Config) -> Engine:
     engine = create_engine_from_config(config)
+    admin_blueprint = admin.create_admin_blueprint(
+        login_methods=engine.login_methods, db=engine.db, locale_func=engine.get_locale
+    )
     blog_blueprint = blog.create_blog_blueprint(
         db=engine.db,
         blog_prefix=config.blog_prefix,
@@ -141,6 +93,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)
 

platzky-0.3.1/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.1/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.2.18 → platzky-0.3.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "platzky"
-version = "0.2.18"
+version = "0.3.1"
 description = "Not only blog engine"
 authors = []
 license = "MIT"
@@ -18,7 +18,7 @@ Flask-Minify = "^0.42"
 google-cloud-storage = "^2.5.0"
 humanize = "^4.9.0"
 pydantic = "^2.7.1"
-platzky-sendmail = "^0.1.1"
+deprecation = "^2.1.0"
 
 [tool.poetry.group.dev.dependencies]
 pytest = "^8.2.1"
@@ -73,14 +73,14 @@ target-version = ["py310"]
 line-length = 100
 target-version = "py310"
 show-fixes = true
-select = [
+lint.select = [
     "I", # isort
     "F", # Pyflakes
     "E", # pycodestyle Error
     "W", # pycodestyle Warning
     "RUF", # Ruff-specific rules
 ]
-ignore = []
+lint.ignore = []
 
 [tool.pytest.ini_options]
 markers = [

platzky-0.2.18/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.2.18/platzky/plugin_loader.py

@@ -1,81 +0,0 @@
-import importlib.util
-import logging
-import os
-import sys
-from os.path import abspath, dirname
-
-logger = logging.getLogger(__name__)
-
-
-class PluginError(Exception):
-    pass
-
-
-# TODO remove find_local_plugin after all plugins will be extracted
-def find_local_plugin(plugin_name):
-    """Find plugin by name and return it as module.
-    :param plugin_name: name of plugin to find
-    :return: module of plugin
-    """
-    plugins_dir = os.path.join(dirname(abspath(__file__)), "plugins")
-    module_name = plugin_name.removesuffix(".py")
-    spec = importlib.util.spec_from_file_location(
-        module_name, os.path.join(plugins_dir, plugin_name, "entrypoint.py")
-    )
-    assert spec is not None
-    plugin = importlib.util.module_from_spec(spec)
-    sys.modules[module_name] = plugin
-    assert spec.loader is not None
-    spec.loader.exec_module(plugin)
-    return plugin
-
-
-def find_installed_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 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 found or imported
-    :return: module of plugin
-    """
-    plugin = None
-    try:
-        plugin = find_local_plugin(plugin_name)
-    except FileNotFoundError:
-        logger.info(f"Local plugin {plugin_name} not found, trying installed version")
-        plugin = find_installed_plugin(plugin_name)
-
-    return plugin
-
-
-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

platzky-0.2.18/platzky/plugins/google-tag-manager/entrypoint.py

@@ -1,30 +0,0 @@
-def process(app, plugin_config):
-    gtm_id = plugin_config["ID"]
-
-    head_code = (
-        """<!-- Google Tag Manager -->
-        <script>(function(w,d,s,l,i){w[l]=w[l]||[];w[l].push({'gtm.start':
-        new Date().getTime(),event:'gtm.js'});var f=d.getElementsByTagName(s)[0],
-        j=d.createElement(s),dl=l!='dataLayer'?'&l='+l:'';j.async=true;j.src=
-        'https://www.googletagmanager.com/gtm.js?id='+i+dl;f.parentNode.insertBefore(j,f);
-        })(window,document,'script','dataLayer','"""
-        + gtm_id
-        + """');</script>
-        <!-- End Google Tag Manager -->
-    """
-    )
-    app.add_dynamic_head(head_code)
-
-    body = (
-        """<!-- Google Tag Manager (noscript) -->
-        <noscript><iframe src="https://www.googletagmanager.com/ns.html?id="""
-        + gtm_id
-        + """
-        "
-        height="0" width="0" style="display:none;visibility:hidden"></iframe></noscript>
-        <!-- End Google Tag Manager (noscript) -->
-    """
-    )
-    app.add_dynamic_body(body)
-
-    return app

platzky-0.2.18/platzky/plugins/redirections/entrypoint.py

@@ -1,64 +0,0 @@
-from flask import redirect
-from gql import gql
-from pydantic import BaseModel
-
-
-def json_db_get_redirections(self):
-    return self.data.get("redirections", {})
-
-
-def json_file_db_get_redirections(self):
-    return json_db_get_redirections(self)
-
-
-def google_json_db_get_redirections(self):
-    return self.data.get("redirections", {})
-
-
-def graph_ql_db_get_redirections(self):
-    redirections = gql(
-        """
-        query MyQuery{
-          redirections(stage: PUBLISHED){
-            source
-            destination
-          }
-        }
-        """
-    )
-    return {
-        x["source"]: x["destination"] for x in self.client.execute(redirections)["redirections"]
-    }
-
-
-class Redirection(BaseModel):
-    source: str
-    destiny: str
-
-
-def parse_redirections(config: dict[str, str]) -> list[Redirection]:
-    return [Redirection(source=source, destiny=destiny) for source, destiny in config.items()]
-
-
-def setup_routes(app, redirections):
-    for redirection in redirections:
-        func = redirect_with_name(
-            redirection.destiny,
-            code=301,
-            name=f"{redirection.source}-{redirection.destiny}",
-        )
-        app.route(rule=redirection.source)(func)
-
-
-def redirect_with_name(destiny, code, name):
-    def named_redirect(*args, **kwargs):
-        return redirect(destiny, code, *args, **kwargs)
-
-    named_redirect.__name__ = name
-    return named_redirect
-
-
-def process(app, config: dict[str, str]) -> object:
-    redirections = parse_redirections(config)
-    setup_routes(app, redirections)
-    return app