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

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 []

platzky/db/json_db.py

@@ -1,46 +1,104 @@
-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_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_all_providers(self):
-        return self.data["providers"]
+    def get_font(self) -> str:
+        return self.get_site_content().get("font", "")
 
-    def get_all_questions(self):
-        return self.data["questions"]
+    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