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

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)

platzky/plugin_loader.py

@@ -1,42 +1,39 @@
+import importlib.util
 import os
 import sys
-from os.path import dirname, abspath
-import importlib.util
-import pkgutil
-
-
-def get_selected_not_installed_plugins(enabled_plugins):
-    plugins_root_dir = os.path.join(dirname(abspath(__file__)), 'plugins')
-    plugins_dirs = set(os.listdir(plugins_root_dir))
-
-    return enabled_plugins - plugins_dirs
+from os.path import abspath, dirname
+
+
+def find_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_plugins(enabled_plugins):
-    plugins_dir = os.path.join(dirname(abspath(__file__)), 'plugins')
-    plugins = []
-
-    if selected_not_enabled := get_selected_not_installed_plugins(enabled_plugins):
-        raise Exception(f"Plugins {selected_not_enabled} has been selected in config, but has not been installed.")
-
-    for plugin_dir in enabled_plugins:
-        module_name = plugin_dir.removesuffix('.py')
-        spec = importlib.util.spec_from_file_location(module_name,
-                                                      os.path.join(plugins_dir, plugin_dir, "entrypoint.py"))
-        plugin = importlib.util.module_from_spec(spec)
-        sys.modules[module_name] = plugin
-        spec.loader.exec_module(plugin)
-        plugins.append(plugin)
-
-    for finder, name, ispkg in pkgutil.iter_modules():
-        if name.startswith('platzky_'):
-            plugins.append(importlib.import_module(name))
+def plugify(app):
+    """Load plugins and run their entrypoints.
+    :param app: Flask app
+    :return: Flask app
+    """
 
-    return plugins
+    plugins_data = app.db.get_plugins_data()
 
+    for plugin_data in plugins_data:
+        plugin_config = plugin_data["config"]
+        plugin_name = plugin_data["name"]
+        plugin = find_plugin(plugin_name)
+        plugin.process(app, plugin_config)
 
-def plugify(app):
-    plugins = set(app.config["PLUGINS"])
-    for plugin in find_plugins(plugins):
-        plugin.process(app)
     return app

platzky/plugins/redirections/entrypoint.py

@@ -1,17 +1,21 @@
 from flask import redirect
-from functools import partial
 from gql import gql
+from pydantic import BaseModel
 
 
-def json_get_redirections(self):
+def json_db_get_redirections(self):
     return self.data.get("redirections", {})
 
 
-def google_get_redirections(self):
+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 graphql_get_redirections(self):
+def graph_ql_db_get_redirections(self):
     redirections = gql(
         """
         query MyQuery{
@@ -22,25 +26,43 @@ def graphql_get_redirections(self):
         }
         """
     )
-    return {x['source']:x['destination'] for x in self.client.execute(redirections)['redirections']}
+    return {
+        x["source"]: x["destination"]
+        for x in self.client.execute(redirections)["redirections"]
+    }
 
 
-def get_proper_redirections(db_type):
-    redirections = {
-        "json_file": json_get_redirections,
-        "graph_ql": graphql_get_redirections,
-        "google_json": google_get_redirections
+class Redirection(BaseModel):
+    source: str
+    destiny: str
 
-    }
-    return redirections[db_type]
 
+def parse_redirections(config: dict) -> 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):
-    app.db.get_redirections = get_proper_redirections(app.config["DB"]["TYPE"])
-    redirects = app.db.get_redirections(app.db)
-    for source, destiny in redirects.items():
-        func = partial(redirect, destiny, code=301)
-        func.__name__ = f"{source}-{destiny}"
-        app.route(rule=source)(func)
 
+def process(app, config: dict) -> object:
+    redirections = parse_redirections(config)
+    setup_routes(app, redirections)
     return app

platzky/plugins/sendmail/entrypoint.py

@@ -1,10 +1,14 @@
 import smtplib
-from functools import partial
 
+from pydantic import BaseModel, Field
 
-def send_mail(sender_email, password, smtp_server, port, receiver_email, subject, message):
-    full_message = f'From: {sender_email}\nTo: {receiver_email}\nSubject: {subject}\n\n{message}'
 
+def send_mail(
+    sender_email, password, smtp_server, port, receiver_email, subject, message
+):
+    full_message = (
+        f"From: {sender_email}\nTo: {receiver_email}\nSubject: {subject}\n\n{message}"
+    )
     server = smtplib.SMTP_SSL(smtp_server, port)
     server.ehlo()
     server.login(sender_email, password)
@@ -12,11 +16,28 @@ def send_mail(sender_email, password, smtp_server, port, receiver_email, subject
     server.close()
 
 
-def process(app):
-    smtp_setup = app.config["SMTP"]
-    app.sendmail = partial(send_mail,
-                           smtp_setup["ADDRESS"],
-                           smtp_setup["PASSWORD"],
-                           smtp_setup["SERVER"],
-                           smtp_setup["PORT"])
+class SendMailConfig(BaseModel):
+    user: str = Field(alias="sender_email")
+    password: str = Field(alias="password")
+    server: str = Field(alias="smtp_server")
+    port: int = Field(alias="port")
+    receiver: str = Field(alias="receiver_email")
+    subject: str = Field(alias="subject")
+
+
+def process(app, config):
+    plugin_config = SendMailConfig.model_validate(config)
+
+    def notify(message):
+        send_mail(
+            sender_email=plugin_config.user,
+            password=plugin_config.password,
+            smtp_server=plugin_config.server,
+            port=plugin_config.port,
+            receiver_email=plugin_config.receiver,
+            subject=plugin_config.subject,
+            message=message,
+        )
+
+    app.add_notifier(notify)
     return app

platzky/seo/seo.py

@@ -1,27 +1,34 @@
+import typing as t
 import urllib.parse
 from os.path import dirname
-from flask import request, render_template, make_response, Blueprint, current_app
+from flask import Blueprint, current_app, make_response, render_template, request
 
 
-def create_seo_blueprint(db, config):
-    url_prefix = config["SEO_PREFIX"]
-    seo = Blueprint('seo', __name__, url_prefix=url_prefix, template_folder=f'{dirname(__file__)}/../templates')
-    # secure_headers = SecureHeaders()
+def create_seo_blueprint(db, config: dict[str, t.Any]):
+    seo = Blueprint(
+        "seo",
+        __name__,
+        url_prefix=config["SEO_PREFIX"],
+        template_folder=f"{dirname(__file__)}/../templates",
+    )
 
     @seo.route("/robots.txt")
     def robots():
-        robots_response = render_template("robots.txt", domain=request.host, mimetype='text/plain')
+        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
 
     @seo.route("/sitemap.xml")
     def main_sitemap():
-        if domain_to_lang := config.get("DOMAIN_TO_LANG", None):
-            domains_lang = domain_to_lang[request.host]
-            return sitemap(domains_lang)
+        if domain_to_lang := config["DOMAIN_TO_LANG"]:
+            return sitemap(domain_to_lang[request.host])
         else:
-            return sitemap(config.get("BABEL_TRANSLATION_DIRECTORIES")) #TODO should be based on localization not on config
+            return sitemap(
+                config.get("TRANSLATION_DIRECTORIES")
+            )  # TODO should be based on localization not on config
 
     def sitemap(lang):
         """
@@ -38,28 +45,31 @@ def create_seo_blueprint(db, config):
         static_urls = list()
         for rule in current_app.url_map.iter_rules():
             if not str(rule).startswith("/admin") and not str(rule).startswith("/user"):
-                if "GET" in rule.methods and len(rule.arguments) == 0:
-                    url = {
-                        "loc": f"{host_base}{str(rule)}"
-                    }
+                if (
+                    rule.methods is not None
+                    and "GET" in rule.methods
+                    and len(rule.arguments) == 0
+                ):
+                    url = {"loc": f"{host_base}{str(rule)}"}
                     static_urls.append(url)
 
         # Dynamic routes with dynamic content
         dynamic_urls = list()
         seo_posts = db.get_all_posts(lang)
         for post in seo_posts:
-            slug = post['slug']
-            datet = post['date'].split('T')[0]
-            url = {
-                "loc": f"{host_base}/{slug}",
-                "lastmod": datet
-            }
+            slug = post["slug"]
+            datet = post["date"].split("T")[0]
+            url = {"loc": f"{host_base}/{slug}", "lastmod": datet}
             dynamic_urls.append(url)
 
-        statics = list({v['loc']: v for v in static_urls}.values())
-        dynamics = list({v['loc']: v for v in dynamic_urls}.values())
-        xml_sitemap = render_template("sitemap.xml", static_urls=statics, dynamic_urls=dynamics,
-                                      host_base=host_base)
+        statics = list({v["loc"]: v for v in static_urls}.values())
+        dynamics = list({v["loc"]: v for v in dynamic_urls}.values())
+        xml_sitemap = render_template(
+            "sitemap.xml",
+            static_urls=statics,
+            dynamic_urls=dynamics,
+            host_base=host_base,
+        )
         response = make_response(xml_sitemap)
         response.headers["Content-Type"] = "application/xml"
         return response

platzky/static/blog.css

@@ -81,29 +81,22 @@ img::-moz-selection {
     background: transparent;
 }
 
-#mainNav {
-#    position: absolute;
-#    border-bottom: 1px solid #e9ecef;
-#    background-color: white;
-    font-family: 'Open Sans', 'Helvetica Neue', Helvetica, Arial, sans-serif;
-}
-
 #mainNav .navbar-brand {
-    font-weight: 800;
+    font-weight: 1000;
     color: #343a40;
 }
 
 #mainNav .navbar-toggler {
-    font-size: 12px;
+    font-size: 20px;
     font-weight: 800;
-    padding: 13px;
+    padding: 10px;
     text-transform: uppercase;
     color: #343a40;
 }
 
 #mainNav .navbar-nav > li.nav-item > a {
-    font-size: 12px;
-    font-weight: 800;
+    font-size: 15px;
+    font-weight: 1000;
     letter-spacing: 1px;
     text-transform: uppercase;
 }