openwrite 0.13.4__tar.gz → 0.14.0__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: openwrite
-Version: 0.13.4
+Version: 0.14.0
 License:                     GNU AFFERO GENERAL PUBLIC LICENSE
                                Version 3, 19 November 2007
         
@@ -685,16 +685,17 @@ 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)
-
 openwrite is a minimalist blogging platform built for writing freely, hosting independently, and publishing without noise.
 
 ![PyPI - Downloads](https://img.shields.io/pypi/dw/openwrite)
 ![PyPI - Version](https://img.shields.io/pypi/v/openwrite)
 [![License: AGPL-3.0-or-later](https://img.shields.io/badge/License-AGPL--3.0--or--later-blue.svg)](LICENSE)
 ![pythonver](https://img.shields.io/badge/python%20version-3.11-blue)
+![GitHub Actions Workflow Status](https://img.shields.io/github/actions/workflow/status/openwriteio/openwrite/python-tests.yml)
 
 ---
 

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

@@ -1,11 +1,11 @@
 ![logo](https://openwrite.io/static/logo.png)
-
 openwrite is a minimalist blogging platform built for writing freely, hosting independently, and publishing without noise.
 
 ![PyPI - Downloads](https://img.shields.io/pypi/dw/openwrite)
 ![PyPI - Version](https://img.shields.io/pypi/v/openwrite)
 [![License: AGPL-3.0-or-later](https://img.shields.io/badge/License-AGPL--3.0--or--later-blue.svg)](LICENSE)
 ![pythonver](https://img.shields.io/badge/python%20version-3.11-blue)
+![GitHub Actions Workflow Status](https://img.shields.io/github/actions/workflow/status/openwriteio/openwrite/python-tests.yml)
 
 ---
 

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

@@ -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.14.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.14.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.14.0}/openwrite/routes/blog.py

@@ -1,6 +1,7 @@
 from flask import Blueprint, render_template, redirect, request, g, Response, abort
 from openwrite.utils.models import Blog, Post, User, View, Like, Page
 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
@@ -215,19 +216,29 @@ 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
 
     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)
@@ -275,24 +286,33 @@ 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
 
     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)
 
 @blog_bp.route("/.well-known/webfinger")
 def webfinger():
@@ -382,23 +402,32 @@ 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
 
     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)
 
 @blog_bp.route("/rss")
 def single_rss():
@@ -420,21 +449,39 @@ 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
     
 
@@ -461,6 +508,4 @@ def _generate_rss(blog):
         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")
-
-
+    return Response(fg.rss_str(pretty=True).decode("utf-8"), mimetype="application/rss+xml")

{openwrite-0.13.4 → openwrite-0.14.0}/openwrite/routes/dashboard.py

@@ -1,7 +1,8 @@
 from flask import Blueprint, render_template, redirect, request, g, abort, Response
-from openwrite.utils.models import Blog, Post, User, View, Page
+from openwrite.utils.models import Blog, Post, User, View, Like, Page
 from openwrite.utils.helpers import sanitize_html, gen_link, safe_css, send_activity, is_html, get_themes
 from openwrite.routes.blog import create_activity_object, create_person_object
+from openwrite.utils.valkey_client import valkey_client
 import requests
 from sqlalchemy import desc
 from datetime import datetime, timezone, timedelta
@@ -148,12 +149,10 @@ def delete_blog(name):
                 "cc": [f"https://{g.main_domain}/followers/{blog.name}"],
                 "object": person_object
             }
-            send_activity(
-                delete_activity,
-                blog.priv_key,
-                blog_url,
-                f"{actor}/inbox"
-            )
+            if valkey_client.is_enabled():
+                valkey_client.queue_federation_activity(delete_activity, blog.id, blog.priv_key, blog_url, f"{actor}/inbox")
+            else:
+                send_activity(delete_activity, blog.priv_key, blog_url, f"{actor}/inbox")
 
     g.db.delete(blog)
     g.db.commit()
@@ -226,15 +225,14 @@ def edit_blog(name):
                     "cc": [f"https://{g.main_domain}/followers/{blog.name}"],
                     "object": person_object
                 }
-                send_activity(
-                    update_activity,
-                    blog.priv_key,
-                    blog_url,
-                    f"{actor}/inbox"
-                )
+                if valkey_client.is_enabled():
+                    valkey_client.queue_federation_activity(update_activity, blog.id, blog.priv_key, blog_url, f"{actor}/inbox")
+                else:
+                    send_activity(update_activity, blog.priv_key, blog_url, f"{actor}/inbox")
 
     return render_template("edit.html", blog=blog, posts=posts, themes=themes, pages=pages)
 
+
 @dashboard_bp.route("/dashboard/post/<name>", methods=['GET', 'POST'])
 def new_post(name):
     if g.user is None:
@@ -306,12 +304,10 @@ def new_post(name):
                     "cc": [f"https://{g.main_domain}/followers/{blog.name}"],
                     "object": activity_object
                 }       
-                send_activity(
-                    activity,
-                    blog.priv_key,
-                    blog_url,
-                    f"{actor}/inbox"
-                )
+                if valkey_client.is_enabled():
+                    valkey_client.queue_federation_activity(activity, blog.id, blog.priv_key, blog_url, f"{actor}/inbox")
+                else:
+                    send_activity(activity, blog.priv_key, blog_url, f"{actor}/inbox")
         
     return redirect(f"/dashboard/edit/{blog.name}")
 
@@ -411,46 +407,25 @@ def edit_post(blog, post):
 
     if followers:
         activity_object = create_activity_object(p, blog_obj.name, blog_url, full_content=False)
-        if request.form.get("publish") == "1":
-            for actor in followers:
-                now_iso = datetime.now(timezone.utc).isoformat().replace("+00:00", "Z")
-                activity = {
-                    "@context": "https://www.w3.org/ns/activitystreams",
-                    "id": f"{blog_url}/{p.link}#create",
-                    "type": "Create",
-                    "actor": blog_url,
-                    "published": now_iso,
-                    "to": ["https://www.w3.org/ns/activitystreams#Public"],
-                    "cc": [f"https://{g.main_domain}/followers/{blog_obj.name}"],
-                    "object": activity_object
-                }       
-                send_activity(
-                    activity,
-                    blog_obj.priv_key,
-                    blog_url,
-                    f"{actor}/inbox"
-                )
-        else:
-            for actor in followers:
-                now_iso = datetime.now(timezone.utc).isoformat().replace("+00:00", "Z")
-                update_activity = {
-                    "@context": "https://www.w3.org/ns/activitystreams",
-                    "id": f"{blog_url}/{p.link}#update",
-                    "type": "Update",
-                    "actor": blog_url,
-                    "published": now_iso,
-                    "to": ["https://www.w3.org/ns/activitystreams#Public"],
-                    "cc": [f"https://{g.main_domain}/followers/{blog_obj.name}"],
-                    "object": activity_object
-                }
-                send_activity(
-                    update_activity,
-                    blog_obj.priv_key,
-                    blog_url,
-                    f"{actor}/inbox"
-                )
-    
-    return redirect(f"/dashboard/edit/{blog_obj.name}")
+        
+        for actor in followers:
+            now_iso = datetime.now(timezone.utc).isoformat().replace("+00:00", "Z")
+            update_activity = {
+                "@context": "https://www.w3.org/ns/activitystreams",
+                "id": f"{blog_url}/{p.link}#update",
+                "type": "Update",
+                "actor": blog_url,
+                "published": now_iso,
+                "to": ["https://www.w3.org/ns/activitystreams#Public"],
+                "cc": [f"https://{g.main_domain}/followers/{blog_obj.name}"],
+                "object": activity_object
+            }
+            if valkey_client.is_enabled():
+                valkey_client.queue_federation_activity(update_activity, blog_obj.id, blog_obj.priv_key, blog_url, f"{actor}/inbox")
+            else:
+                send_activity(update_activity, blog_obj.priv_key, blog_url, f"{actor}/inbox")
+
+    return redirect(f"/dashboard/edit/{blog}")
 
 @dashboard_bp.route("/dashboard/edit/<blog>/<post>/delete")
 def delete_post(blog, post):
@@ -487,12 +462,15 @@ def delete_post(blog, post):
                     "cc": [f"https://{g.main_domain}/followers/{blog_obj.name}"],
                     "object": activity_object
                 }
-                send_activity(
-                    delete_activity,
-                    blog_obj.priv_key,
-                    blog_url,
-                    f"{actor}/inbox"
-                )
+                if valkey_client.is_enabled():
+                    valkey_client.queue_federation_activity(delete_activity, blog_obj.id, blog_obj.priv_key, blog_url, f"{actor}/inbox")
+                else:
+                    send_activity(
+                        delete_activity,
+                        blog_obj.priv_key,
+                        blog_url,
+                        f"{actor}/inbox"
+                    )
         
         g.db.delete(p)
         g.db.commit()
@@ -500,6 +478,7 @@ def delete_post(blog, post):
     return redirect(f"/dashboard/edit/{blog_obj.name}")
 
 
+
 @dashboard_bp.route("/dashboard/changepw", methods=['GET', 'POST'])
 def changepw():
     if g.user is None: