openwrite 0.13.4__tar.gz → 0.15.0__tar.gz

{openwrite-0.13.4/openwrite.egg-info → openwrite-0.15.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: openwrite
-Version: 0.13.4
+Version: 0.15.0
 License:                     GNU AFFERO GENERAL PUBLIC LICENSE
                                Version 3, 19 November 2007
         
@@ -685,6 +685,7 @@ Requires-Dist: markdown
 Requires-Dist: md2gemini
 Requires-Dist: gmcapsule
 Requires-Dist: user-agents
+Requires-Dist: redis
 Dynamic: license-file
 
 ![logo](https://openwrite.io/static/logo.png)
@@ -714,7 +715,7 @@ openwrite is a minimalist blogging platform built for writing freely, hosting in
 - Lightweight
 - No tracking, only data collected is anonymized(hashed) IP for post view counting and likes
 - Custom CSS per blog
-- Federation using ActivityPub protocol: Follow and Like
+- Federation using ActivityPub protocol
 - Likes system
 - Posts importing from xml/csv
 - Blog themes
@@ -723,6 +724,8 @@ openwrite is a minimalist blogging platform built for writing freely, hosting in
 - Multilanguage (currently English and Polish)
 - Custom favicon per blog
 - Subpages per blog
+- Valkey support
+- Post tags, filtering
 
 
 ## Installation

{openwrite-0.13.4 → openwrite-0.15.0}/README.md

@@ -25,7 +25,7 @@ openwrite is a minimalist blogging platform built for writing freely, hosting in
 - Lightweight
 - No tracking, only data collected is anonymized(hashed) IP for post view counting and likes
 - Custom CSS per blog
-- Federation using ActivityPub protocol: Follow and Like
+- Federation using ActivityPub protocol
 - Likes system
 - Posts importing from xml/csv
 - Blog themes
@@ -34,6 +34,8 @@ openwrite is a minimalist blogging platform built for writing freely, hosting in
 - Multilanguage (currently English and Polish)
 - Custom favicon per blog
 - Subpages per blog
+- Valkey support
+- Post tags, filtering
 
 
 ## Installation

{openwrite-0.13.4 → openwrite-0.15.0}/openwrite/__init__.py

@@ -25,17 +25,21 @@ def create_app(test_config=None):
         db_path = test_config.get("DB_PATH", "data.db")
         load_dotenv(test_config.get("env"), override=True)
 
+    # Always run database migrations to ensure schema is up to date
+    from .utils.create_db import init_db
+    init_db(db_type, db_path)
+    
+    # Initialize database engine and session
+    from .utils.models import User, Blog, Post, Settings, Home, Page
+    from .utils.db import init_engine, SessionLocal
+    init_engine(db_type, db_path)
+    from .utils.db import SessionLocal
+
     if not os.path.exists(".initialized") or test_config is not None:
         mode = os.getenv("MODE")
         domain = os.getenv("DOMAIN")
         f_abs_path = os.path.abspath(__file__)
         file_cwd = "/".join(f_abs_path.split("/")[:-1])
-        from .utils.create_db import init_db
-        init_db(db_type, db_path)
-        from .utils.models import User, Blog, Post, Settings, Home, Page
-        from .utils.db import init_engine, SessionLocal
-        init_engine(db_type, db_path)
-        from .utils.db import SessionLocal
         admin_password = os.urandom(16).hex()
         hashed = bcrypt.hashpw("openwrite".encode("utf-8"), bcrypt.gensalt())
         admin_user = User(username="admin", email="", password_hash=hashed.decode("utf-8"), verified=1, admin=1)
@@ -171,14 +175,10 @@ def create_app(test_config=None):
     from .routes.main import main_bp
     from .routes.upload import upload_bp
     from .routes.federation import federation_bp
-    from .utils.db import init_engine, SessionLocal
     from flask_cors import CORS
     
     CORS(app)
 
-    init_engine(db_type, db_path)    
-    from .utils.db import SessionLocal
-
     app.register_blueprint(auth_bp)
     app.register_blueprint(dashboard_bp)
     app.register_blueprint(blog_bp)
@@ -212,7 +212,7 @@ def create_app(test_config=None):
 
         trans = g.db.query(Home).filter(Home.type == "translation", Home.language == lang).all()
         
-        g.version = "0.13.3"
+        g.version = "0.15.0"
         g.mode = os.getenv("MODE")
         f_abs_path = os.path.abspath(__file__)
         g.mainpath = "/".join(f_abs_path.split("/")[:-1])

{openwrite-0.13.4 → openwrite-0.15.0}/openwrite/cli.py

@@ -100,6 +100,13 @@ def init():
     if captcha_enabled:
         captcha_sitekey = click.prompt("Friendly captcha sitekey")
         captcha_apikey = click.prompt("Friendly captcha API key")
+    valkey_enabled = click.confirm("Enable valkey (queue for likes and views)?", default=False)
+    if valkey_enabled:
+        valkey_host = click.prompt("Valkey host", default="localhost")
+        valkey_port = click.prompt("Valkey port", default="6379")
+        valkey_password = click.prompt("Valkey password(optional)", default="")
+        valkey_db = click.prompt("Valkey database", default="0")
+        valkey_interval = click.prompt("How often should valkey refresh data to DB? (minutes)", default="5")
 
         
     
@@ -145,6 +152,13 @@ def init():
         if captcha_enabled:
             f.write(f"FRIENDLY_CAPTCHA_SITEKEY={captcha_sitekey}\n")
             f.write(f"FRIENDLY_CAPTCHA_APIKEY={captcha_apikey}\n")
+        if valkey_enabled:
+            f.write(f"VALKEY_ENABLED={'yes' if valkey_enabled else 'no'}\n")
+            f.write(f"VALKEY_HOST={valkey_host}\n")
+            f.write(f"VALKEY_PORT={valkey_port}\n")
+            f.write(f"VALKEY_PASSWORD={valkey_password}\n")
+            f.write(f"VALKEY_DB={valkey_db}\n")
+            f.write(f"VALKEY_INTERVAL={valkey_interval}\n")
 
     click.echo("[+] .env file created")
     if logs_enabled and not os.path.exists(logs_dir):
@@ -185,7 +199,12 @@ def run(daemon):
         "gmcapsuled", "-c", f"{cwd}/gemini.ini"
     ]
 
+    worker_cmd = [
+        sys.executable, "-m", "openwrite.utils.worker"
+    ]
+
     gemini_log = open(os.path.join(logs_dir, "gemini.log"), "a") if logs_enabled else subprocess.PIPE
+    worker_log = open(os.path.join(logs_dir, "worker.log"), "a") if logs_enabled else subprocess.PIPE
     
     if gemini_proxy:
         gemini_cmd = gemini_cmd + ["proxy"]
@@ -193,33 +212,37 @@ def run(daemon):
     if logs_enabled:
         gunicorn_cmd = gunicorn_cmd + gunicorn_logs
 
-
     if daemon:
         click.echo(f"[+] Openwrite listening on {ip}:{port}")
         subprocess.Popen(gunicorn_cmd + ["--daemon"])
 
         if gemini:
             click.echo(f"[+] Gemini listening on {ip}:{gemini_port}")
-
             subprocess.Popen(gemini_cmd, stdout=gemini_log, stderr=subprocess.STDOUT)
 
+        click.echo("[+] Starting worker process")
+        subprocess.Popen(worker_cmd, stdout=worker_log, stderr=subprocess.STDOUT)
+
     else:
-        gunicorn_proc = subprocess.Popen(
-            gunicorn_cmd
-        )
+        gunicorn_proc = subprocess.Popen(gunicorn_cmd)
 
         if gemini:
             click.echo(f"[+] Gemini started on {ip}:{gemini_port}")
             gemini_proc = subprocess.Popen(gemini_cmd, stdout=gemini_log)
 
+        click.echo("[+] Starting worker process")
+        worker_proc = subprocess.Popen(worker_cmd, stdout=worker_log)
+
         try:
             gunicorn_proc.wait()
             if gemini:
                 gemini_proc.wait()
+            worker_proc.wait()
         except KeyboardInterrupt:
             gunicorn_proc.terminate()
             if gemini:
                 gemini_proc.terminate()
+            worker_proc.terminate()
 
 @cli.command()
 def debugrun():
@@ -286,4 +309,3 @@ def stop(service):
 
 if __name__ == "__main__":
     cli()
-

{openwrite-0.13.4 → openwrite-0.15.0}/openwrite/gemini_multi.py

@@ -22,8 +22,10 @@ def root(req):
     global session
     resp = f"```\n{openwrite_logo}\n```"
     resp += "\nopenwrite.io is a minimalist blogging platform built for writing freely, hosting independently, and publishing without noise. To create your own blog, visit:\n"
-    resp += "=> https://openwrite.io openwrite.io\n"
+    resp += "=> https://openwrite.io https://openwrite.io\n"
     resp += "In here you can read posts published.\n"
+    resp += "If you want to list all blogs (that did not disable indexing) find them in the link below:\n"
+    resp += "=> /blogs All Blogs list"
     resp += "\n## 🗞️ Latest posts:\n"
     try:
         posts = (session.query(Post).filter(Post.feed == "1", Post.isdraft == "0").order_by(Post.id.desc()).limit(10).all())
@@ -36,6 +38,20 @@ def root(req):
     finally:
         session.close()
 
+def all_blogs(req):
+    global session
+    blogs = session.query(Blog).filter_by(index='on').order_by(Blog.title).all()
+    resp = "Here you will find a list of all blogs in openwrite that did not disable their indexing:\n"
+    resp += "\n"
+    for b in blogs:
+        posts = session.query(Post).filter_by(blog=b.id).count()
+        last = session.query(Post).filter_by(blog=b.id).order_by(Post.date.desc()).first()
+        resp += f"=> /b/{b.name} {b.title} \n"
+        resp += f"Posts: {posts}\n"
+        resp += f"Last posted: {last.date if last is not None else 'never'}\n\n"
+
+    return resp
+
 def blog_index(req):                                                                           
         global session
         path = req.path
@@ -134,3 +150,7 @@ def init(capsule):
     capsule.add("/b/*",
         blog_index,
         protocol='gemini')
+
+    capsule.add("/blogs",
+                all_blogs,
+                protocol='gemini')

{openwrite-0.13.4 → openwrite-0.15.0}/openwrite/routes/auth.py

@@ -19,7 +19,7 @@ def register():
         return render_template('register.html')
 
     form_username = request.form.get('username')
-    if not re.match(r"^[a-zA-Z0-9](?:[a-zA-Z0-9_-]{1,28}[a-zA-Z0-9])?$", form_username):
+    if not re.match(r"^[a-zA-Z0-9](?:[a-zA-Z0-9_-]{1,28}[a-zA-Z0-9])+$", form_username):
         return render_template('register.html', error=g.trans['wrong_username'])
     form_password = request.form.get('password')
     form_password2 = request.form.get('password2')

{openwrite-0.13.4 → openwrite-0.15.0}/openwrite/routes/blog.py

@@ -1,6 +1,8 @@
-from flask import Blueprint, render_template, redirect, request, g, Response, abort
+from flask import Blueprint, render_template, redirect, request, g, Response, abort, send_file
 from openwrite.utils.models import Blog, Post, User, View, Like, Page
+from openwrite.utils.tags import get_post_tags, parse_tags_from_posts_syntax, get_posts_by_tags
 from openwrite.utils.helpers import gen_link, sanitize_html, anonymize, get_ip
+from openwrite.utils.valkey_client import valkey_client
 from feedgen.feed import FeedGenerator
 from sqlalchemy import desc
 import os
@@ -11,6 +13,26 @@ from datetime import timezone, datetime
 
 blog_bp = Blueprint("blog", __name__)
 
+def process_posts_content(page, blog_id, blog_url, domain):
+    posts_matches = re.findall(r'{posts[^}]*}', page.content_raw)
+    if not posts_matches:
+        return [], page.content_html
+        
+    posts_syntax = posts_matches[0]
+    tag_names = parse_tags_from_posts_syntax(posts_syntax)
+    posts = get_posts_by_tags(g.db, blog_id, tag_names)
+    
+    posts_html = ""
+    for post in posts:
+        post_url = f"{blog_url}/{post.link}"
+        posts_html += f'<div class="postlist_item"><i class="datetime">{post.date}</i> - <a href="{post_url}">{post.title}</a></div>'
+    
+    processed_content = page.content_html
+    for match in posts_matches:
+        processed_content = processed_content.replace(match, posts_html)
+        
+    return posts, processed_content
+
 def create_activity_object(post, blog, url, full_content=True):
     """Create ActivityPub object (Article or Note) based on post content length"""
     dt = datetime.strptime(str(post.date), "%Y-%m-%d %H:%M:%S")
@@ -138,11 +160,9 @@ def show_blog(blog):
     pages = g.db.query(Page).filter_by(blog=blog_obj.id).all()
     blog_obj.url = f"/b/{blog_obj.name}"
     homepage = g.db.query(Page).filter(Page.blog == blog_obj.id, Page.url == "").first()
-    if "{posts}" in homepage.content_raw:
-        posts = g.db.query(Post).filter(Post.blog == blog_obj.id, Post.isdraft == "0").order_by(desc(Post.id)).all()
-        return render_template("blog.html", blog=blog_obj, page=homepage, posts=posts, pages=pages)
-
-    return render_template("blog.html", blog=blog_obj, page=homepage, pages=pages)
+    
+    posts, processed_content = process_posts_content(homepage, blog_obj.id, blog_obj.url, g.main_domain)
+    return render_template("blog.html", blog=blog_obj, page=homepage, posts=posts, pages=pages, processed_content=processed_content)
 
 @blog_bp.route("/", subdomain="<blog>")
 def show_subblog(blog):
@@ -166,11 +186,9 @@ def show_subblog(blog):
     blog_obj.url = f"https://{blog_obj.name}.{os.getenv('DOMAIN')}"
     pages = g.db.query(Page).filter_by(blog=blog_obj.id).all()
     homepage = g.db.query(Page).filter(Page.blog == blog_obj.id, Page.url == "").first()
-    if "{posts}" in homepage.content_raw:
-        posts = g.db.query(Post).filter(Post.blog == blog_obj.id, Post.isdraft == "0").order_by(desc(Post.id)).all()
-        return render_template("blog.html", blog=blog_obj, page=homepage, posts=posts, pages=pages)
-
-    return render_template("blog.html", blog=blog_obj, page=homepage, pages=pages)
+    
+    posts, processed_content = process_posts_content(homepage, blog_obj.id, blog_obj.url, g.main_domain)
+    return render_template("blog.html", blog=blog_obj, page=homepage, posts=posts, pages=pages, processed_content=processed_content)
 
 @blog_bp.route("/b/<blog>/<post>")
 def show_post(blog, post):
@@ -181,7 +199,7 @@ def show_post(blog, post):
         return redirect("/")
 
     if post == "rss":
-        return _generate_rss(blog_obj)
+        return serve_rss(blog_obj)
 
     if blog_obj.access == "domain":
         return redirect(f"https://{blog_obj.name}.{os.getenv('DOMAIN')}/{post}")
@@ -195,11 +213,8 @@ def show_post(blog, post):
         if not page:
             return redirect("/")
 
-        if "{posts}" in page.content_raw:
-            posts = g.db.query(Post).filter(Post.blog == blog_obj.id, Post.isdraft == "0").order_by(desc(Post.id)).all()
-            return render_template("blog.html", blog=blog_obj, page=page, posts=posts, pages=pages)
-        
-        return render_template("blog.html", blog=blog_obj, page=page, pages=pages)
+        posts, processed_content = process_posts_content(page, blog_obj.id, blog_obj.url, g.main_domain)
+        return render_template("blog.html", blog=blog_obj, page=page, posts=posts, pages=pages, processed_content=processed_content)
 
     if is_activitypub_request():
         url = f"https://{g.main_domain}/b/{blog}"
@@ -215,22 +230,34 @@ def show_post(blog, post):
     blog_obj.url = f"/b/{blog_obj.name}"
 
     user_agent = request.headers.get('User-Agent')
+    ip = anonymize(get_ip())
 
     if 'Bot' not in user_agent:
-        ip = anonymize(get_ip())
         v = g.db.query(View).filter(View.blog == blog_obj.id, View.post == one_post.id, View.hash == ip).count()
         if v < 1:
-            now = datetime.now(timezone.utc).replace(microsecond=0)
-            new_view = View(blog=blog_obj.id, post=one_post.id, hash=ip, date=now, agent=user_agent)
-            g.db.add(new_view)
-            g.db.commit()
-        likes = g.db.query(Like).filter(Like.blog == blog_obj.id, Like.post == one_post.id).count()
-        one_post.likes = likes
-        liked = g.db.query(Like).filter(Like.blog == blog_obj.id, Like.post == one_post.id, Like.hash == anonymize(get_ip())).count()
-        one_post.liked = liked
+            if valkey_client.is_enabled():
+                valkey_client.queue_view(blog_obj.id, one_post.id, ip, user_agent)
+            else:
+                now = datetime.now(timezone.utc).replace(microsecond=0)
+                new_view = View(blog=blog_obj.id, post=one_post.id, hash=ip, date=now, agent=user_agent)
+                g.db.add(new_view)
+                g.db.commit()
+
+    likes_db = g.db.query(Like).filter(Like.blog == blog_obj.id, Like.post == one_post.id).count()
+    likes_queued = valkey_client.count_queued_likes(blog_obj.id, one_post.id) if valkey_client.is_enabled() else 0
+    likes = likes_db + likes_queued
+
+    liked_db = g.db.query(Like).filter(Like.blog == blog_obj.id, Like.post == one_post.id, Like.hash == ip).count()
+    liked_queued = valkey_client.check_queued_like(blog_obj.id, one_post.id, ip) if valkey_client.is_enabled() else False
+    liked = liked_db or liked_queued
+
+    one_post.likes = likes
+    one_post.liked = liked
+
+    post_tags = get_post_tags(g.db, one_post)
 
     user = g.db.query(User).filter_by(id=g.user) if g.user else None
-    return render_template("post.html", blog=blog_obj, post=one_post, user=user, views=v, likes=likes, pages=pages)
+    return render_template("post.html", blog=blog_obj, post=one_post, user=user, views=v, likes=likes, pages=pages, post_tags=post_tags)
 
 @blog_bp.route("/<post>", subdomain="<blog>")
 def show_subpost(blog, post):
@@ -241,7 +268,7 @@ def show_subpost(blog, post):
         return redirect(f"https://{os.getenv('DOMAIN')}/")
 
     if post == "rss":
-        return _generate_rss(blog_obj)
+        return serve_rss(blog_obj)
 
     if blog_obj.access == "path":
         return redirect(f"https://{os.getenv('DOMAIN')}/b/{blog_obj.name}/{post}")
@@ -256,11 +283,8 @@ def show_subpost(blog, post):
         if not page:
             return redirect("/")
 
-        if "{posts}" in page.content_raw:
-            posts = g.db.query(Post).filter(Post.blog == blog_obj.id, Post.isdraft == "0").order_by(desc(Post.id)).all()
-            return render_template("blog.html", blog=blog_obj, page=page, posts=posts, pages=pages)
-        
-        return render_template("blog.html", blog=blog_obj, page=page, pages=pages)
+        posts, processed_content = process_posts_content(page, blog_obj.id, blog_obj.url, g.main_domain)
+        return render_template("blog.html", blog=blog_obj, page=page, posts=posts, pages=pages, processed_content=processed_content)
 
     if is_activitypub_request():
         url = f"https://{blog}.{g.main_domain}"
@@ -275,24 +299,35 @@ def show_subpost(blog, post):
     one_post.authorname = post_author.username
     blog_obj.url = f"https://{blog_obj.name}.{os.getenv('DOMAIN')}"
 
-    user_agent = request.headers.get('User-Agent', '')
+    user_agent = request.headers.get('User-Agent')
+    ip = anonymize(get_ip())
+
     if 'Bot' not in user_agent:
-        ip = anonymize(get_ip())
         v = g.db.query(View).filter(View.blog == blog_obj.id, View.post == one_post.id, View.hash == ip).count()
-        user_agent = request.headers.get('User-Agent')
         if v < 1:
-            now = datetime.now(timezone.utc).replace(microsecond=0)
-            new_view = View(blog=blog_obj.id, post=one_post.id, hash=ip, date=now, agent=user_agent)
-            g.db.add(new_view)
-            g.db.commit()
+            if valkey_client.is_enabled():
+                valkey_client.queue_view(blog_obj.id, one_post.id, ip, user_agent)
+            else:
+                now = datetime.now(timezone.utc).replace(microsecond=0)
+                new_view = View(blog=blog_obj.id, post=one_post.id, hash=ip, date=now, agent=user_agent)
+                g.db.add(new_view)
+                g.db.commit()
+
+    likes_db = g.db.query(Like).filter(Like.blog == blog_obj.id, Like.post == one_post.id).count()
+    likes_queued = valkey_client.count_queued_likes(blog_obj.id, one_post.id) if valkey_client.is_enabled() else 0
+    likes = likes_db + likes_queued
+
+    liked_db = g.db.query(Like).filter(Like.blog == blog_obj.id, Like.post == one_post.id, Like.hash == ip).count()
+    liked_queued = valkey_client.check_queued_like(blog_obj.id, one_post.id, ip) if valkey_client.is_enabled() else False
+    liked = liked_db or liked_queued
 
-    likes = g.db.query(Like).filter(Like.blog == blog_obj.id, Like.post == one_post.id).count()
     one_post.likes = likes
-    liked = g.db.query(Like).filter(Like.blog == blog_obj.id, Like.post == one_post.id, Like.hash == anonymize(get_ip())).count()
     one_post.liked = liked
+ 
+    post_tags = get_post_tags(g.db, one_post)
 
     user = g.db.query(User).filter_by(id=g.user) if g.user else None
-    return render_template("post.html", blog=blog_obj, post=one_post, user=user, views=v, pages=pages)
+    return render_template("post.html", blog=blog_obj, post=one_post, user=user, views=v, likes=likes, pages=pages, post_tags=post_tags)
 
 @blog_bp.route("/.well-known/webfinger")
 def webfinger():
@@ -362,12 +397,8 @@ def single_showpost(post):
         if not page:
             return redirect("/")
 
-        if "{posts}" in page.content_raw:
-            posts = g.db.query(Post).filter(Post.blog == blog.id, Post.isdraft == "0").order_by(desc(Post.id)).all()
-
-            return render_template("blog.html", blog=blog, page=page, posts=posts, pages=pages)
-        
-        return render_template("blog.html", blog=blog, page=page, pages=pages)
+        posts, processed_content = process_posts_content(page, blog.id, blog.url, g.main_domain)
+        return render_template("blog.html", blog=blog, page=page, posts=posts, pages=pages, processed_content=processed_content)
 
     if is_activitypub_request():
         url = f"https://{g.main_domain}"
@@ -382,23 +413,34 @@ def single_showpost(post):
     one_post.authorname = post_author.username
 
     user_agent = request.headers.get('User-Agent', '')
+    ip = anonymize(get_ip())
+
     if 'Bot' not in user_agent:
-        ip = anonymize(get_ip())
-        v = g.db.query(View).filter(View.blog == 1, View.post == one_post.id, View.hash == ip).count()
-        user_agent = request.headers.get('User-Agent')
+        v = g.db.query(View).filter(View.blog == blog.id, View.post == one_post.id, View.hash == ip).count()
         if v < 1:
-            now = datetime.now(timezone.utc).replace(microsecond=0)
-            new_view = View(blog=1, post=one_post.id, hash=ip, date=now, agent=user_agent)
-            g.db.add(new_view)
-            g.db.commit()
+            if valkey_client.is_enabled():
+                valkey_client.queue_view(blog.id, one_post.id, ip, user_agent)
+            else:
+                now = datetime.now(timezone.utc).replace(microsecond=0)
+                new_view = View(blog=blog.id, post=one_post.id, hash=ip, date=now, agent=user_agent)
+                g.db.add(new_view)
+                g.db.commit()
+
+    likes_db = g.db.query(Like).filter(Like.blog == blog.id, Like.post == one_post.id).count()
+    likes_queued = valkey_client.count_queued_likes(blog.id, one_post.id) if valkey_client.is_enabled() else 0
+    likes = likes_db + likes_queued
+
+    liked_db = g.db.query(Like).filter(Like.blog == blog.id, Like.post == one_post.id, Like.hash == ip).count()
+    liked_queued = valkey_client.check_queued_like(blog.id, one_post.id, ip) if valkey_client.is_enabled() else False
+    liked = liked_db or liked_queued
 
-    likes = g.db.query(Like).filter(Like.blog == 1, Like.post == one_post.id).count()
     one_post.likes = likes
-    liked = g.db.query(Like).filter(Like.blog == 1, Like.post == one_post.id, Like.hash == anonymize(get_ip())).count()
     one_post.liked = liked
 
+    post_tags = get_post_tags(g.db, one_post)
+
     user = g.db.query(User).filter_by(id=g.user) if g.user else None
-    return render_template("post.html", blog=blog, post=one_post, user=user, views=v, pages=pages)
+    return render_template("post.html", blog=blog, post=one_post, user=user, views=v, likes=likes, pages=pages, post_tags=post_tags)
 
 @blog_bp.route("/rss")
 def single_rss():
@@ -406,7 +448,7 @@ def single_rss():
         return redirect("/")
 
     blog = g.db.query(Blog).first()
-    return _generate_rss(blog)
+    return serve_rss(blog)
 
 @blog_bp.route("/like", methods=["POST"])
 def like():
@@ -420,47 +462,45 @@ def like():
     if post < 1:
         resp = {"status": "no_post"}
         return resp, 404
+    
     ip = anonymize(get_ip())
 
-    l = g.db.query(Like).filter(Like.blog == blog_id, Like.post == post_id, Like.hash == ip).first()
-    if l:
-        g.db.delete(l)
-        g.db.commit()
+    liked_db = g.db.query(Like).filter(Like.blog == blog_id, Like.post == post_id, Like.hash == ip).first()
+    liked_queued = valkey_client.check_queued_like(blog_id, post_id, ip) if valkey_client.is_enabled() else False
+
+    if liked_db:
+        if liked_db and valkey_client.is_enabled():
+            valkey_client.queue_like(blog_id, post_id, ip, 'remove')
+        elif liked_db and not valkey_client.is_enabled():
+            g.db.delete(liked_db)
+            g.db.commit()
+
+        resp = {"status": "deleted"}
+        status = 204
+
+    elif liked_queued and valkey_client.is_enabled():
+        valkey_client.queue_like(blog_id, post_id, ip, 'remove')
+        
         resp = {"status": "deleted"}
         status = 204
     else:
-        now = datetime.now(timezone.utc).replace(microsecond=0)
-        like = Like(blog=blog_id, post=post_id, hash=ip, date=now)
-        g.db.add(like)
-        g.db.commit()
+        if valkey_client.is_enabled():
+            valkey_client.queue_like(blog_id, post_id, ip, 'add')
+        else:
+            now = datetime.now(timezone.utc).replace(microsecond=0)
+            like = Like(blog=blog_id, post=post_id, hash=ip, date=now)
+            g.db.add(like)
+            g.db.commit()
+        
         resp = {"status": "ok"}
         status = 201
-    return resp, status
     
+    return resp, status
 
-def _generate_rss(blog):
-    posts = g.db.query(Post).filter(Post.blog == blog.id, Post.isdraft == "0").all()
-    fg = FeedGenerator()
-    fg.title(blog.title)
-    
-    if blog.access == "domain":
-        blog_url = f"https://{blog.name}.{g.main_domain}"
-        post_base_url = blog_url
-    else:
-        blog_url = f"https://{g.main_domain}/b/{blog.name}"
-        post_base_url = blog_url
-    
-    fg.link(href=blog_url, rel="alternate")
-    fg.description(blog.description_html)
-
-    for p in posts:
-        soup = BeautifulSoup(p.content_html, "html.parser")
-        fe = fg.add_entry()
-        fe.title(p.title)
-        fe.link(href=f"{post_base_url}/{p.link}")
-        fe.description(soup.get_text())
-        fe.published(p.date.replace(tzinfo=timezone.utc))
-
-    return Response(fg.rss_str(pretty=True).decode("utf-8"), mimetype="application/rss+xml")
 
 
+def serve_rss(blog):
+    """
+    Here we just serve static RSS files :)
+    """
+    return send_file(f"{g.mainpath}/static/feed/{blog.name}.xml")