picata 0.0.1__py3-none-any.whl

picata/helpers/wagtail.py

@@ -0,0 +1,61 @@
+"""Generic helper-functions."""
+# NB: Django's meta-class shenanigans over-complicate type hinting when QuerySets get involved.
+# pyright: reportAttributeAccessIssue=false
+
+from typing import cast
+
+from django.http import HttpRequest
+from wagtail.models import Page
+from wagtail.query import PageQuerySet
+
+from hpk.models import TaggedPage
+
+from . import get_models_of_type
+
+TAGGED_PAGE_TYPES = get_models_of_type(TaggedPage)
+
+
+def visible_pages_qs(request: HttpRequest) -> PageQuerySet:
+    """Return a QuerySet of all pages derived from `Page` visible to the user."""
+    pages = cast(PageQuerySet, Page.objects.all())
+    if not request.user.is_authenticated:
+        pages = pages.live()
+    return pages
+
+
+def filter_pages_by_tags(pages: list[Page], tags: set[str]) -> list[TaggedPage]:
+    """Filter a list of pages to those containing all of a list of tags."""
+    filtered_pages = []
+    for page in pages:
+        try:
+            if isinstance(page, tuple(TAGGED_PAGE_TYPES)):
+                page_tags = {tag.name for tag in page.tags.all()}
+                if set(tags).issubset(page_tags):
+                    filtered_pages.append(page)
+        except AttributeError:
+            continue
+    return filtered_pages
+
+
+def filter_pages_by_type(pages: list[Page], page_type_slugs: set[str]) -> list[Page]:
+    """Filter a list of pages to those with a `page_type` matching any of the given slugs."""
+    filtered_pages = []
+    for page in pages:
+        try:
+            if (
+                hasattr(page, "page_type")
+                and page.page_type
+                and page.page_type.slug in page_type_slugs
+            ):
+                filtered_pages.append(page)
+        except AttributeError:
+            continue
+    return filtered_pages
+
+
+def page_preview_data(request: HttpRequest, page: Page) -> dict[str, str]:
+    """Return a dictionary of available publication and preview data for a page."""
+    page_data = getattr(page, "preview_data", {}).copy()
+    if hasattr(page, "get_publication_data"):
+        page_data.update(page.get_publication_data(request))
+    return page_data

picata/log_utils.py

@@ -0,0 +1,47 @@
+"""Customisations to the global logging system and custom logging classses."""
+
+import logging
+from logging.handlers import TimedRotatingFileHandler
+
+# Define custom levels
+TRACE_LEVEL = 5
+SUCCESS_LEVEL = 25
+
+logging.addLevelName(TRACE_LEVEL, "TRACE")
+logging.addLevelName(SUCCESS_LEVEL, "SUCCESS")
+
+
+# Handlers
+
+
+class RotatingDailyFileHandler(TimedRotatingFileHandler):
+    """Rotates file logs daily at midnight, with a week of backups by default."""
+
+    def __init__(self, filename: str, backup_days: int = 7) -> None:
+        """Pass our defaults and given args to TimedRotatingFileHandler's __init__ method."""
+        super().__init__(filename, when="midnight", interval=1, backupCount=backup_days)
+
+
+# Formatters
+
+
+class FormatterWithEverything(logging.Formatter):
+    """The *most* verbose logging formatter."""
+
+    def format(self, record: logging.LogRecord) -> str:
+        """Return a ludicrously verbose log message format."""
+        verbose_message = (
+            f"LEVEL: {record.levelname}\n"
+            f"TIME: {self.formatTime(record)}\n"
+            f"LOGGER: {record.name}\n"
+            f"MODULE: {record.module}\n"
+            f"FUNC: {record.funcName}\n"
+            f"LINE: {record.lineno}\n"
+            f"PATH: {record.pathname}\n"
+            f"THREAD: {record.threadName}\n"
+            f"PROCESS: {record.process}\n"
+            f"MESSAGE: {record.getMessage()}\n"
+        )
+        if record.exc_info:
+            verbose_message += f"EXCEPTION: {self.formatException(record.exc_info)}\n"
+        return verbose_message

picata/middleware.py

@@ -0,0 +1,54 @@
+"""HTML-processing middlware; should be placed last in (at the heart of) MIDDLEWARE."""
+
+import logging
+import re
+from collections.abc import Callable
+from typing import ClassVar
+
+from django.http import HttpRequest, HttpResponse
+from lxml import etree
+
+from hpk.helpers import make_response
+
+logger = logging.getLogger(__name__)
+
+
+class HTMLProcessingMiddleware:
+    """Middleware register for text/html document transformers."""
+
+    transformers: ClassVar[list[Callable[[etree._Element], None]]] = []
+
+    def __init__(self, get_response: Callable) -> None:
+        """Standard middleware initialisation; get the get_response method."""
+        self.get_response = get_response
+
+    def __call__(self, request: HttpRequest) -> HttpResponse:
+        """Filter the response through every registered transformer function."""
+        response = self.get_response(request)
+
+        if "text/html" in response.get("Content-Type", ""):
+            doctype = self.extract_doctype(response.content.decode())
+            tree = etree.fromstring(response.content, etree.HTMLParser())  # noqa: S320
+            if tree is not None:
+                for transformer in self.transformers:
+                    transformer(tree)
+                processed_html = etree.tostring(
+                    tree,
+                    pretty_print=True,  # type: ignore [reportCallIssue]
+                    method="html",  # type: ignore [reportCallIssue]
+                    encoding=str,  # type: ignore [reportCallIssue]
+                )
+                return make_response(response, f"{doctype}\n{processed_html}")
+
+        return response
+
+    @staticmethod
+    def extract_doctype(html: str) -> str:
+        """Extract the DOCTYPE declaration from the HTML."""
+        match = re.match(r"^(<!DOCTYPE [^>]+>)", html, re.IGNORECASE)
+        return match.group(1) if match else ""
+
+    @classmethod
+    def add_transformer(cls, func: Callable[[etree._Element], None]) -> None:
+        """Add a transformation function to the global pipeline."""
+        cls.transformers.append(func)

picata/migrations/0001_initial.py

@@ -0,0 +1,264 @@
+# Generated by Django 5.1.4 on 2024-12-19 01:11
+
+import django.db.models.deletion
+import modelcluster.contrib.taggit
+import modelcluster.fields
+import wagtail.fields
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+    initial = True
+
+    dependencies = [
+        ("taggit", "0006_rename_taggeditem_content_type_object_id_taggit_tagg_content_8fc721_idx"),
+        ("wagtailcore", "0094_alter_page_locale"),
+    ]
+
+    operations = [
+        migrations.CreateModel(
+            name="Article",
+            fields=[
+                (
+                    "page_ptr",
+                    models.OneToOneField(
+                        auto_created=True,
+                        on_delete=django.db.models.deletion.CASCADE,
+                        parent_link=True,
+                        primary_key=True,
+                        serialize=False,
+                        to="wagtailcore.page",
+                    ),
+                ),
+                (
+                    "summary",
+                    wagtail.fields.RichTextField(
+                        blank=True, help_text="A short summary, or tagline for the article."
+                    ),
+                ),
+                (
+                    "content",
+                    wagtail.fields.StreamField(
+                        [("section", 5), ("image", 3)],
+                        blank=True,
+                        block_lookup={
+                            0: (
+                                "wagtail.blocks.CharBlock",
+                                (),
+                                {"help_text": "Heading for this section.", "required": True},
+                            ),
+                            1: (
+                                "wagtail.blocks.IntegerBlock",
+                                (),
+                                {
+                                    "help_text": "Heading level",
+                                    "max_value": 6,
+                                    "min_value": 1,
+                                    "required": True,
+                                },
+                            ),
+                            2: (
+                                "wagtail.blocks.RichTextBlock",
+                                (),
+                                {
+                                    "features": [
+                                        "bold",
+                                        "italic",
+                                        "link",
+                                        "ul",
+                                        "ol",
+                                        "document-link",
+                                    ]
+                                },
+                            ),
+                            3: ("wagtail.images.blocks.ImageChooserBlock", (), {}),
+                            4: (
+                                "wagtail.blocks.StreamBlock",
+                                [[("rich_text", 2), ("image", 3)]],
+                                {
+                                    "help_text": "Content blocks for this section.",
+                                    "required": False,
+                                },
+                            ),
+                            5: (
+                                "wagtail.blocks.StructBlock",
+                                [[("heading", 0), ("level", 1), ("content", 4)]],
+                                {},
+                            ),
+                        },
+                        help_text="Main content for the article.",
+                    ),
+                ),
+            ],
+            options={
+                "verbose_name": "Article",
+                "verbose_name_plural": "Articles",
+            },
+            bases=("wagtailcore.page",),
+        ),
+        migrations.CreateModel(
+            name="ArticleTag",
+            fields=[
+                (
+                    "id",
+                    models.BigAutoField(
+                        auto_created=True, primary_key=True, serialize=False, verbose_name="ID"
+                    ),
+                ),
+                ("name", models.CharField(max_length=100, unique=True, verbose_name="name")),
+                (
+                    "slug",
+                    models.SlugField(
+                        allow_unicode=True, max_length=100, unique=True, verbose_name="slug"
+                    ),
+                ),
+            ],
+            options={
+                "verbose_name": "Article Tag",
+                "verbose_name_plural": "Article Tags",
+            },
+        ),
+        migrations.CreateModel(
+            name="ArticleType",
+            fields=[
+                (
+                    "id",
+                    models.BigAutoField(
+                        auto_created=True, primary_key=True, serialize=False, verbose_name="ID"
+                    ),
+                ),
+                (
+                    "name",
+                    models.CharField(
+                        help_text="Name of the article type.", max_length=100, unique=True
+                    ),
+                ),
+                (
+                    "name_plural",
+                    models.CharField(
+                        blank=True,
+                        help_text="Plural form of the article type name (optional). Defaults to appending 's'.",  # noqa: E501
+                        max_length=100,
+                    ),
+                ),
+                ("slug", models.SlugField(max_length=100, unique=True)),
+                (
+                    "description",
+                    models.TextField(blank=True, help_text="Optional description of this type."),
+                ),
+            ],
+        ),
+        migrations.CreateModel(
+            name="BasicPage",
+            fields=[
+                (
+                    "page_ptr",
+                    models.OneToOneField(
+                        auto_created=True,
+                        on_delete=django.db.models.deletion.CASCADE,
+                        parent_link=True,
+                        primary_key=True,
+                        serialize=False,
+                        to="wagtailcore.page",
+                    ),
+                ),
+                (
+                    "content",
+                    wagtail.fields.StreamField(
+                        [("rich_text", 0), ("image", 1)],
+                        blank=True,
+                        block_lookup={
+                            0: ("wagtail.blocks.RichTextBlock", (), {}),
+                            1: ("wagtail.images.blocks.ImageChooserBlock", (), {}),
+                        },
+                        help_text="Main content for the page.",
+                    ),
+                ),
+            ],
+            options={
+                "verbose_name": "Basic Page",
+                "verbose_name_plural": "Basic Pages",
+            },
+            bases=("wagtailcore.page",),
+        ),
+        migrations.CreateModel(
+            name="PostGroupPage",
+            fields=[
+                (
+                    "page_ptr",
+                    models.OneToOneField(
+                        auto_created=True,
+                        on_delete=django.db.models.deletion.CASCADE,
+                        parent_link=True,
+                        primary_key=True,
+                        serialize=False,
+                        to="wagtailcore.page",
+                    ),
+                ),
+                (
+                    "intro",
+                    wagtail.fields.RichTextField(
+                        blank=True, help_text="An optional introduction to this group."
+                    ),
+                ),
+            ],
+            options={
+                "verbose_name": "Post Group",
+                "verbose_name_plural": "Post Groups",
+            },
+            bases=("wagtailcore.page",),
+        ),
+        migrations.CreateModel(
+            name="ArticleTagItem",
+            fields=[
+                (
+                    "id",
+                    models.BigAutoField(
+                        auto_created=True, primary_key=True, serialize=False, verbose_name="ID"
+                    ),
+                ),
+                (
+                    "content_object",
+                    modelcluster.fields.ParentalKey(
+                        on_delete=django.db.models.deletion.CASCADE,
+                        related_name="tagged_items",
+                        to="hpk.article",
+                    ),
+                ),
+                (
+                    "tag",
+                    models.ForeignKey(
+                        on_delete=django.db.models.deletion.CASCADE,
+                        related_name="%(app_label)s_%(class)s_items",
+                        to="taggit.tag",
+                    ),
+                ),
+            ],
+            options={
+                "abstract": False,
+            },
+        ),
+        migrations.AddField(
+            model_name="article",
+            name="tags",
+            field=modelcluster.contrib.taggit.ClusterTaggableManager(
+                blank=True,
+                help_text="Tags for the article.",
+                through="hpk.ArticleTagItem",
+                to="taggit.Tag",
+                verbose_name="Tags",
+            ),
+        ),
+        migrations.AddField(
+            model_name="article",
+            name="article_type",
+            field=models.ForeignKey(
+                blank=True,
+                help_text="Select the type of article.",
+                null=True,
+                on_delete=django.db.models.deletion.SET_NULL,
+                related_name="articles",
+                to="hpk.articletype",
+            ),
+        ),
+    ]

picata/migrations/0002_alter_article_content_alter_basicpage_content.py

@@ -0,0 +1,112 @@
+# Generated by Django 5.1.4 on 2024-12-19 22:18
+
+import wagtail.fields
+from django.db import migrations
+
+
+class Migration(migrations.Migration):
+    dependencies = [
+        ("hpk", "0001_initial"),
+    ]
+
+    operations = [
+        migrations.AlterField(
+            model_name="article",
+            name="content",
+            field=wagtail.fields.StreamField(
+                [("section", 5), ("code", 8), ("image", 3)],
+                blank=True,
+                block_lookup={
+                    0: (
+                        "wagtail.blocks.CharBlock",
+                        (),
+                        {"help_text": "Heading for this section.", "required": True},
+                    ),
+                    1: (
+                        "wagtail.blocks.IntegerBlock",
+                        (),
+                        {
+                            "help_text": "Heading level",
+                            "max_value": 6,
+                            "min_value": 1,
+                            "required": True,
+                        },
+                    ),
+                    2: (
+                        "wagtail.blocks.RichTextBlock",
+                        (),
+                        {"features": ["bold", "italic", "link", "ul", "ol", "document-link"]},
+                    ),
+                    3: ("wagtail.images.blocks.ImageChooserBlock", (), {}),
+                    4: (
+                        "wagtail.blocks.StreamBlock",
+                        [[("rich_text", 2), ("image", 3)]],
+                        {"help_text": "Content blocks for this section.", "required": False},
+                    ),
+                    5: (
+                        "wagtail.blocks.StructBlock",
+                        [[("heading", 0), ("level", 1), ("content", 4)]],
+                        {},
+                    ),
+                    6: (
+                        "wagtail.blocks.TextBlock",
+                        (),
+                        {"help_text": "Paste your code here.", "required": True},
+                    ),
+                    7: (
+                        "wagtail.blocks.ChoiceBlock",
+                        [],
+                        {
+                            "choices": [
+                                ("python", "Python"),
+                                ("javascript", "JavaScript"),
+                                ("html", "HTML"),
+                                ("css", "CSS"),
+                                ("bash", "Bash"),
+                                ("plaintext", "Plain Text"),
+                            ],
+                            "help_text": "Select the language for syntax highlighting.",
+                            "required": False,
+                        },
+                    ),
+                    8: ("wagtail.blocks.StructBlock", [[("code", 6), ("language", 7)]], {}),
+                },
+                help_text="Main content for the article.",
+            ),
+        ),
+        migrations.AlterField(
+            model_name="basicpage",
+            name="content",
+            field=wagtail.fields.StreamField(
+                [("rich_text", 0), ("code", 3), ("image", 4)],
+                blank=True,
+                block_lookup={
+                    0: ("wagtail.blocks.RichTextBlock", (), {}),
+                    1: (
+                        "wagtail.blocks.TextBlock",
+                        (),
+                        {"help_text": "Paste your code here.", "required": True},
+                    ),
+                    2: (
+                        "wagtail.blocks.ChoiceBlock",
+                        [],
+                        {
+                            "choices": [
+                                ("python", "Python"),
+                                ("javascript", "JavaScript"),
+                                ("html", "HTML"),
+                                ("css", "CSS"),
+                                ("bash", "Bash"),
+                                ("plaintext", "Plain Text"),
+                            ],
+                            "help_text": "Select the language for syntax highlighting.",
+                            "required": False,
+                        },
+                    ),
+                    3: ("wagtail.blocks.StructBlock", [[("code", 1), ("language", 2)]], {}),
+                    4: ("wagtail.images.blocks.ImageChooserBlock", (), {}),
+                },
+                help_text="Main content for the page.",
+            ),
+        ),
+    ]

picata/migrations/0003_alter_article_content_alter_basicpage_content.py

@@ -0,0 +1,104 @@
+# Generated by Django 5.1.4 on 2024-12-19 22:21
+
+import wagtail.fields
+from django.db import migrations
+
+
+class Migration(migrations.Migration):
+    dependencies = [
+        ("hpk", "0002_alter_article_content_alter_basicpage_content"),
+    ]
+
+    operations = [
+        migrations.AlterField(
+            model_name="article",
+            name="content",
+            field=wagtail.fields.StreamField(
+                [("section", 5), ("code", 8), ("image", 3)],
+                blank=True,
+                block_lookup={
+                    0: (
+                        "wagtail.blocks.CharBlock",
+                        (),
+                        {"help_text": "Heading for this section.", "required": True},
+                    ),
+                    1: (
+                        "wagtail.blocks.IntegerBlock",
+                        (),
+                        {
+                            "help_text": "Heading level",
+                            "max_value": 6,
+                            "min_value": 1,
+                            "required": True,
+                        },
+                    ),
+                    2: (
+                        "wagtail.blocks.RichTextBlock",
+                        (),
+                        {"features": ["bold", "italic", "link", "ul", "ol", "document-link"]},
+                    ),
+                    3: ("wagtail.images.blocks.ImageChooserBlock", (), {}),
+                    4: (
+                        "wagtail.blocks.StreamBlock",
+                        [[("rich_text", 2), ("image", 3)]],
+                        {"help_text": "Content blocks for this section.", "required": False},
+                    ),
+                    5: (
+                        "wagtail.blocks.StructBlock",
+                        [[("heading", 0), ("level", 1), ("content", 4)]],
+                        {},
+                    ),
+                    6: ("wagtail.blocks.TextBlock", (), {"help_text": None, "required": True}),
+                    7: (
+                        "wagtail.blocks.ChoiceBlock",
+                        [],
+                        {
+                            "choices": [
+                                ("python", "Python"),
+                                ("javascript", "JavaScript"),
+                                ("html", "HTML"),
+                                ("css", "CSS"),
+                                ("bash", "Bash"),
+                                ("plaintext", "Plain Text"),
+                            ],
+                            "help_text": "Select the language for syntax highlighting.",
+                            "required": False,
+                        },
+                    ),
+                    8: ("wagtail.blocks.StructBlock", [[("code", 6), ("language", 7)]], {}),
+                },
+                help_text="Main content for the article.",
+            ),
+        ),
+        migrations.AlterField(
+            model_name="basicpage",
+            name="content",
+            field=wagtail.fields.StreamField(
+                [("rich_text", 0), ("code", 3), ("image", 4)],
+                blank=True,
+                block_lookup={
+                    0: ("wagtail.blocks.RichTextBlock", (), {}),
+                    1: ("wagtail.blocks.TextBlock", (), {"help_text": None, "required": True}),
+                    2: (
+                        "wagtail.blocks.ChoiceBlock",
+                        [],
+                        {
+                            "choices": [
+                                ("python", "Python"),
+                                ("javascript", "JavaScript"),
+                                ("html", "HTML"),
+                                ("css", "CSS"),
+                                ("bash", "Bash"),
+                                ("plaintext", "Plain Text"),
+                            ],
+                            "help_text": "Select the language for syntax highlighting.",
+                            "required": False,
+                        },
+                    ),
+                    3: ("wagtail.blocks.StructBlock", [[("code", 1), ("language", 2)]], {}),
+                    4: ("wagtail.images.blocks.ImageChooserBlock", (), {}),
+                },
+                help_text="Main content for the page.",
+            ),
+        ),
+    ]