platzky 1.1.0__py3-none-any.whl → 1.2.1__py3-none-any.whl

platzky/db/json_file_db.py

@@ -1,4 +1,7 @@
+"""Local file-based JSON database implementation."""
+
 import json
+from typing import Any
 
 from pydantic import Field
 
@@ -6,25 +9,55 @@ from platzky.db.db import DBConfig
 from platzky.db.json_db import Json
 
 
-def db_config_type():
+def db_config_type() -> type["JsonFileDbConfig"]:
+    """Return the configuration class for JSON file database.
+
+    Returns:
+        JsonFileDbConfig class
+    """
     return JsonFileDbConfig
 
 
 class JsonFileDbConfig(DBConfig):
+    """Configuration for JSON file database."""
+
     path: str = Field(alias="PATH")
 
 
-def get_db(config):
+def get_db(config: dict[str, Any]) -> "JsonFile":
+    """Get a JSON file database instance from raw configuration.
+
+    Args:
+        config: Raw configuration dictionary
+
+    Returns:
+        Configured JSON file database instance
+    """
     json_file_db_config = JsonFileDbConfig.model_validate(config)
     return JsonFile(json_file_db_config.path)
 
 
-def db_from_config(config: JsonFileDbConfig):
+def db_from_config(config: JsonFileDbConfig) -> "JsonFile":
+    """Create a JSON file database instance from configuration.
+
+    Args:
+        config: JSON file database configuration
+
+    Returns:
+        Configured JSON file database instance
+    """
     return JsonFile(config.path)
 
 
 class JsonFile(Json):
-    def __init__(self, path: str):
+    """JSON database stored in a local file with read/write support."""
+
+    def __init__(self, path: str) -> None:
+        """Initialize JSON file database from a local file path.
+
+        Args:
+            path: Absolute or relative path to the JSON file
+        """
         self.data_file_path = path
         with open(self.data_file_path) as json_file:
             data = json.load(json_file)
@@ -32,10 +65,17 @@ class JsonFile(Json):
         self.module_name = "json_file_db"
         self.db_name = "JsonFileDb"
 
-    def __save_file(self):
+    def __save_file(self) -> None:
         with open(self.data_file_path, "w") as json_file:
             json.dump(self.data, json_file)
 
-    def add_comment(self, author_name, comment, post_slug):
+    def add_comment(self, author_name: str, comment: str, post_slug: str) -> None:
+        """Add a comment to a blog post and persist to file.
+
+        Args:
+            author_name: Name of the comment author
+            comment: Comment text content
+            post_slug: URL-friendly identifier of the post
+        """
         super().add_comment(author_name, comment, post_slug)
         self.__save_file()

platzky/db/mongodb_db.py

@@ -1,3 +1,5 @@
+"""MongoDB database implementation."""
+
 import datetime
 from typing import Any
 
@@ -10,26 +12,57 @@ from platzky.db.db import DB, DBConfig
 from platzky.models import MenuItem, Page, Post
 
 
-def db_config_type():
+def db_config_type() -> type["MongoDbConfig"]:
+    """Return the configuration class for MongoDB database.
+
+    Returns:
+        MongoDbConfig class
+    """
     return MongoDbConfig
 
 
 class MongoDbConfig(DBConfig):
+    """Configuration for MongoDB database connection."""
+
     connection_string: str = Field(alias="CONNECTION_STRING")
     database_name: str = Field(alias="DATABASE_NAME")
 
 
-def get_db(config):
+def get_db(config: dict[str, Any]) -> "MongoDB":
+    """Get a MongoDB database instance from raw configuration.
+
+    Args:
+        config: Raw configuration dictionary
+
+    Returns:
+        Configured MongoDB database instance
+    """
     mongodb_config = MongoDbConfig.model_validate(config)
     return MongoDB(mongodb_config.connection_string, mongodb_config.database_name)
 
 
-def db_from_config(config: MongoDbConfig):
+def db_from_config(config: MongoDbConfig) -> "MongoDB":
+    """Create a MongoDB database instance from configuration.
+
+    Args:
+        config: MongoDB database configuration
+
+    Returns:
+        Configured MongoDB database instance
+    """
     return MongoDB(config.connection_string, config.database_name)
 
 
 class MongoDB(DB):
+    """MongoDB database implementation with connection pooling."""
+
     def __init__(self, connection_string: str, database_name: str):
+        """Initialize MongoDB database connection.
+
+        Args:
+            connection_string: MongoDB connection URI
+            database_name: Name of the database to use
+        """
         super().__init__()
         self.connection_string = connection_string
         self.database_name = database_name
@@ -46,38 +79,103 @@ class MongoDB(DB):
         self.plugins: Collection[Any] = self.db.plugins
 
     def get_app_description(self, lang: str) -> str:
+        """Retrieve the application description for a specific language.
+
+        Args:
+            lang: Language code (e.g., 'en', 'pl')
+
+        Returns:
+            Application description text or empty string if not found
+        """
         site_content = self.site_content.find_one({"_id": "config"})
         if site_content and "app_description" in site_content:
             return site_content["app_description"].get(lang, "")
         return ""
 
     def get_all_posts(self, lang: str) -> list[Post]:
+        """Retrieve all posts for a specific language.
+
+        Args:
+            lang: Language code (e.g., 'en', 'pl')
+
+        Returns:
+            List of Post objects
+        """
         posts_cursor = self.posts.find({"language": lang})
         return [Post.model_validate(post) for post in posts_cursor]
 
     def get_menu_items_in_lang(self, lang: str) -> list[MenuItem]:
+        """Retrieve menu items for a specific language.
+
+        Args:
+            lang: Language code (e.g., 'en', 'pl')
+
+        Returns:
+            List of MenuItem objects
+        """
         menu_items_doc = self.menu_items.find_one({"_id": lang})
         if menu_items_doc and "items" in menu_items_doc:
             return [MenuItem.model_validate(item) for item in menu_items_doc["items"]]
         return []
 
     def get_post(self, slug: str) -> Post:
+        """Retrieve a single post by its slug.
+
+        Args:
+            slug: URL-friendly identifier for the post
+
+        Returns:
+            Post object
+
+        Raises:
+            ValueError: If post not found
+        """
         post_doc = self.posts.find_one({"slug": slug})
         if post_doc is None:
             raise ValueError(f"Post with slug {slug} not found")
         return Post.model_validate(post_doc)
 
     def get_page(self, slug: str) -> Page:
+        """Retrieve a page by its slug.
+
+        Args:
+            slug: URL-friendly identifier for the page
+
+        Returns:
+            Page object
+
+        Raises:
+            ValueError: If page not found
+        """
         page_doc = self.pages.find_one({"slug": slug})
         if page_doc is None:
             raise ValueError(f"Page with slug {slug} not found")
         return Page.model_validate(page_doc)
 
-    def get_posts_by_tag(self, tag: str, lang: str) -> Any:
+    def get_posts_by_tag(self, tag: str, lang: str) -> list[Post]:
+        """Retrieve posts filtered by tag and language.
+
+        Args:
+            tag: Tag name to filter by
+            lang: Language code (e.g., 'en', 'pl')
+
+        Returns:
+            List of Post objects matching the tag and language
+        """
         posts_cursor = self.posts.find({"tags": tag, "language": lang})
-        return posts_cursor
+        return [Post.model_validate(post) for post in posts_cursor]
 
     def add_comment(self, author_name: str, comment: str, post_slug: str) -> None:
+        """Add a new comment to a post.
+
+        Args:
+            author_name: Name of the comment author
+            comment: Comment text content
+            post_slug: URL-friendly identifier of the post
+
+        Raises:
+            ValueError: If post not found
+        """
         now_utc = datetime.datetime.now(datetime.timezone.utc).isoformat(timespec="seconds")
         comment_doc = {
             "author": str(author_name),
@@ -90,36 +188,66 @@ class MongoDB(DB):
             raise ValueError(f"Post with slug {post_slug} not found")
 
     def get_logo_url(self) -> str:
+        """Retrieve the URL of the application logo.
+
+        Returns:
+            Logo image URL or empty string if not found
+        """
         site_content = self.site_content.find_one({"_id": "config"})
         if site_content:
             return site_content.get("logo_url", "")
         return ""
 
     def get_favicon_url(self) -> str:
+        """Retrieve the URL of the application favicon.
+
+        Returns:
+            Favicon URL or empty string if not found
+        """
         site_content = self.site_content.find_one({"_id": "config"})
         if site_content:
             return site_content.get("favicon_url", "")
         return ""
 
     def get_primary_color(self) -> str:
+        """Retrieve the primary color for the application theme.
+
+        Returns:
+            Primary color value, defaults to 'white'
+        """
         site_content = self.site_content.find_one({"_id": "config"})
         if site_content:
             return site_content.get("primary_color", "white")
         return "white"
 
     def get_secondary_color(self) -> str:
+        """Retrieve the secondary color for the application theme.
+
+        Returns:
+            Secondary color value, defaults to 'navy'
+        """
         site_content = self.site_content.find_one({"_id": "config"})
         if site_content:
             return site_content.get("secondary_color", "navy")
         return "navy"
 
-    def get_plugins_data(self) -> list[Any]:
+    def get_plugins_data(self) -> list[dict[str, Any]]:
+        """Retrieve configuration data for all plugins.
+
+        Returns:
+            List of plugin configuration dictionaries
+        """
         plugins_doc = self.plugins.find_one({"_id": "config"})
         if plugins_doc and "data" in plugins_doc:
             return plugins_doc["data"]
         return []
 
     def get_font(self) -> str:
+        """Get the font configuration for the application.
+
+        Returns:
+            Font name or empty string if not configured
+        """
         site_content = self.site_content.find_one({"_id": "config"})
         if site_content:
             return site_content.get("font", "")

platzky/engine.py

@@ -7,11 +7,12 @@ from flask import Blueprint, Flask, jsonify, make_response, request, session
 from flask_babel import Babel
 
 from platzky.config import Config
+from platzky.db.db import DB
 from platzky.models import CmsModule
 
 
 class Engine(Flask):
-    def __init__(self, config: Config, db, import_name):
+    def __init__(self, config: Config, db: DB, import_name: str) -> None:
         super().__init__(import_name)
         self.config.from_mapping(config.model_dump(by_alias=True))
         self.db = db
@@ -40,7 +41,7 @@ class Engine(Flask):
         for notifier in self.notifiers:
             notifier(message)
 
-    def add_notifier(self, notifier):
+    def add_notifier(self, notifier: Callable[[str], None]) -> None:
         self.notifiers.append(notifier)
 
     def add_cms_module(self, module: CmsModule):
@@ -48,7 +49,7 @@ class Engine(Flask):
         self.cms_modules.append(module)
 
     # TODO login_method should be interface
-    def add_login_method(self, login_method):
+    def add_login_method(self, login_method: Callable[[], str]) -> None:
         self.login_methods.append(login_method)
 
     def add_dynamic_body(self, body: str):

platzky/models.py

@@ -160,29 +160,32 @@ class Post(BaseModel):
         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)
+        language: Language code for the post content (defaults to 'en')
+        comments: Optional list of comments on this post
+        tags: Optional list of tags for categorization
+        date: Optional 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
+    coverImage: Image = Field(default_factory=Image)
+    language: str = "en"
+    comments: list[Comment] = Field(default_factory=list)
+    tags: list[str] = Field(default_factory=list)
+    date: DateTimeField | None = None
 
     def __lt__(self, other: object) -> bool:
         """Compare posts by date for sorting.
 
         Uses datetime comparison to ensure robust and correct ordering.
+        Posts without dates are treated as "less than" dated posts, meaning they
+        appear last when using descending sort (reverse=True, newest-first) and
+        first when using ascending sort.
 
         Args:
             other: Another Post instance to compare against
@@ -192,6 +195,13 @@ class Post(BaseModel):
             or NotImplemented if comparing with a non-Post object
         """
         if isinstance(other, Post):
+            # Posts without dates are sorted last
+            if self.date is None and other.date is None:
+                return False
+            if self.date is None:
+                return True  # None is "less than" any date (sorted last)
+            if other.date is None:
+                return False
             return self.date < other.date
         return NotImplemented
 

platzky/plugin/plugin_loader.py

@@ -2,6 +2,7 @@ import importlib.util
 import inspect
 import logging
 import os
+from types import ModuleType
 from typing import Any, Optional, Type
 
 import deprecation
@@ -12,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:
@@ -33,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:
@@ -60,7 +61,7 @@ def _is_class_plugin(plugin_module: Any) -> Optional[Type[PluginBase[Any]]]:
     ),
 )
 def _process_legacy_plugin(
-    plugin_module: Any, app: Engine, plugin_config: dict[str, Any], plugin_name: str
+    plugin_module: ModuleType, app: Engine, plugin_config: dict[str, Any], plugin_name: str
 ) -> Engine:
     """Process a legacy plugin using the entrypoint approach.
 

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,50 @@ 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.date().isoformat()
-            url = {"loc": f"{host_base}{blog_prefix}/{slug}", "lastmod": datet}
+            url: dict[str, str] = {"loc": f"{host_base}{blog_prefix}/{slug}"}
+            if post.date is not None:
+                url["lastmod"] = post.date.date().isoformat()
             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 +82,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.1.0.dist-info → platzky-1.2.1.dist-info}/METADATA

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

{platzky-1.1.0.dist-info → platzky-1.2.1.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=YkWS-WD5hb-ClVMPO4vJA4Lt2teT9_xkTXQXzubwMdA,3507
+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=YMbLLxza_bhL5wIoqklzhko4Ov9vXLibPHbv8XK1ueA,3600
-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=-rwNDBPV_2fswIyQeecahjLSLkt5n0BYGnTUxGzGTio,3087
-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=URsUykJc1-f5J3Uk64KeKki9Fdok_Be-XqmuhmAfJXE,4488
-platzky/db/json_file_db.py,sha256=tPo92n5zG7vGpunn5vl66zISHBziQdxBttitvc5hPug,1030
-platzky/db/mongodb_db.py,sha256=28KO8XmTEiqE7FcNBzw_pfxOy6Vo-T7qsHdUlh59QX0,5174
-platzky/engine.py,sha256=hSkatp5EC8yKjY_mXkvbVrBnlabvlmcygle_OMzBc_o,5469
+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=Z372NhIhZcJ92DLPlOq44gTu8XqVcw05SOeJ1BaU7zE,6767
+platzky/models.py,sha256=Ws5ZSWf5EhcpFxl3Yeze2pQiesjnjAA_haBJ90bN6lk,7435
 platzky/platzky.py,sha256=1LKYq8pLm1QBlOcEPhugxWi8W0vuWqjjINIFK8b2Kow,9319
 platzky/plugin/plugin.py,sha256=KZb6VEph__lx9xrv5Ay4h4XkFFYbodV5OimaG6B9IDc,2812
-platzky/plugin/plugin_loader.py,sha256=1bhFQbOu_OKJr4ayth9-x4HMHi8eP96EO1ZQwQ57x0o,6657
-platzky/seo/seo.py,sha256=pw7yrhZFQwWR6Ec7_j45JwQAkwAYBGBiQ4NKIB97bHY,2636
+platzky/plugin/plugin_loader.py,sha256=eKG6zodUCkiRLxJ2ZX9zdN4-ZrZ9EwssoY1SDtThaFo,6707
+platzky/seo/seo.py,sha256=cguipDKHYBd0J4M8q8t5QNk3bmUIavXp9V3Ugv0UouU,3854
 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.1.0.dist-info/METADATA,sha256=gunNzvqEk_vWisK0fPkYaS4D625Pn89HV8QQeezaIc8,2556
-platzky-1.1.0.dist-info/WHEEL,sha256=zp0Cn7JsFoX2ATtOhtaFYIiE2rmFAD4OcMhtUki8W3U,88
-platzky-1.1.0.dist-info/licenses/LICENSE,sha256=wCdfk-qEosi6BDwiBulMfKMi0hxp1UXV0DdjLrRm788,1077
-platzky-1.1.0.dist-info/RECORD,,
+platzky-1.2.1.dist-info/METADATA,sha256=0LIO-7G1YnqVwinorr24GPlOBBE0RPIR_Q99FfuvrkA,2556
+platzky-1.2.1.dist-info/WHEEL,sha256=zp0Cn7JsFoX2ATtOhtaFYIiE2rmFAD4OcMhtUki8W3U,88
+platzky-1.2.1.dist-info/licenses/LICENSE,sha256=wCdfk-qEosi6BDwiBulMfKMi0hxp1UXV0DdjLrRm788,1077
+platzky-1.2.1.dist-info/RECORD,,