platzky 0.1.19__tar.gz → 0.2.1__tar.gz

platzky-0.2.1/PKG-INFO

@@ -0,0 +1,40 @@
+Metadata-Version: 2.1
+Name: platzky
+Version: 0.2.1
+Summary: Not only blog engine
+License: MIT
+Requires-Python: >=3.10,<4.0
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Requires-Dist: Flask (==3.0.3)
+Requires-Dist: Flask-Babel (>=4.0.0,<5.0.0)
+Requires-Dist: Flask-Minify (>=0.42,<0.43)
+Requires-Dist: Flask-WTF (>=1.2.1,<2.0.0)
+Requires-Dist: PyYAML (>=6.0,<7.0)
+Requires-Dist: aiohttp (>=3.9.5,<4.0.0)
+Requires-Dist: google-cloud-storage (>=2.5.0,<3.0.0)
+Requires-Dist: gql (>=3.4.0,<4.0.0)
+Requires-Dist: humanize (>=4.9.0,<5.0.0)
+Requires-Dist: pydantic (>=2.7.1,<3.0.0)
+Description-Content-Type: text/markdown
+
+![Github Actions](https://github.com/platzky/platzky/actions/workflows/tests.yml/badge.svg?event=push&branch=main)
+[![Coverage Status](https://coveralls.io/repos/github/platzky/platzky/badge.svg?branch=main)](https://coveralls.io/github/platzky/platzky?branch=main)
+
+# platzky
+
+Platzky is engine which aims to provide simple and easy way to create and run web applications in python.
+
+# How to use?
+
+1. Install platzky with your favorite dependency management tool (`pip install platzky` or `poetry add platzky`).
+2. Copy `config-template.yml` to your project directory and fill it with your data.
+3. Run `flask --app "platzky.platzky:create_app(config_path='PATH_TO_YOUR_CONFIG_FILE')`
+
+## Example
+
+For examples check e2e tests in `tests/e2e` directory and Makefile.
+

platzky-0.2.1/README.md

@@ -0,0 +1,16 @@
+![Github Actions](https://github.com/platzky/platzky/actions/workflows/tests.yml/badge.svg?event=push&branch=main)
+[![Coverage Status](https://coveralls.io/repos/github/platzky/platzky/badge.svg?branch=main)](https://coveralls.io/github/platzky/platzky?branch=main)
+
+# platzky
+
+Platzky is engine which aims to provide simple and easy way to create and run web applications in python.
+
+# How to use?
+
+1. Install platzky with your favorite dependency management tool (`pip install platzky` or `poetry add platzky`).
+2. Copy `config-template.yml` to your project directory and fill it with your data.
+3. Run `flask --app "platzky.platzky:create_app(config_path='PATH_TO_YOUR_CONFIG_FILE')`
+
+## Example
+
+For examples check e2e tests in `tests/e2e` directory and Makefile.

platzky-0.2.1/platzky/blog/blog.py

@@ -0,0 +1,93 @@
+from os.path import dirname
+
+from flask import Blueprint, make_response, render_template, request
+from markupsafe import Markup
+
+from . import comment_form
+
+
+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):
+        return Markup(text)
+
+    @blog.errorhandler(404)
+    def page_not_found(e):
+        return render_template("404.html", title="404"), 404
+
+    @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"])
+    def get_feed():
+        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"])
+    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"],
+        )
+        return get_post(post_slug=post_slug)
+
+    @blog.route("/<post_slug>", methods=["GET"])
+    def get_post(post_slug):
+        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
+        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)
+        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"])
+    def get_posts_from_tag(tag):
+        lang = locale_func()
+        posts = db.get_posts_by_tag(tag, lang)
+        return render_template("blog.html", posts=posts, subtitle=f" - tag: {tag}")
+
+    return blog

platzky-0.2.1/platzky/blog/comment_form.py

@@ -0,0 +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
+
+
+class CommentForm(FlaskForm):
+    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-0.2.1/platzky/config.py

@@ -0,0 +1,66 @@
+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
+
+
+class StrictBaseModel(BaseModel):
+    model_config = ConfigDict(frozen=True)
+
+
+class LanguageConfig(StrictBaseModel):
+    name: str = Field(alias="name")
+    flag: str = Field(alias="flag")
+    domain: t.Optional[str] = Field(default=None, alias="domain")
+
+
+Languages = dict[str, LanguageConfig]
+LanguagesMapping = t.Mapping[str, t.Mapping[str, str]]
+
+
+def languages_dict(languages: Languages) -> LanguagesMapping:
+    return {name: lang.model_dump() for name, lang in languages.items()}
+
+
+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")
+
+    @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
+        )
+
+    @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-0.2.1/platzky/db/db.py

@@ -0,0 +1,99 @@
+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_site_content(self) -> str:
+        pass
+
+
+class DBConfig(BaseModel):
+    type: str = Field(alias="TYPE")

platzky-0.2.1/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-0.2.1/platzky/db/google_json_db.py

@@ -0,0 +1,56 @@
+import json
+
+from google.cloud.storage import Client
+from pydantic import Field
+
+from .db import DBConfig
+from .json_db import Json
+
+
+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 = Client()
+    bucket = storage_client.bucket(bucket_name)
+    return bucket.blob(source_blob_name)
+
+
+def get_data(blob):
+    raw_data = blob.download_as_text(client=None)
+    return json.loads(raw_data)
+
+
+class GoogleJsonDb(Json):
+    def __init__(self, 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)
+
+        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")

{platzky-0.1.19 → platzky-0.2.1}/platzky/db/graph_ql_db.py

@@ -1,22 +1,58 @@
-#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 import Client, gql
 from gql.transport.aiohttp import AIOHTTPTransport
-import json
-from platzky.blog.db import DB
+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 get_db(config):
-    endpoint = config["DB"]["CMS_ENDPOINT"]
-    token = config["DB"]["CMS_TOKEN"]
-    return GraphQL(endpoint, token)
+
+def db_from_config(config: GraphQlDbConfig):
+    return GraphQL(config.endpoint, config.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 +60,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 +104,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 +134,16 @@ class GraphQL(DB):
                     author
                     comment
                     date: createdAt
-                }                
+                }
               }
             }
-            """)
-        return self.client.execute(post, variable_values={"slug": slug})['post']
+            """
+        )
 
-    #TODO Cleanup page logic of internationalization (now it depends on translation of slugs)
+        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)
     def get_page(self, slug):
         post = gql(
             """
@@ -96,8 +157,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,41 +179,11 @@ class GraphQL(DB):
                     }
               }
             }
-            """)
-        return self.client.execute(post, variable_values={"tag": tag, "lang": lang})['posts']
-
-    def get_all_providers(self):
-        all_providers = gql(
-            """
-            query MyQuery {
-              providers(stage: PUBLISHED) {
-                link
-                name
-                offer
-                currency
-              }
-            }
             """
         )
-        providers = self.client.execute(all_providers)["providers"]
-        for provider in providers:
-            provider["offer"] = json.loads(provider["offer"])
-        return providers
-
-    def get_all_questions(self):
-        all_questions = gql(
-            """
-            query MyQuery {
-              questions(stage: PUBLISHED) {
-                question
-                field
-                inputType
-              }
-            }
-            """
-        )
-        query = self.client.execute(all_questions)
-        return query['questions']
+        return self.client.execute(post, variable_values={"tag": tag, "lang": lang})[
+            "posts"
+        ]
 
     def add_comment(self, author_name, comment, post_slug):
         add_comment = gql(
@@ -167,7 +199,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 []