django-rss-filter 0.1.0__py3-none-any.whl

django_rss_filter-0.1.0.dist-info/METADATA

@@ -0,0 +1,69 @@
+Metadata-Version: 2.4
+Name: django-rss-filter
+Version: 0.1.0
+Summary: Filter public RSS feeds, remove articles that contain certain keywords or categories.
+Project-URL: Homepage, https://github.com/loopwerk/django-rss-filter/issues
+Project-URL: Repository, https://github.com/loopwerk/django-rss-filter.git
+Project-URL: Issues, https://github.com/loopwerk/django-rss-filter/issues
+Author-email: Kevin Renskers <kevin@loopwerk.io>
+License-Expression: MIT
+License-File: LICENSE
+Keywords: atom,django,feed,filter,mute,rss
+Requires-Python: >=3.9
+Requires-Dist: django>=3.2.0
+Requires-Dist: fastfeedparser>=0.3.7
+Requires-Dist: feedgen>=1.0.0
+Requires-Dist: httpx>=0.28.1
+Description-Content-Type: text/markdown
+
+# django-rss-filter
+
+This is a Django app that creates filtered RSS feeds. It does this by filtering exsiting RSS feeds, removing articles that match filtered words and/or filtered categories. It's what powers https://www.rssfilter.com.
+
+It comes with one view that returns the filtered feed XML, as well as Django Admin configuration to make it possible and easy to self-host your own instance of django-rss-filter. It does not come with views to create or edit filtered feeds; this can be done using the Django Admin.
+
+## Getting started
+
+All instructions use [uv](https://docs.astral.sh/uv/), but should work just as well with pip or Poetry for example.
+
+In an existing Django project:
+
+1. Install: `uv add django-rss-filter`
+2. Add `rssfilter` to `INSTALLED_APPS`
+3. `uv run ./manage.py migrate`
+4. Include the URL config: `path("", include("rssfilter.urls"))`
+
+If you don't have a Django project yet, these are the steps to get started:
+
+1. `uv init my-django-project`
+2. `cd my-django-project`
+3. `uv add django`
+4. `uv run django-admin startproject my_django_app .`
+5. `uv run ./manage.py migrate`
+6. `uv run ./manage.py createsuperuser`
+7. `uv run ./manage.py runserver`
+
+This will get you up and running with a working Admin site at http://127.0.0.1:8000/admin/.
+
+Then follow the first four steps to add django-rss-filter to your Django project.
+
+## Example project
+
+There's an example Django project using django-rss-filter under `example/`.
+
+1. `cd example`
+2. `uv run ./manage.py migrate`
+3. `uv run ./manage.py createsuperuser`
+4. `uv run ./manage.py runserver`
+
+You can then go to http://127.0.0.1:8000/admin/ to create a feed, which you can then access at http://127.0.0.1:8000/[feed_uuid]/.
+
+## Settings
+
+There is one setting that can be configured: `RSS_FILTER_CACHE_SECONDS`. The default value is 300 (5 minutes).
+
+This setting controls how long a feed will be cached before it's fetched, filtered, and stored again.
+
+## Tests
+
+Unit tests can be run with `uv run pytest`.

django_rss_filter-0.1.0.dist-info/RECORD

@@ -0,0 +1,13 @@
+rssfilter/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+rssfilter/admin.py,sha256=BBDSbwHkBGI_mb2_kmD9FahvUtIMoeibTUMAGdmLL44,718
+rssfilter/models.py,sha256=YWuks5d-8lyUBtBoyieVCAqiJpuRqoIK5vKgFN-TAJg,2369
+rssfilter/settings.py,sha256=TfwnqH2_JKROr4y2bBXxomNUkjTVunq1hnBptk463ts,115
+rssfilter/urls.py,sha256=WFDTeS3Mb-eoKTT6VrHMsYnsC1v0vKHqnBCk_zWdX5M,143
+rssfilter/utils.py,sha256=qbQ05h7RN6tGSbO9HhohWb_ACAyeSA4fJJKDA6TNAC4,1673
+rssfilter/views.py,sha256=M_7unpE-7Kv3K6GqjAPmPP2sT72SXO5xEMNrrVmsGEg,301
+rssfilter/migrations/0001_initial.py,sha256=hJ5a15sFc-ucHQnYvLssxBDoKaDB0FPS4Efr4fHpUOI,1369
+rssfilter/migrations/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+django_rss_filter-0.1.0.dist-info/METADATA,sha256=b_huJhluOTK4Ox5fN1YhHoN2TIkzKyX7nRvKVc5t8MQ,2698
+django_rss_filter-0.1.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+django_rss_filter-0.1.0.dist-info/licenses/LICENSE,sha256=k0sRaq6OW62Sd_eEaMGgQAGJd7iscowsUr-Zfaqkilk,1060
+django_rss_filter-0.1.0.dist-info/RECORD,,

django_rss_filter-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.27.0
+Root-Is-Purelib: true
+Tag: py3-none-any

django_rss_filter-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) Loopwerk
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

rssfilter/admin.py

@@ -0,0 +1,23 @@
+from django.contrib import admin
+from django.utils.safestring import mark_safe
+
+from .models import FilteredFeed
+
+
+@admin.register(FilteredFeed)
+class FilteredFeedAdmin(admin.ModelAdmin):
+    list_display = ["id", "created", "feed_url", "filtered_words", "filtered_categories", "view"]
+    ordering = ["-id"]
+
+    def view(self, obj):
+        return mark_safe(f'<a href="{obj.get_absolute_url()}">Open</a>')
+
+    def get_form(self, request, obj=None, **kwargs):
+        if obj is None:
+            kwargs["exclude"] = ["uuid"]
+        return super().get_form(request, obj, **kwargs)
+
+    def get_readonly_fields(self, request, obj=None):
+        if obj:
+            return ["uuid"]
+        return self.readonly_fields

rssfilter/migrations/0001_initial.py

@@ -0,0 +1,36 @@
+# Generated by Django 5.1.7 on 2025-03-29 13:44
+
+import uuid
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+    initial = True
+
+    dependencies = []
+
+    operations = [
+        migrations.CreateModel(
+            name="FeedCache",
+            fields=[
+                ("id", models.BigAutoField(auto_created=True, primary_key=True, serialize=False, verbose_name="ID")),
+                ("feed_url", models.URLField(db_index=True, unique=True)),
+                ("cache_date", models.DateTimeField(null=True)),
+                ("feed_body", models.TextField()),
+            ],
+        ),
+        migrations.CreateModel(
+            name="FilteredFeed",
+            fields=[
+                ("id", models.BigAutoField(auto_created=True, primary_key=True, serialize=False, verbose_name="ID")),
+                ("uuid", models.UUIDField(default=uuid.uuid4)),
+                ("feed_url", models.URLField()),
+                ("filtered_words", models.CharField(blank=True, max_length=1024)),
+                ("filtered_categories", models.CharField(blank=True, max_length=1024)),
+                ("created", models.DateTimeField(auto_now_add=True)),
+                ("cache_date", models.DateTimeField(editable=False, null=True)),
+                ("filtered_feed_body", models.TextField(editable=False)),
+            ],
+        ),
+    ]

rssfilter/models.py

@@ -0,0 +1,67 @@
+import uuid
+from datetime import timedelta
+
+import httpx
+from django.core.exceptions import ValidationError
+from django.db import models
+from django.urls import reverse
+from django.utils import timezone
+
+from .settings import RSS_FILTER_CACHE_SECONDS
+from .utils import filter_feed, validate_feed
+
+
+class FilteredFeed(models.Model):
+    uuid = models.UUIDField(default=uuid.uuid4)
+    feed_url = models.URLField()
+    filtered_words = models.CharField(max_length=1024, blank=True)
+    filtered_categories = models.CharField(max_length=1024, blank=True)
+    created = models.DateTimeField(auto_now_add=True)
+    cache_date = models.DateTimeField(null=True, editable=False)
+    filtered_feed_body = models.TextField(editable=False)
+
+    def __str__(self):
+        return f"Feed {self.uuid}"
+
+    def clean(self):
+        super().clean()
+
+        # Make sure we have a valid feed.
+        # Let's assume it's valid if it's already in FeedCache.
+        if not FeedCache.objects.filter(feed_url=self.feed_url).exists():
+            if not validate_feed(self.feed_url):
+                raise ValidationError({"feed_url": "This doesn't seem to be a valid RSS or Atom feed"})
+
+    def get_filtered_feed_body(self) -> str:
+        five_mins_ago = timezone.now() - timedelta(seconds=RSS_FILTER_CACHE_SECONDS)
+        if self.cache_date and self.cache_date > five_mins_ago:
+            return self.filtered_feed_body
+
+        feed_cache, _created = FeedCache.objects.get_or_create(feed_url=self.feed_url)
+
+        self.filtered_feed_body = filter_feed(feed_cache.get_feed_body(), self.filtered_words, self.filtered_categories)
+        self.cache_date = timezone.now()
+        self.save()
+
+        return self.filtered_feed_body
+
+    def get_absolute_url(self):
+        return reverse("rss-filter-feed", args=[self.uuid])
+
+
+class FeedCache(models.Model):
+    feed_url = models.URLField(unique=True, db_index=True)
+    cache_date = models.DateTimeField(null=True)
+    feed_body = models.TextField()
+
+    def get_feed_body(self) -> str:
+        five_mins_ago = timezone.now() - timedelta(seconds=RSS_FILTER_CACHE_SECONDS)
+        if self.cache_date and self.cache_date > five_mins_ago:
+            return self.feed_body
+
+        r = httpx.get(self.feed_url)
+        self.feed_body = r.text
+        self.cache_date = timezone.now()
+        self.save()
+
+        return self.feed_body

rssfilter/settings.py

@@ -0,0 +1,3 @@
+from django.conf import settings
+
+RSS_FILTER_CACHE_SECONDS = getattr(settings, "RSS_FILTER_CACHE_SECONDS", 5 * 60)

rssfilter/urls.py

@@ -0,0 +1,7 @@
+from django.urls import path
+
+from .views import feed_view
+
+urlpatterns = [
+    path("<uuid:feed_uuid>", feed_view, name="rss-filter-feed"),
+]

rssfilter/utils.py

@@ -0,0 +1,46 @@
+import fastfeedparser
+from feedgen.feed import FeedGenerator
+
+
+def validate_feed(feed_url: str) -> bool:
+    try:
+        fastfeedparser.parse(feed_url)
+        return True
+    except ValueError:
+        return False
+
+
+def filter_feed(feed_body: str, filtered_words: str, filtered_categories: str) -> str:
+    feed = fastfeedparser.parse(feed_body)
+
+    fg = FeedGenerator()
+    fg.id(feed.feed.link)
+    fg.title(feed.feed.title)
+    fg.link(href=feed.feed.link)
+    fg.description(feed.feed.get("description", "Filtered feed"))
+    fg.language(feed.feed.get("language", "en"))
+    fg.updated(feed.feed.updated)
+
+    filtered_words_list = [item.strip().lower() for item in filtered_words.split(",") if item.strip()]
+    filtered_categories_list = [item.strip().lower() for item in filtered_categories.split(",") if item.strip()]
+
+    for entry in feed.entries:
+        # Check if the title contains filtered words
+        if len(filtered_words_list):
+            if any(word in entry.title.lower() for word in filtered_words_list):
+                continue
+
+        # Check if the categories/terms contain filtered categories
+        if len(filtered_categories_list) and hasattr(entry, "tags"):
+            terms = [tag["term"].lower() for tag in entry.tags]
+            if any(filtered_category in term for term in terms for filtered_category in filtered_categories_list):
+                continue
+
+        fe = fg.add_entry()
+        fe.id(entry.link)
+        fe.title(entry.title)
+        fe.link(href=entry.link)
+        fe.description(entry.get("description", ""))
+        fe.pubDate(entry.get("published", None))
+
+    return fg.atom_str(pretty=True).decode("utf-8")

rssfilter/views.py

@@ -0,0 +1,9 @@
+from django.http import HttpResponse
+from django.shortcuts import get_object_or_404
+
+from .models import FilteredFeed
+
+
+def feed_view(request, feed_uuid):
+    feed = get_object_or_404(FilteredFeed, uuid=feed_uuid)
+    return HttpResponse(feed.get_filtered_feed_body(), content_type="application/xml")