platzky 1.0.1__py3-none-any.whl → 1.2.0__py3-none-any.whl

platzky/platzky.py

@@ -4,6 +4,8 @@ import urllib.parse
 from flask import redirect, render_template, request, session
 from flask_minify import Minify
 from flask_wtf import CSRFProtect
+from werkzeug.exceptions import HTTPException
+from werkzeug.wrappers import Response
 
 from platzky.admin import admin
 from platzky.blog import blog
@@ -11,6 +13,7 @@ from platzky.config import (
     Config,
     languages_dict,
 )
+from platzky.db.db import DB
 from platzky.db.db_loader import get_db
 from platzky.engine import Engine
 from platzky.plugin.plugin_loader import plugify
@@ -24,38 +27,131 @@ _MISSING_OTEL_MSG = (
 )
 
 
-def create_engine(config: Config, db) -> Engine:
+def _url_encode(x: str) -> str:
+    """URL-encode a string for safe use in URLs.
+
+    Args:
+        x: String to encode
+
+    Returns:
+        URL-encoded string with all characters except safe ones escaped
+    """
+    return urllib.parse.quote(x, safe="")
+
+
+def _get_language_domain(config: Config, lang: str) -> t.Optional[str]:
+    """Get the domain associated with a language.
+
+    Args:
+        config: Application configuration
+        lang: Language code to look up
+
+    Returns:
+        Domain string if language has a dedicated domain, None otherwise
+    """
+    lang_cfg = config.languages.get(lang)
+    if lang_cfg is None:
+        return None
+    return lang_cfg.domain
+
+
+def _get_safe_redirect_url(referrer: t.Optional[str], current_host: str) -> str:
+    """Get a safe redirect URL by validating the referrer.
+
+    Prevents open redirect vulnerabilities by only allowing same-host redirects.
+
+    Args:
+        referrer: The HTTP referrer header value
+        current_host: The current request host
+
+    Returns:
+        The referrer URL if safe, otherwise "/"
+    """
+    if not referrer:
+        return "/"
+
+    referrer_parsed = urllib.parse.urlparse(referrer)
+    # Only redirect to referrer if it's from the same host
+    if referrer_parsed.netloc == current_host:
+        return referrer
+    return "/"
+
+
+def create_engine(config: Config, db: DB) -> Engine:
+    """Create and configure a Platzky Engine instance.
+
+    Sets up the core application with database connection, request handlers,
+    route definitions, and context processors for template rendering.
+
+    Args:
+        config: Application configuration object
+        db: Database instance for data persistence
+
+    Returns:
+        Configured Engine instance with plugins loaded
+    """
     app = Engine(config, db, __name__)
 
     @app.before_request
-    def handle_www_redirection():
+    def handle_www_redirection() -> t.Optional[Response]:
+        """Handle WWW subdomain redirection based on configuration.
+
+        Redirects requests to/from www subdomain based on config.use_www setting.
+
+        Returns:
+            Redirect response if redirection is needed, None otherwise
+        """
         if config.use_www:
             return redirect_nonwww_to_www()
-        else:
-            return redirect_www_to_nonwww()
-
-    def get_langs_domain(lang: str) -> t.Optional[str]:
-        lang_cfg = config.languages.get(lang)
-        if lang_cfg is None:
-            return None
-        return lang_cfg.domain
+        return redirect_www_to_nonwww()
 
     @app.route("/lang/<string:lang>", methods=["GET"])
-    def change_language(lang):
-        if new_domain := get_langs_domain(lang):
-            return redirect("http://" + new_domain, code=301)
-        else:
-            session["language"] = lang
-            return redirect(request.referrer)
+    def change_language(lang: str) -> Response | tuple[str, int]:
+        """Change the user's language preference.
+
+        If the language has a dedicated domain, redirects to that domain.
+        Otherwise, sets the language in the session and returns to the referrer.
+
+        Args:
+            lang: Language code to switch to
+
+        Returns:
+            Redirect response to the language domain or referrer page, or 404 if invalid
+        """
+        # Only allow configured languages
+        if lang not in config.languages:
+            return render_template("404.html", title="404"), 404
+
+        if new_domain := _get_language_domain(config, lang):
+            return redirect(f"{request.scheme}://{new_domain}", code=302)
+
+        session["language"] = lang
+        redirect_url = _get_safe_redirect_url(request.referrer, request.host)
+        return redirect(redirect_url)
 
     def url_link(x: str) -> str:
-        return urllib.parse.quote(x, safe="")
+        """URL-encode a string for safe use in URLs.
+
+        Args:
+            x: String to encode
+
+        Returns:
+            URL-encoded string with all characters except safe ones escaped
+        """
+        return _url_encode(x)
 
     @app.context_processor
-    def utils():
+    def utils() -> dict[str, t.Any]:
+        """Provide utility variables and functions to all templates.
+
+        Returns:
+            Dictionary of template context variables including app metadata,
+            language settings, styling configuration, and helper functions
+        """
         locale = app.get_locale()
-        flag = lang.flag if (lang := config.languages.get(locale)) is not None else ""
-        country = lang.country if (lang := config.languages.get(locale)) is not None else ""
+        lang = config.languages.get(locale)
+        flag = lang.flag if lang is not None else ""
+        country = lang.country if lang is not None else ""
         return {
             "app_name": config.app_name,
             "app_description": app.db.get_app_description(locale) or config.app_name,
@@ -73,21 +169,55 @@ def create_engine(config: Config, db) -> Engine:
         }
 
     @app.context_processor
-    def dynamic_body():
+    def dynamic_body() -> dict[str, str]:
+        """Provide dynamic body content to all templates.
+
+        Returns:
+            Dictionary with dynamic_body content for injection into page body
+        """
         return {"dynamic_body": app.dynamic_body}
 
     @app.context_processor
-    def dynamic_head():
+    def dynamic_head() -> dict[str, str]:
+        """Provide dynamic head content to all templates.
+
+        Returns:
+            Dictionary with dynamic_head content for injection into page head
+        """
         return {"dynamic_head": app.dynamic_head}
 
     @app.errorhandler(404)
-    def page_not_found(e):
+    def page_not_found(_e: HTTPException) -> tuple[str, int]:
+        """Handle 404 Not Found errors.
+
+        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
 
     return plugify(app)
 
 
 def create_app_from_config(config: Config) -> Engine:
+    """Create a fully configured Platzky application from a Config object.
+
+    Initializes the database, creates the engine, sets up telemetry (if enabled),
+    registers blueprints (admin, blog, SEO), and configures minification and CSRF
+    protection.
+
+    Args:
+        config: Application configuration object
+
+    Returns:
+        Fully configured Engine instance ready to serve requests
+
+    Raises:
+        ImportError: If telemetry is enabled but OpenTelemetry packages are not installed
+        ValueError: If telemetry configuration is invalid
+    """
     db = get_db(config.db)
     engine = create_engine(config, db)
 
@@ -133,5 +263,21 @@ def create_app_from_config(config: Config) -> Engine:
 
 
 def create_app(config_path: str) -> Engine:
+    """Create a Platzky application from a YAML configuration file.
+
+    Convenience function that loads configuration from a YAML file and
+    creates the application.
+
+    Args:
+        config_path: Path to the YAML configuration file
+
+    Returns:
+        Fully configured Engine instance ready to serve requests
+
+    Raises:
+        FileNotFoundError: If the configuration file doesn't exist
+        yaml.YAMLError: If the configuration file contains invalid YAML
+        ValidationError: If the configuration doesn't match the expected schema
+    """
     config = Config.parse_yaml(config_path)
     return create_app_from_config(config)

platzky/plugin/plugin.py

@@ -1,6 +1,9 @@
+import inspect
 import logging
+import os
+import types
 from abc import ABC, abstractmethod
-from typing import Any, Dict, Generic, Type, TypeVar
+from typing import Any, Generic, Optional, TypeVar
 
 from pydantic import BaseModel, ConfigDict
 
@@ -39,17 +42,50 @@ class PluginBase(Generic[T], ABC):
     Plugin developers must extend this class to implement their plugins.
     """
 
+    @staticmethod
+    def get_locale_dir_from_module(plugin_module: types.ModuleType) -> Optional[str]:
+        """Get plugin locale directory from a module.
+
+        Encapsulates the knowledge of how plugins organize their locale directories.
+
+        Args:
+            plugin_module: The plugin module
+
+        Returns:
+            Path to the locale directory if it exists, None otherwise
+        """
+        if not hasattr(plugin_module, "__file__") or plugin_module.__file__ is None:
+            return None
+
+        # Use realpath to resolve symlinks and get canonical path
+        plugin_dir = os.path.dirname(os.path.realpath(plugin_module.__file__))
+        locale_dir = os.path.join(plugin_dir, "locale")
+
+        return locale_dir if os.path.isdir(locale_dir) else None
+
     @classmethod
-    def get_config_model(cls) -> Type[PluginBaseConfig]:
+    def get_config_model(cls) -> type[PluginBaseConfig]:
         return PluginBaseConfig
 
-    def __init__(self, config: Dict[str, Any]):
+    def __init__(self, config: dict[str, Any]) -> None:
         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
 
+    def get_locale_dir(self) -> Optional[str]:
+        """Get this plugin's locale directory.
+
+        Returns:
+            Path to the locale directory if it exists, None otherwise
+        """
+        module = inspect.getmodule(self.__class__)
+        if module is None:
+            return None
+
+        return self.get_locale_dir_from_module(module)
+
     @abstractmethod
     def process(self, app: PlatzkyEngine) -> PlatzkyEngine:
         """Process the plugin with the given app.

platzky/plugin/plugin_loader.py

@@ -1,6 +1,8 @@
 import importlib.util
 import inspect
 import logging
+import os
+from types import ModuleType
 from typing import Any, Optional, Type
 
 import deprecation
@@ -11,7 +13,7 @@ from platzky.plugin.plugin import PluginBase, PluginError
 logger = logging.getLogger(__name__)
 
 
-def find_plugin(plugin_name: str) -> Any:
+def find_plugin(plugin_name: str) -> ModuleType:
     """Find plugin by name and return it as module.
 
     Args:
@@ -32,7 +34,7 @@ def find_plugin(plugin_name: str) -> Any:
         ) from e
 
 
-def _is_class_plugin(plugin_module: Any) -> Optional[Type[PluginBase[Any]]]:
+def _is_class_plugin(plugin_module: ModuleType) -> Optional[Type[PluginBase[Any]]]:
     """Check if the plugin module contains a PluginBase implementation.
 
     Args:
@@ -49,24 +51,114 @@ def _is_class_plugin(plugin_module: Any) -> Optional[Type[PluginBase[Any]]]:
 
 
 @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.",
+    deprecated_in="1.2.0",
+    removed_in="2.0.0",
+    current_version="1.2.0",
+    details=(
+        "Legacy plugin style using the entrypoint process() function is deprecated. "
+        "Migrate to PluginBase to support plugin translations and other features. "
+        "See: https://platzky.readthedocs.io/en/latest/plugins.html"
+    ),
 )
-def _process_legacy_plugin(plugin_module, app, plugin_config, plugin_name):
-    """Process a legacy plugin using the entrypoint approach."""
+def _process_legacy_plugin(
+    plugin_module: ModuleType, app: Engine, plugin_config: dict[str, Any], plugin_name: str
+) -> Engine:
+    """Process a legacy plugin using the entrypoint approach.
+
+    DEPRECATED: This function will be removed in version 2.0.0.
+    Please migrate your plugin to extend PluginBase.
+
+    Args:
+        plugin_module: The plugin module
+        app: The Platzky Engine instance
+        plugin_config: Plugin configuration dictionary
+        plugin_name: Name of the plugin
+
+    Returns:
+        Platzky Engine with processed plugin
+    """
     app = plugin_module.process(app, plugin_config)
-    logger.info(f"Processed legacy plugin: {plugin_name}")
+    logger.warning(
+        "Plugin '%s' uses deprecated legacy interface. "
+        "This will be removed in version 2.0.0. "
+        "Migrate to PluginBase: https://platzky.readthedocs.io/",
+        plugin_name,
+    )
     return app
 
 
+def _is_safe_locale_dir(locale_dir: str, plugin_instance: PluginBase[Any]) -> bool:
+    """Validate that a locale directory is safe to use.
+
+    Prevents malicious plugins from exposing arbitrary filesystem paths
+    by ensuring the locale directory is within the plugin's module directory.
+
+    Args:
+        locale_dir: Path to the locale directory
+        plugin_instance: The plugin instance
+
+    Returns:
+        True if the locale directory is safe to use, False otherwise
+    """
+    if not os.path.isdir(locale_dir):
+        return False
+
+    module = inspect.getmodule(plugin_instance.__class__)
+    if module is None or not hasattr(module, "__file__") or module.__file__ is None:
+        return False
+
+    normalized_path = os.path.normpath(locale_dir)
+    if ".." in normalized_path.split(os.sep):
+        logger.warning("Rejected locale path with .. components: %s", locale_dir)
+        return False
+
+    # Get canonical paths (resolve symlinks)
+    locale_path = os.path.realpath(locale_dir)
+    module_path = os.path.realpath(os.path.dirname(module.__file__))
+
+    if not locale_path.startswith(module_path + os.sep):
+        if locale_path != module_path:
+            return False
+
+    return True
+
+
+def _register_plugin_locale(
+    app: Engine, plugin_instance: PluginBase[Any], plugin_name: str
+) -> None:
+    """Register plugin's locale directory with Babel if it exists.
+
+    Args:
+        app: The Platzky Engine instance
+        plugin_instance: The plugin instance
+        plugin_name: Name of the plugin for logging
+    """
+    locale_dir = plugin_instance.get_locale_dir()
+    if locale_dir is None:
+        return
+
+    # Validate that the locale directory is safe to use
+    if not _is_safe_locale_dir(locale_dir, plugin_instance):
+        logger.warning(
+            "Skipping locale directory for plugin %s: path validation failed: %s",
+            plugin_name,
+            locale_dir,
+        )
+        return
+
+    babel_config = app.extensions.get("babel")
+    if babel_config and locale_dir not in babel_config.translation_directories:
+        babel_config.translation_directories.append(locale_dir)
+        logger.info("Registered locale directory for plugin %s: %s", plugin_name, locale_dir)
+
+
 def plugify(app: Engine) -> Engine:
     """Load plugins and run their entrypoints.
 
     Supports both class-based plugins (PluginBase) and legacy entrypoint plugins.
 
+    Legacy plugin support is deprecated and will be removed in version 2.0.0.
+
     Args:
         app: Platzky Engine instance
 
@@ -91,8 +183,9 @@ def plugify(app: Engine) -> Engine:
             if plugin_class:
                 # Handle new class-based plugins
                 plugin_instance = plugin_class(plugin_config)
+                _register_plugin_locale(app, plugin_instance, plugin_name)
                 app = plugin_instance.process(app)
-                logger.info(f"Processed class-based plugin: {plugin_name}")
+                logger.info("Processed class-based plugin: %s", 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)
@@ -102,8 +195,11 @@ def plugify(app: Engine) -> Engine:
                     f"or provide a process() function"
                 )
 
+        except PluginError:
+            # Re-raise PluginError directly to avoid redundant wrapping
+            raise
         except Exception as e:
-            logger.error(f"Error processing plugin {plugin_name}: {e}")
+            logger.exception("Error processing plugin %s", plugin_name)
             raise PluginError(f"Error processing plugin {plugin_name}: {e}") from e
 
     return app

platzky/seo/seo.py

@@ -1,11 +1,27 @@
+"""Flask blueprint for SEO functionality including robots.txt and sitemap.xml."""
+
 import typing as t
 import urllib.parse
 from os.path import dirname
 
-from flask import Blueprint, current_app, make_response, render_template, request
+from flask import Blueprint, Response, current_app, make_response, render_template, request
+
+from platzky.db.db import DB
+
 
+def create_seo_blueprint(
+    db: DB, config: dict[str, t.Any], locale_func: t.Callable[[], str]
+) -> Blueprint:
+    """Create SEO blueprint with routes for robots.txt and sitemap.xml.
 
-def create_seo_blueprint(db, config: dict[str, t.Any], locale_func: t.Callable[[], str]):
+    Args:
+        db: Database instance for accessing blog content
+        config: Configuration dictionary with SEO and blog settings
+        locale_func: Function that returns the current locale/language code
+
+    Returns:
+        Configured Flask Blueprint for SEO functionality
+    """
     seo = Blueprint(
         "seo",
         __name__,
@@ -14,30 +30,49 @@ def create_seo_blueprint(db, config: dict[str, t.Any], locale_func: t.Callable[[
     )
 
     @seo.route("/robots.txt")
-    def robots():
+    def robots() -> Response:
+        """Generate robots.txt file for search engine crawlers.
+
+        Returns:
+            Text response containing robots.txt directives
+        """
         robots_response = render_template("robots.txt", domain=request.host, mimetype="text/plain")
         response = make_response(robots_response)
         response.headers["Content-Type"] = "text/plain"
         return response
 
-    def get_blog_entries(host_base, lang, db, blog_prefix):
-        dynamic_urls = list()
-        print(blog_prefix)
-        for post in db.get_all_posts(
-            lang
-        ):  # TODO add get_list_of_posts for faster getting just list of it
+    def get_blog_entries(
+        host_base: str, lang: str, db: DB, blog_prefix: str
+    ) -> list[dict[str, str]]:
+        """Generate sitemap entries for all blog posts.
+
+        Args:
+            host_base: Base URL of the website (e.g., 'https://example.com')
+            lang: Language code for posts to include
+            db: Database instance for accessing blog posts
+            blog_prefix: URL prefix for blog routes
+
+        Returns:
+            List of dictionaries with sitemap URL entries (loc, lastmod)
+        """
+        dynamic_urls = []
+        # TODO: Add get_list_of_posts for faster getting just list of it
+        for post in db.get_all_posts(lang):
             slug = post.slug
-            datet = post.date.split("T")[0]
+            datet = post.date.date().isoformat()
             url = {"loc": f"{host_base}{blog_prefix}/{slug}", "lastmod": datet}
             dynamic_urls.append(url)
         return dynamic_urls
 
-    @seo.route("/sitemap.xml")  # TODO try to replace sitemap logic with flask-sitemap module
-    def sitemap():
-        """
-        Route to dynamically generate a sitemap of your website/application.
+    @seo.route("/sitemap.xml")  # TODO: Try to replace sitemap logic with flask-sitemap module
+    def sitemap() -> Response:
+        """Route to dynamically generate a sitemap of your website/application.
+
         lastmod and priority tags omitted on static pages.
-        lastmod included on dynamic content such as seo posts.
+        lastmod included on dynamic content such as blog posts.
+
+        Returns:
+            XML response containing the sitemap
         """
         lang = locale_func()
 
@@ -46,7 +81,7 @@ def create_seo_blueprint(db, config: dict[str, t.Any], locale_func: t.Callable[[
         host_base = host_components.scheme + "://" + host_components.netloc
 
         # Static routes with static content
-        static_urls = list()
+        static_urls = []
         for rule in current_app.url_map.iter_rules():
             if rule.methods is not None and "GET" in rule.methods and len(rule.arguments) == 0:
                 url = {"loc": f"{host_base}{rule!s}"}

{platzky-1.0.1.dist-info → platzky-1.2.0.dist-info}/METADATA

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

{platzky-1.0.1.dist-info → platzky-1.2.0.dist-info}/RECORD

@@ -1,31 +1,31 @@
 platzky/__init__.py,sha256=IhL91rSWxIIJQNfVsqJ1d4yY5D2WyWcefo4Xv2aX_lo,180
-platzky/admin/admin.py,sha256=PlwAXaR_YaM07knB88D33vNe6vCpJXOfuxpCaGnHQlY,1028
-platzky/admin/fake_login.py,sha256=tGsdofPyI3P65pol_3Nbj5075xjA_CU090brnBVNjxg,3480
+platzky/admin/admin.py,sha256=QhuxGtUjfX-xeDd_xmSChoeD5Z1UMu1jTGtUck-9jJU,1699
+platzky/admin/fake_login.py,sha256=Z_4M4PLQ73qL-sKh05CmDx_nFy8S30PdsNfPPDeFSmE,3528
 platzky/admin/templates/admin.html,sha256=zgjROhSezayZqnNFezvVa0MEfgmXLvOM8HRRaZemkQw,688
 platzky/admin/templates/login.html,sha256=oBNuv130iMTwXrtRnDUDcGIGvu0O2VsIbjQxw-Tjd7Y,380
 platzky/admin/templates/module.html,sha256=WuQZxKQDD4INl-QF2uiKHf9Fmf2h7cEW9RLe1nWKC8k,175
 platzky/blog/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-platzky/blog/blog.py,sha256=L9IYWxnLo1v1h_wLF-0HyG1Y4RSGg7maEMnYxhTgG5Y,2971
-platzky/blog/comment_form.py,sha256=4lkNJ_S_2DZmJBbz-NPDqahvy2Zz5AGNH2spFeGIop4,513
-platzky/config.py,sha256=NFnW-cjieWgER-uRko1Hbuh6cyGKCFQcq6ihDNSyjQk,7529
+platzky/blog/blog.py,sha256=n3bsZ1GpVCmvxCFMiF7QUDb_PHbmBiTu0GDu3r_Su24,5490
+platzky/blog/comment_form.py,sha256=yOuXvX9PZLc6qQLIWZWLFcbwFQD4a849X82PlXKUzdk,805
+platzky/config.py,sha256=_TQNZ8w8-xQImtm6Gw2SawBqf-UFxF9okIlZi_DGrGA,7540
 platzky/db/README.md,sha256=IO-LoDsd4dLBZenaz423EZjvEOQu_8m2OC0G7du170w,1753
 platzky/db/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-platzky/db/db.py,sha256=0h5rGCBO_N1wBqJRl5EoiW_bFDpNIvmNwuA0hJi89jw,3060
-platzky/db/db_loader.py,sha256=CuEiXxhIa4bFMm0vi7ugzm7j3WycilGRKCU6smgIImE,905
-platzky/db/github_json_db.py,sha256=G1GBIomeKOCeG05pA4qccaFntiGzkgyEMQJz_FQlvNY,2185
-platzky/db/google_json_db.py,sha256=rS__UEK7ed71htTg066_vzpg0etTlpke6YkcrAQ3Fgk,1325
-platzky/db/graph_ql_db.py,sha256=af6yy1R27YO8N9zJWU7VgU7optRgpdk_1ZUtab_1eT4,8967
-platzky/db/json_db.py,sha256=NUBPy4jt-y37TYq4SCGaSgief3MbBWL_Efw8Bxp8Jo0,4046
-platzky/db/json_file_db.py,sha256=tPo92n5zG7vGpunn5vl66zISHBziQdxBttitvc5hPug,1030
-platzky/db/mongodb_db.py,sha256=28KO8XmTEiqE7FcNBzw_pfxOy6Vo-T7qsHdUlh59QX0,5174
-platzky/engine.py,sha256=0bxKzfK83ic-VNlKcDut_84_u5EmY2baU5JcJsleUoM,5461
+platzky/db/db.py,sha256=gi5uxvY8Ww8O4y2rxaH1Zj_12Yno8SbILvIaWnQPbYQ,4778
+platzky/db/db_loader.py,sha256=YgR16K5Mj5pN0vWYVQxTD4Z6ihG5fZyjbUUCS8LNqJs,999
+platzky/db/github_json_db.py,sha256=0z-aCz7Pm6Al--SbIHx4T_FyzwfwQcZDqBduTCOE5_A,3314
+platzky/db/google_json_db.py,sha256=RnvirGFo5a41vkd1iD-M4-HwHlWDZ19EqpF0vIer_Xo,3049
+platzky/db/graph_ql_db.py,sha256=a8LGPJKoNpmTkJ6Bb89eg6m6Q9GFetp5z8A0xuemuSk,14504
+platzky/db/json_db.py,sha256=pANXJZzVPAO890TRy3IvzHjpCaeDgNNgNOR5Uhkk2h4,8078
+platzky/db/json_file_db.py,sha256=Tl6b67p4hNViXSAjujXZ9vtVHN61QhrzJUgOuvngyMI,2232
+platzky/db/mongodb_db.py,sha256=nq07j0NldK014qRL1mF-cvBXQF1LKKTTeWxaZdyzjAs,8595
+platzky/engine.py,sha256=9Y74nrO4gwr9_CqRTzPs9LtcY2t0fs0XtPyjPiqRlVQ,5573
 platzky/locale/en/LC_MESSAGES/messages.po,sha256=WaZGlFAegKRq7CSz69dWKic-mKvQFhVvssvExxNmGaU,1400
 platzky/locale/pl/LC_MESSAGES/messages.po,sha256=sUPxMKDeEOoZ5UIg94rGxZD06YVWiAMWIby2XE51Hrc,1624
-platzky/models.py,sha256=DZZgKW2Q3fY2GMdikFUmAgpsRqT5VKAOwP6RmEsmO2M,1871
-platzky/platzky.py,sha256=8mTqdYqRKONv2oGvQF5Y0fuOomH7ZFYvXtxc7ZohBLE,4585
-platzky/plugin/plugin.py,sha256=tV8aobIzMDJe1frKUAi4kLbrTAIS0FWE3oYpktSo6Ug,1633
-platzky/plugin/plugin_loader.py,sha256=MeQ8LNbrOomwXgc1ISHuyhjZd2mzYKen70eDShWs-Co,3497
-platzky/seo/seo.py,sha256=N_MmAA4KJZmmrDUh0hYNtD8ycOwpNKow4gVSAv8V3N4,2631
+platzky/models.py,sha256=Z372NhIhZcJ92DLPlOq44gTu8XqVcw05SOeJ1BaU7zE,6767
+platzky/platzky.py,sha256=1LKYq8pLm1QBlOcEPhugxWi8W0vuWqjjINIFK8b2Kow,9319
+platzky/plugin/plugin.py,sha256=KZb6VEph__lx9xrv5Ay4h4XkFFYbodV5OimaG6B9IDc,2812
+platzky/plugin/plugin_loader.py,sha256=eKG6zodUCkiRLxJ2ZX9zdN4-ZrZ9EwssoY1SDtThaFo,6707
+platzky/seo/seo.py,sha256=yEyoRzXNXV9lyqnHSGW8mewC3_vYzyQFHI3EuRrd8ao,3805
 platzky/static/blog.css,sha256=TrppzgQbj4UtuTufDCdblyNTVAqgIbhD66Cziyv_xnY,7893
 platzky/static/styles.css,sha256=U5ddGIK-VcGRJZ3BdOpMp0pR__k6rNEMsuQXkP4tFQ0,686
 platzky/telemetry.py,sha256=iXYvEt0Uw5Hx8lAxyr45dpQ_SiE2NxmJkoSx-JSRJyM,5011
@@ -41,7 +41,7 @@ platzky/templates/post.html,sha256=GSgjIZsOQKtNx3cEbquSjZ5L4whPnG6MzRyoq9k4B8Q,1
 platzky/templates/robots.txt,sha256=2_j2tiYtYJnzZUrANiX9pvBxyw5Dp27fR_co18BPEJ0,116
 platzky/templates/sitemap.xml,sha256=iIJZ91_B5ZuNLCHsRtsGKZlBAXojOTP8kffqKLacgvs,578
 platzky/www_handler.py,sha256=pF6Rmvem1sdVqHD7z3RLrDuG-CwAqfGCti50_NPsB2w,725
-platzky-1.0.1.dist-info/METADATA,sha256=lkAvxX2DdR4HSpfYr7A5TXnStXzv0O4ZqFqhDIwrD_c,2556
-platzky-1.0.1.dist-info/WHEEL,sha256=zp0Cn7JsFoX2ATtOhtaFYIiE2rmFAD4OcMhtUki8W3U,88
-platzky-1.0.1.dist-info/licenses/LICENSE,sha256=wCdfk-qEosi6BDwiBulMfKMi0hxp1UXV0DdjLrRm788,1077
-platzky-1.0.1.dist-info/RECORD,,
+platzky-1.2.0.dist-info/METADATA,sha256=N32Pfi0ph7na4fWV4U-mM9B89BwCTtMCErfDpFJDU1I,2556
+platzky-1.2.0.dist-info/WHEEL,sha256=zp0Cn7JsFoX2ATtOhtaFYIiE2rmFAD4OcMhtUki8W3U,88
+platzky-1.2.0.dist-info/licenses/LICENSE,sha256=wCdfk-qEosi6BDwiBulMfKMi0hxp1UXV0DdjLrRm788,1077
+platzky-1.2.0.dist-info/RECORD,,