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

platzky/db/graph_ql_db.py

@@ -1,22 +1,59 @@
-#TODO rename file, extract it to another library, remove qgl and aiohttp from dependencies
+# TODO rename file, extract it to another library, remove qgl and aiohttp from dependencies
 
-from gql import gql, Client
-from gql.transport.aiohttp import AIOHTTPTransport
 import json
-from platzky.blog.db import DB
 
+from gql import Client, gql
+from gql.transport.aiohttp import AIOHTTPTransport
+from pydantic import Field
+
+from .db import DB, DBConfig
+from ..models import Color, Post
+
+
+def db_config_type():
+    return GraphQlDbConfig
+
+
+class GraphQlDbConfig(DBConfig):
+    endpoint: str = Field(alias="CMS_ENDPOINT")
+    token: str = Field(alias="CMS_TOKEN")
+
+
+def get_db(config: GraphQlDbConfig):
+    return GraphQL(config.endpoint, config.token)
+
+
+def db_from_config(config: GraphQlDbConfig):
+    return GraphQL(config.endpoint, config.token)
 
-def get_db(config):
-    endpoint = config["DB"]["CMS_ENDPOINT"]
-    token = config["DB"]["CMS_TOKEN"]
-    return GraphQL(endpoint, token)
+
+def _standarize_post(post):
+    return {
+        "author": post["author"]["name"],
+        "slug": post["slug"],
+        "title": post["title"],
+        "excerpt": post["excerpt"],
+        "contentInMarkdown": post["contentInRichText"]["html"],
+        "comments": post["comments"],
+        "tags": post["tags"],
+        "language": post["language"],
+        "coverImage": {
+            "url": post["coverImage"]["image"]["url"],
+        },
+        "date": post["date"],
+    }
 
 
 class GraphQL(DB):
     def __init__(self, endpoint, token):
-        full_token = 'bearer ' + token
-        transport = AIOHTTPTransport(url=endpoint, headers={'Authorization': full_token})
+        self.module_name = "graph_ql_db"
+        self.db_name = "GraphQLDb"
+        full_token = "bearer " + token
+        transport = AIOHTTPTransport(
+            url=endpoint, headers={"Authorization": full_token}
+        )
         self.client = Client(transport=transport)
+        super().__init__()
 
     def get_all_posts(self, lang):
         all_posts = gql(
@@ -24,22 +61,38 @@ class GraphQL(DB):
             query MyQuery($lang: Lang!) {
               posts(where: {language: $lang},  orderBy: date_DESC, stage: PUBLISHED){
                 createdAt
+                author {
+                    name
+                }
+                contentInRichText {
+                    html
+                    }
+                comments {
+                  comment
+                  author
+                  createdAt
+                  }
                 date
                 title
                 excerpt
                 slug
                 tags
+                language
                 coverImage {
                   alternateText
                   image {
                     url
                   }
-                }             
+                }
               }
             }
             """
         )
-        return self.client.execute(all_posts, variable_values={"lang": lang})['posts']
+        raw_ql_posts = self.client.execute(all_posts, variable_values={"lang": lang})[
+            "posts"
+        ]
+
+        return [Post.model_validate(_standarize_post(post)) for post in raw_ql_posts]
 
     def get_menu_items(self):
         menu_items = gql(
@@ -52,17 +105,23 @@ class GraphQL(DB):
             }
             """
         )
-        return self.client.execute(menu_items)['menuItems']
+        return self.client.execute(menu_items)["menuItems"]
 
     def get_post(self, slug):
         post = gql(
             """
             query MyQuery($slug: String!) {
               post(where: {slug: $slug}, stage: PUBLISHED) {
+                date
+                language
                 title
+                slug
+                author {
+                    name
+                }                
                 contentInRichText {
-                  text
                   markdown
+                  html
                 }
                 excerpt
                 tags
@@ -76,13 +135,16 @@ class GraphQL(DB):
                     author
                     comment
                     date: createdAt
-                }                
+                }
               }
             }
-            """)
-        return self.client.execute(post, variable_values={"slug": slug})['post']
+            """
+        )
+
+        post_raw = self.client.execute(post, variable_values={"slug": slug})["post"]
+        return Post.model_validate(_standarize_post(post_raw))
 
-    #TODO Cleanup page logic of internationalization (now it depends on translation of slugs)
+    # TODO Cleanup page logic of internationalization (now it depends on translation of slugs)
     def get_page(self, slug):
         post = gql(
             """
@@ -96,8 +158,9 @@ class GraphQL(DB):
                 }
               }
             }
-            """)
-        return self.client.execute(post, variable_values={"slug": slug})['page']
+            """
+        )
+        return self.client.execute(post, variable_values={"slug": slug})["page"]
 
     def get_posts_by_tag(self, tag, lang):
         post = gql(
@@ -117,8 +180,11 @@ class GraphQL(DB):
                     }
               }
             }
-            """)
-        return self.client.execute(post, variable_values={"tag": tag, "lang": lang})['posts']
+            """
+        )
+        return self.client.execute(post, variable_values={"tag": tag, "lang": lang})[
+            "posts"
+        ]
 
     def get_all_providers(self):
         all_providers = gql(
@@ -151,7 +217,7 @@ class GraphQL(DB):
             """
         )
         query = self.client.execute(all_questions)
-        return query['questions']
+        return query["questions"]
 
     def add_comment(self, author_name, comment, post_slug):
         add_comment = gql(
@@ -167,7 +233,31 @@ class GraphQL(DB):
                     id
                 }
             }
-            """)
-        self.client.execute(add_comment, variable_values={
-            "author": author_name, "comment": comment, "slug": post_slug
-        })
+            """
+        )
+        self.client.execute(
+            add_comment,
+            variable_values={
+                "author": author_name,
+                "comment": comment,
+                "slug": post_slug,
+            },
+        )
+
+    def get_font(self):
+        return str("")
+
+    def get_logo_url(self):
+        return ""
+
+    def get_primary_color(self) -> Color:
+        return Color()
+
+    def get_secondary_color(self):
+        return Color()
+
+    def get_site_content(self):
+        return ""
+
+    def get_plugins_data(self):
+        return []

platzky/db/json_db.py

@@ -1,34 +1,72 @@
-from platzky.blog.db import DB
 import datetime
+from typing import Any, Dict
+
+from pydantic import Field
+
+from .db import DB, DBConfig
+from ..models import MenuItem, Post
+
+
+def db_config_type():
+    return JsonDbConfig
+
+
+class JsonDbConfig(DBConfig):
+    data: Dict[str, Any] = Field(alias="DATA")
 
 
 def get_db(config):
-    return Json(config["DATA"])
+    json_db_config = JsonDbConfig.model_validate(config)
+    return Json(json_db_config.data)
+
+
+def db_from_config(config: JsonDbConfig):
+    return Json(config.data)
 
 
 class Json(DB):
-    def __init__(self, data_dict):
-        self.data = data_dict
+    def __init__(self, data: Dict[str, Any]):
+        super().__init__()
+        self.data: Dict[str, Any] = data
+        self.module_name = "json_db"
+        self.db_name = "JsonDb"
 
     def get_all_posts(self, lang):
-        posts = (filter(lambda x: x["language"] == lang, self.data.get("posts", [])))
-        return list(posts)
+        return [
+            Post.model_validate(post)
+            for post in self.get_site_content().get("posts", ())
+            if post["language"] == lang
+        ]
 
-    def get_post(self, slug):
-        post = next(filter(lambda x: x["slug"] == slug, self.data["posts"]), None)
-        return post
+    def get_post(self, slug: str) -> Post:
+        """Returns a post matching the given slug."""
+        all_posts = self.get_site_content().get("posts")
+        if all_posts is None:
+            raise ValueError("Posts data is missing")
+        wanted_post = next((post for post in all_posts if post["slug"] == slug), None)
+        if wanted_post is None:
+            raise ValueError(f"Post with slug {slug} not found")
+        return Post.model_validate(wanted_post)
 
+    # TODO: add test for non-existing page
     def get_page(self, slug):
-        post = next(filter(lambda x: x["slug"] == slug, self.data["pages"]), None)
-        return post
+        list_of_pages = (
+            page
+            for page in self.get_site_content().get("pages")
+            if page["slug"] == slug
+        )
+        page = Post.model_validate(next(list_of_pages))
+        return page
 
-    def get_menu_items(self):
-        post = self.data.get("menu_items", [])
-        return post
+    def get_menu_items(self) -> list[MenuItem]:
+        menu_items_raw = self.get_site_content().get("menu_items", [])
+        menu_items_list = [MenuItem.model_validate(x) for x in menu_items_raw]
+        return menu_items_list
 
     def get_posts_by_tag(self, tag, lang):
-        posts = filter(lambda x: tag in x["tags"], self.data["posts"])
-        return posts
+        return (
+            post for post in self.get_site_content()["posts"] if tag in post["tags"]
+        )
 
     def get_all_providers(self):
         return self.data["providers"]
@@ -36,11 +74,37 @@ class Json(DB):
     def get_all_questions(self):
         return self.data["questions"]
 
+    def get_site_content(self):
+        content = self.data.get("site_content")
+        if content is None:
+            raise Exception("Content should not be None")
+        return content
+
+    def get_logo_url(self):
+        return self.get_site_content().get("logo_url", "")
+
+    def get_font(self) -> str:
+        return self.get_site_content().get("font", "")
+
+    def get_primary_color(self):
+        return self.get_site_content().get("primary_color", "white")
+
+    def get_secondary_color(self):
+        return self.get_site_content().get("secondary_color", "navy")
+
     def add_comment(self, author_name, comment, post_slug):
         comment = {
             "author": str(author_name),
             "comment": str(comment),
-            "date": datetime.datetime.now().strftime("%Y-%m-%dT%H:%M:%S")
+            "date": datetime.datetime.now().strftime("%Y-%m-%dT%H:%M:%S"),
         }
-        post_index = next(i for i in range(len(self.data["posts"])) if self.data["posts"][i]["slug"] == post_slug)
-        self.data["posts"][post_index]["comments"].append(comment)
+
+        post_index = next(
+            i
+            for i in range(len(self.get_site_content()["posts"]))
+            if self.get_site_content()["posts"][i]["slug"] == post_slug
+        )
+        self.get_site_content()["posts"][post_index]["comments"].append(comment)
+
+    def get_plugins_data(self):
+        return self.data.get("plugins", [])

platzky/db/json_file_db.py

@@ -1,25 +1,41 @@
 import json
-import os.path
 
-from platzky.db.json_db import Json
+from pydantic import Field
+
+from .db import DBConfig
+from .json_db import Json
+
+
+def db_config_type():
+    return JsonFileDbConfig
+
+
+class JsonFileDbConfig(DBConfig):
+    path: str = Field(alias="PATH")
 
 
 def get_db(config):
-    db_path = os.path.abspath(config["DB"]["PATH"])
-    return JsonFile(db_path)
+    json_file_db_config = JsonFileDbConfig.model_validate(config)
+    return JsonFile(json_file_db_config.path)
+
+
+def db_from_config(config: JsonFileDbConfig):
+    return JsonFile(config.path)
 
 
 class JsonFile(Json):
-    def __init__(self, file_path):
-        self.data_file_path = file_path
+    def __init__(self, path: str):
+        self.data_file_path = path
         with open(self.data_file_path) as json_file:
             data = json.load(json_file)
             super().__init__(data)
+        self.module_name = "json_file_db"
+        self.db_name = "JsonFileDb"
 
-    def _save_file(self):
-        with open(self.data_file_path, 'w') as json_file:
+    def __save_file(self):
+        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):
         super().add_comment(author_name, comment, post_slug)
-        self._save_file()
+        self.__save_file()

platzky/models.py

@@ -0,0 +1,64 @@
+from pydantic import BaseModel
+import datetime
+import humanize
+
+
+class Image(BaseModel):
+    url: str = ""
+    alternateText: str = ""
+
+
+class MenuItem(BaseModel):
+    name: str
+    url: str
+
+
+class Comment(BaseModel):
+    author: str
+    comment: str
+    date: str  # TODO change its type to datetime
+
+    @property
+    def time_delta(self) -> str:
+        now = datetime.datetime.now()
+        date = datetime.datetime.strptime(self.date.split(".")[0], "%Y-%m-%dT%H:%M:%S")
+        return humanize.naturaltime(now - date)
+
+
+class Post(BaseModel):
+    author: str
+    slug: str
+    title: str
+    contentInMarkdown: str
+    comments: list[Comment]
+    excerpt: str
+    tags: list[str]
+    language: str
+    coverImage: Image
+    date: str
+
+    def __lt__(self, other):
+        if isinstance(other, Post):
+            return self.date < other.date
+        return NotImplemented
+
+
+Page = Post
+
+
+class Color(BaseModel):
+    def __init__(self, r: int = 0, g: int = 0, b: int = 0, a: int = 255):
+        if not (0 <= r <= 255):
+            raise ValueError("r must be between 0 and 255")
+        if not (0 <= g <= 255):
+            raise ValueError("g must be between 0 and 255")
+        if not (0 <= b <= 255):
+            raise ValueError("b must be between 0 and 255")
+        if not (0 <= a <= 255):
+            raise ValueError("a must be between 0 and 255")
+        super().__init__(r=r, g=g, b=b, a=a)
+
+    r: int
+    g: int
+    b: int
+    a: int

platzky/platzky.py

@@ -1,94 +1,154 @@
-from flask import Flask, request, session, redirect, render_template
+import typing as t
+import urllib.parse
+
+from flask import Flask, redirect, render_template, request, session
 from flask_babel import Babel
 from flask_minify import Minify
 
-import os
-import urllib.parse
-
-from . import config, db_loader
 from .blog import blog
+from .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_www_to_nonwww, redirect_nonwww_to_www
-
-
-def create_app_from_config(config_object):
-    engine = create_engine_from_config(config_object)
-
-    blog_blueprint = blog.create_blog_blueprint(db=engine.db,
-                                                config=engine.config, babel=engine.babel)
-    seo_blueprint = seo.create_seo_blueprint(db=engine.db,
-                                             config=engine.config)
-    engine.register_blueprint(blog_blueprint)
-    engine.register_blueprint(seo_blueprint)
-    Minify(app=engine, html=True, js=True, cssless=True)
-    return engine
-
-
-def create_app(config_path):
-    absolute_config_path = os.path.join(os.getcwd(), config_path)
-    config_object = config.from_file(absolute_config_path)
-    return create_app_from_config(config_object)
-
-
-def create_engine_from_config(config_object):
-    config_dict = config_object.asdict()
-    db_driver = db_loader.load_db_driver(config_dict["DB"]["TYPE"])
-    db = db_driver.get_db(config_dict)
-    languages = config_dict["LANGUAGES"]
-    domain_langs = config_dict["DOMAIN_TO_LANG"]
-    return create_engine(config_dict, db, languages, domain_langs)
+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 = ""
+        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
 
-def create_engine(config, db, languages, domain_langs):
-    app = Flask(__name__)
-    app.config.from_mapping(config)
 
-    app.db = db
-    app.babel = Babel(app)
-    languages = languages
-    domain_langs = domain_langs
+def create_engine(config: Config, db) -> Engine:
+    app = Engine(config, db, __name__)
 
     @app.before_request
     def handle_www_redirection():
-        if app.config["USE_WWW"]:
+        if config.use_www:
             return redirect_nonwww_to_www()
         else:
             return redirect_www_to_nonwww()
 
-    @app.babel.localeselector
-    def get_locale():
-        domain = request.headers['Host']
-        lang = domain_langs.get(domain,
-                                session.get('language',
-                                            request.accept_languages.best_match(languages.keys(), 'en')))
-        session['language'] = lang
-        return lang
-
-    def get_langs_domain(lang):
-        return languages.get(lang).get('domain')
+    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
 
-    @app.route('/lang/<string:lang>', methods=["GET"])
+    @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
+            session["language"] = lang
             return redirect(request.referrer)
 
+    @app.route("/logo", methods=["GET"])
+    def logo():
+        return redirect(
+            "https://www.problematy.pl/wp-content/uploads/2023/08/kolor_poziom.png"
+        )
+
+    def url_link(x: str) -> str:
+        return urllib.parse.quote(x, safe="")
+
     @app.context_processor
     def utils():
+        locale = app.get_locale()
+        flag = lang.flag if (lang := config.languages.get(locale)) is not None else ""
         return {
-            "app_name": app.config["APP_NAME"],
-            'languages': languages,
-            "current_flag": languages[get_locale()]['flag'],
-            "current_language": get_locale(),
-            "url_link": lambda x: urllib.parse.quote(x, safe=''),
-            "menu_items": app.db.get_menu_items()
+            "app_name": config.app_name,
+            "languages": languages_dict(config.languages),
+            "current_flag": flag,
+            "current_language": locale,
+            "url_link": url_link,
+            "menu_items": app.db.get_menu_items(),
+            "logo_url": app.db.get_logo_url(),
+            "font": app.db.get_font(),
+            "primary_color": app.db.get_primary_color(),
+            "secondary_color": app.db.get_secondary_color(),
         }
 
+    @app.context_processor
+    def dynamic_body():
+        return {"dynamic_body": app.dynamic_body}
+
+    @app.context_processor
+    def dynamic_head():
+        return {"dynamic_head": app.dynamic_head}
+
     @app.errorhandler(404)
     def page_not_found(e):
-        return render_template('404.html', title='404'), 404
+        return render_template("404.html", title="404"), 404
 
     return plugify(app)
+
+
+def create_app_from_config(config: Config) -> Engine:
+    engine = create_engine_from_config(config)
+    blog_blueprint = blog.create_blog_blueprint(
+        db=engine.db,
+        blog_prefix=config.blog_prefix,
+        locale_func=engine.get_locale,
+    )
+    seo_blueprint = seo.create_seo_blueprint(db=engine.db, config=engine.config)
+    engine.register_blueprint(blog_blueprint)
+    engine.register_blueprint(seo_blueprint)
+
+    Minify(app=engine, html=True, js=True, cssless=True)
+    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)