platzky 0.1.19__py3-none-any.whl → 0.2.0__py3-none-any.whl

platzky/blog/blog.py

@@ -1,15 +1,19 @@
-from flask import request, render_template,\
-    make_response, Blueprint, Markup
-from platzky.blog import comment_form, post_formatter
 from os.path import dirname
 
+from flask import Blueprint, make_response, render_template, request
+from markupsafe import Markup
 
-def create_blog_blueprint(db, config, babel):
-    url_prefix = config["BLOG_PREFIX"]
-    blog = Blueprint('blog', __name__, url_prefix=url_prefix, template_folder=f'{dirname(__file__)}/../templates')
+from . import comment_form
 
-    def locale():
-        return babel.locale_selector_func()
+
+def create_blog_blueprint(db, blog_prefix: str, locale_func):
+    url_prefix = blog_prefix
+    blog = Blueprint(
+        "blog",
+        __name__,
+        url_prefix=url_prefix,
+        template_folder=f"{dirname(__file__)}/../templates",
+    )
 
     @blog.app_template_filter()
     def markdown(text):
@@ -17,50 +21,72 @@ def create_blog_blueprint(db, config, babel):
 
     @blog.errorhandler(404)
     def page_not_found(e):
-        return render_template('404.html', title='404'), 404
+        return render_template("404.html", title="404"), 404
 
-    @blog.route('/', methods=["GET"])
-    def index():
-        lang = locale()
-        return render_template("blog.html", posts=db.get_all_posts(lang))
+    @blog.route("/", methods=["GET"])
+    def all_posts():
+        lang = locale_func()
+        posts = db.get_all_posts(lang)
+        if not posts:
+            return page_not_found("no posts")
+        posts_sorted = sorted(posts, reverse=True)
+        return render_template("blog.html", posts=posts_sorted)
 
-    @blog.route('/feed', methods=["GET"])
+    @blog.route("/feed", methods=["GET"])
     def get_feed():
-        lang = locale()
-        response = make_response(render_template("feed.xml", posts=db.get_all_posts(lang)))
+        lang = locale_func()
+        response = make_response(
+            render_template("feed.xml", posts=db.get_all_posts(lang))
+        )
         response.headers["Content-Type"] = "application/xml"
         return response
 
-    @blog.route('/<post_slug>', methods=["POST"])
+    @blog.route("/<post_slug>", methods=["POST"])
     def post_comment(post_slug):
         comment = request.form.to_dict()
-        db.add_comment(post_slug=post_slug, author_name=comment["author_name"],
-                       comment=comment["comment"])
+        db.add_comment(
+            post_slug=post_slug,
+            author_name=comment["author_name"],
+            comment=comment["comment"],
+        )
         return get_post(post_slug=post_slug)
 
-    @blog.route('/<post_slug>', methods=["GET"])
+    @blog.route("/<post_slug>", methods=["GET"])
     def get_post(post_slug):
-        if raw_post := db.get_post(post_slug):
-            formatted_post = post_formatter.format_post(raw_post)
-            return render_template("post.html", post=formatted_post, post_slug=post_slug,
-                                   form=comment_form.CommentForm(), comment_sent=request.args.get('comment_sent'))
-        else:
-            return page_not_found("no such page")
+        post = db.get_post(post_slug)
+        try:
+            post = db.get_post(post_slug)
+            return render_template(
+                "post.html",
+                post=post,
+                post_slug=post_slug,
+                form=comment_form.CommentForm(),
+                comment_sent=request.args.get("comment_sent"),
+            )
+        except ValueError:
+            return page_not_found(f"no post with slug {post_slug}")
+        except Exception as e:
+            return page_not_found(str(e))
 
-    @blog.route('/page/<path:page_slug>', methods=["GET"])
-    def get_page(page_slug):  # TODO refactor to share code with get_post since they are very similar
-        if page := db.get_page(page_slug):
-            if cover_image := page.get("coverImage"):
-                cover_image_url = cover_image["url"]
+    @blog.route("/page/<path:page_slug>", methods=["GET"])
+    def get_page(
+        page_slug,
+    ):  # TODO refactor to share code with get_post since they are very similar
+        try:
+            page = db.get_page(page_slug)
+            if cover_image := page.coverImage:
+                cover_image_url = cover_image.url
             else:
                 cover_image_url = None
             return render_template("page.html", page=page, cover_image=cover_image_url)
-        else:
-            return page_not_found("no such page")
+        except ValueError:
+            return page_not_found("no page with slug {page_slug}")
+        except Exception as e:
+            return page_not_found(str(e))
 
-    @blog.route('/tag/<path:tag>', methods=["GET"])
+    @blog.route("/tag/<path:tag>", methods=["GET"])
     def get_posts_from_tag(tag):
-        lang = locale()
+        lang = locale_func()
         posts = db.get_posts_by_tag(tag, lang)
         return render_template("blog.html", posts=posts, subtitle=f" - tag: {tag}")
 

platzky/blog/comment_form.py

@@ -1,11 +1,15 @@
+from flask_babel import lazy_gettext
 from flask_wtf import FlaskForm
 from wtforms import StringField, SubmitField
 from wtforms.validators import DataRequired
 from wtforms.widgets import TextArea
-from flask_babel import lazy_gettext
 
 
 class CommentForm(FlaskForm):
-    author_name = StringField(lazy_gettext('Name'), validators=[DataRequired()])
-    comment = StringField(lazy_gettext('Type comment here'), validators=[DataRequired()], widget=TextArea())
-    submit = SubmitField(lazy_gettext('Comment'))
+    author_name = StringField(str(lazy_gettext("Name")), validators=[DataRequired()])
+    comment = StringField(
+        str(lazy_gettext("Type comment here")),
+        validators=[DataRequired()],
+        widget=TextArea(),
+    )
+    submit = SubmitField(str(lazy_gettext("Comment")))

platzky/config.py

@@ -1,63 +1,66 @@
-import os.path
+import sys
+import typing as t
 import yaml
+from pydantic import ConfigDict, BaseModel, Field
 
+from .db.db import DBConfig
+from .db.db_loader import get_db_module
 
-def is_db_ok(mapping):
-    if 'DB' not in mapping:
-        raise Exception("DB not set")
-    if 'TYPE' not in mapping['DB']:
-        raise Exception("DB type is not set")
-    if mapping['DB']['TYPE'] not in ['graph_ql', 'json_file', 'google_json']:
-        raise Exception("DB type is not supported")
-    return True
 
+class StrictBaseModel(BaseModel):
+    model_config = ConfigDict(frozen=True)
 
-class Config():
-    def __init__(self, mapping):
-        if is_db_ok(mapping):
-            self.config = mapping
-        else:
-            raise Exception("Config is wrong")
 
-    def add_translations_dir(self, absolute_translation_dir):
-        self.config["BABEL_TRANSLATION_DIRECTORIES"] += ";" + absolute_translation_dir
+class LanguageConfig(StrictBaseModel):
+    name: str = Field(alias="name")
+    flag: str = Field(alias="flag")
+    domain: t.Optional[str] = Field(default=None, alias="domain")
 
-    def asdict(self):
-        return self.config
 
+Languages = dict[str, LanguageConfig]
+LanguagesMapping = t.Mapping[str, t.Mapping[str, str]]
 
-def get_config_mapping(base_config):
-    default_config = {  # TODO move it to platzky
-        "USE_WWW": True,
-        "SEO_PREFIX": "/",
-        "BLOG_PREFIX": "/",
-        "LANGUAGES": {},
-        "DOMAIN_TO_LANG": {},
-        "PLUGINS": []
-    }
 
-    config = default_config | base_config
-    babel_format_dir = ";".join(config.get("TRANSLATION_DIRECTORIES", []))
-    config["BABEL_TRANSLATION_DIRECTORIES"] = babel_format_dir
-    return config
+def languages_dict(languages: Languages) -> LanguagesMapping:
+    return {name: lang.model_dump() for name, lang in languages.items()}
 
 
-def from_file(absolute_config_path):
-    with open(absolute_config_path, "r") as stream:
-        file_config = yaml.safe_load(stream)
-    file_config["CONFIG_PATH"] = absolute_config_path
-    config_from_file = from_mapping(file_config)
-    config_directory = os.path.dirname(absolute_config_path)
-    for x in ["locales", "locale", "translations"]:
-        translation_directory = os.path.join(config_directory, x)
-        config_from_file.add_translations_dir(translation_directory)
+class Config(StrictBaseModel):
+    app_name: str = Field(alias="APP_NAME")
+    secret_key: str = Field(alias="SECRET_KEY")
+    db: DBConfig = Field(alias="DB")
+    use_www: bool = Field(default=True, alias="USE_WWW")
+    seo_prefix: str = Field(default="/", alias="SEO_PREFIX")
+    blog_prefix: str = Field(default="/", alias="BLOG_PREFIX")
+    languages: Languages = Field(default_factory=dict, alias="LANGUAGES")
+    domain_to_lang: dict[str, str] = Field(default_factory=dict, alias="DOMAIN_TO_LANG")
+    translation_directories: list[str] = Field(
+        default_factory=list,
+        alias="TRANSLATION_DIRECTORIES",
+    )
+    debug: bool = Field(default=False, alias="DEBUG")
+    testing: bool = Field(default=False, alias="TESTING")
 
-    path_to_module_locale = os.path.join(os.path.dirname(__file__), "./locale")
-    config_from_file.add_translations_dir(path_to_module_locale)
+    @classmethod
+    def model_validate(
+        cls,
+        obj: t.Any,
+        *,
+        strict: bool | None = None,
+        from_attributes: bool | None = None,
+        context: dict[str, t.Any] | None = None,
+    ) -> "Config":
+        db_cfg_type = get_db_module(obj["DB"]["TYPE"]).db_config_type()
+        obj["DB"] = db_cfg_type.model_validate(obj["DB"])
+        return super().model_validate(
+            obj, strict=strict, from_attributes=from_attributes, context=context
+        )
 
-    return config_from_file
-
-
-def from_mapping(mapping):
-    config_dict = get_config_mapping(mapping)
-    return Config(config_dict)
+    @classmethod
+    def parse_yaml(cls, path: str) -> "Config":
+        try:
+            with open(path, "r") as f:
+                return cls.model_validate(yaml.safe_load(f))
+        except FileNotFoundError:
+            print(f"Config file not found: {path}", file=sys.stderr)
+            raise SystemExit(1)

platzky/db/db.py

@@ -0,0 +1,107 @@
+from functools import partial
+from typing import Any, Callable
+
+from pydantic import BaseModel, Field
+
+from abc import abstractmethod, ABC
+from ..models import MenuItem, Post, Page, Color
+
+
+class DB(ABC):
+    db_name: str = "DB"
+    module_name: str = "db"
+    config_type: type
+
+    def __init_subclass__(cls, *args, **kw):
+        """Check that all methods defined in the subclass exist in the superclasses.
+        This is to prevent subclasses from adding new methods to the DB object.
+        """
+        super().__init_subclass__(*args, **kw)
+        for name in cls.__dict__:
+            if name.startswith("_"):
+                continue
+            for superclass in cls.__mro__[1:]:
+                if name in dir(superclass):
+                    break
+            else:
+                raise TypeError(
+                    f"Method {name} defined in {cls.__name__} does not exist in superclasses"
+                )
+
+    def extend(self, function_name: str, function: Callable) -> None:
+        """
+        Add a function to the DB object. The function must take the DB object as first parameter.
+
+        Parameters:
+        function_name (str): The name of the function to add.
+        function (Callable): The function to add to the DB object.
+        """
+        if not callable(function):
+            raise ValueError(
+                f"The provided func for '{function_name}' is not callable."
+            )
+        try:
+            bound_function = partial(function, self)
+            setattr(self, function_name, bound_function)
+        except Exception as e:
+            raise ValueError(f"Failed to extend DB with function {function_name}: {e}")
+
+    @abstractmethod
+    def get_all_posts(self, lang) -> list[Post]:
+        pass
+
+    @abstractmethod
+    def get_menu_items(self) -> list[MenuItem]:
+        pass
+
+    @abstractmethod
+    def get_post(self, slug) -> Post:
+        pass
+
+    @abstractmethod
+    def get_page(self, slug) -> Page:
+        pass
+
+    @abstractmethod
+    def get_posts_by_tag(self, tag, lang) -> Any:
+        pass
+
+    @abstractmethod
+    def add_comment(self, author_name, comment, post_slug) -> None:
+        pass
+
+    @abstractmethod
+    def get_logo_url(self) -> str:
+        pass
+
+    @abstractmethod
+    def get_primary_color(self) -> Color:
+        pass
+
+    @abstractmethod
+    def get_secondary_color(self) -> Color:
+        pass
+
+    @abstractmethod
+    def get_plugins_data(self) -> list:
+        pass
+
+    @abstractmethod
+    def get_font(self) -> str:
+        pass
+
+    @abstractmethod
+    def get_all_providers(self):  # TODO providers are not part of the DB
+        pass
+
+    @abstractmethod
+    def get_all_questions(self):  # TODO questions are not part of the DB
+        pass
+
+    @abstractmethod
+    def get_site_content(self) -> str:
+        pass
+
+
+class DBConfig(BaseModel):
+    type: str = Field(alias="TYPE")

platzky/db/db_loader.py

@@ -0,0 +1,32 @@
+import importlib.util
+import os
+import sys
+from os.path import abspath, dirname
+
+
+def get_db(db_config):
+    db_name = db_config.type
+    db = get_db_module(db_name)
+    return db.db_from_config(db_config)
+
+
+def get_db_module(db_type):
+    """
+    Load db module from db_type
+    This function is used to load db module dynamically as it is specified in config file.
+    :param db_type: name of db module
+    :return: db module
+    """
+    db_dir = dirname(abspath(__file__))
+    parent_module_name = ".".join(__name__.split(".")[:-1])
+    module_name = f"{parent_module_name}.{db_type}_db"
+    spec = importlib.util.spec_from_file_location(
+        module_name, os.path.join(db_dir, f"{db_type}_db.py")
+    )
+    assert spec is not None
+    db = importlib.util.module_from_spec(spec)
+    sys.modules[f"{db_type}_db"] = db
+    assert spec.loader is not None
+    spec.loader.exec_module(db)
+
+    return db

platzky/db/google_json_db.py

@@ -1,17 +1,34 @@
 import json
-from google.cloud import storage
+
+from google.cloud.storage import Client
+from pydantic import Field
+
+from .db import DBConfig
 from .json_db import Json
 
 
-def get_db(app_config):
-    config = app_config["DB"]
-    bucket_name = config["BUCKET_NAME"]
-    source_blob_name = config["SOURCE_BLOB_NAME"]
-    return GoogleJsonDb(bucket_name, source_blob_name)
+def db_config_type():
+    return GoogleJsonDbConfig
+
+
+class GoogleJsonDbConfig(DBConfig):
+    bucket_name: str = Field(alias="BUCKET_NAME")
+    source_blob_name: str = Field(alias="SOURCE_BLOB_NAME")
+
+
+def db_from_config(config: GoogleJsonDbConfig):
+    return GoogleJsonDb(config.bucket_name, config.source_blob_name)
+
+
+def get_db(config):
+    google_json_db_config = GoogleJsonDbConfig.model_validate(config)
+    return GoogleJsonDb(
+        google_json_db_config.bucket_name, google_json_db_config.source_blob_name
+    )
 
 
 def get_blob(bucket_name, source_blob_name):
-    storage_client = storage.Client()
+    storage_client = Client()
     bucket = storage_client.bucket(bucket_name)
     return bucket.blob(source_blob_name)
 
@@ -23,11 +40,17 @@ def get_data(blob):
 
 class GoogleJsonDb(Json):
     def __init__(self, bucket_name, source_blob_name):
-        self.blob = get_blob(bucket_name, source_blob_name)
+        self.bucket_name = bucket_name
+        self.source_blob_name = source_blob_name
+
+        self.blob = get_blob(self.bucket_name, self.source_blob_name)
         data = get_data(self.blob)
         super().__init__(data)
 
-    def save_entry(self, entry):
+        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')
+        self.blob.upload_from_string(json.dumps(data), content_type="application/json")