picata 0.0.6__py3-none-any.whl → 0.0.8__py3-none-any.whl

node_modules/yargs-parser/README.md

@@ -0,0 +1,396 @@
+# yargs-parser
+
+[![Build Status](https://travis-ci.org/yargs/yargs-parser.svg)](https://travis-ci.org/yargs/yargs-parser)
+[![Coverage Status](https://coveralls.io/repos/yargs/yargs-parser/badge.svg?branch=)](https://coveralls.io/r/yargs/yargs-parser?branch=master)
+[![NPM version](https://img.shields.io/npm/v/yargs-parser.svg)](https://www.npmjs.com/package/yargs-parser)
+[![Standard Version](https://img.shields.io/badge/release-standard%20version-brightgreen.svg)](https://github.com/conventional-changelog/standard-version)
+
+
+The mighty option parser used by [yargs](https://github.com/yargs/yargs).
+
+visit the [yargs website](http://yargs.js.org/) for more examples, and thorough usage instructions.
+
+<img width="250" src="https://raw.githubusercontent.com/yargs/yargs-parser/master/yargs-logo.png">
+
+## Example
+
+```sh
+npm i yargs-parser --save
+```
+
+```js
+var argv = require('yargs-parser')(process.argv.slice(2))
+console.log(argv)
+```
+
+```sh
+node example.js --foo=33 --bar hello
+{ _: [], foo: 33, bar: 'hello' }
+```
+
+_or parse a string!_
+
+```js
+var argv = require('./')('--foo=99 --bar=33')
+console.log(argv)
+```
+
+```sh
+{ _: [], foo: 99, bar: 33 }
+```
+
+Convert an array of mixed types before passing to `yargs-parser`:
+
+```js
+var parse = require('yargs-parser')
+parse(['-f', 11, '--zoom', 55].join(' '))   // <-- array to string
+parse(['-f', 11, '--zoom', 55].map(String)) // <-- array of strings
+```
+
+## API
+
+### require('yargs-parser')(args, opts={})
+
+Parses command line arguments returning a simple mapping of keys and values.
+
+**expects:**
+
+* `args`: a string or array of strings representing the options to parse.
+* `opts`: provide a set of hints indicating how `args` should be parsed:
+  * `opts.alias`: an object representing the set of aliases for a key: `{alias: {foo: ['f']}}`.
+  * `opts.array`: indicate that keys should be parsed as an array: `{array: ['foo', 'bar']}`.<br>
+    Indicate that keys should be parsed as an array and coerced to booleans / numbers:<br>
+    `{array: [{ key: 'foo', boolean: true }, {key: 'bar', number: true}]}`.
+  * `opts.boolean`: arguments should be parsed as booleans: `{boolean: ['x', 'y']}`.
+  * `opts.coerce`: provide a custom synchronous function that returns a coerced value from the argument provided
+    (or throws an error). For arrays the function is called only once for the entire array:<br>
+    `{coerce: {foo: function (arg) {return modifiedArg}}}`.
+  * `opts.config`: indicate a key that represents a path to a configuration file (this file will be loaded and parsed).
+  * `opts.configObjects`: configuration objects to parse, their properties will be set as arguments:<br>
+    `{configObjects: [{'x': 5, 'y': 33}, {'z': 44}]}`.
+  * `opts.configuration`: provide configuration options to the yargs-parser (see: [configuration](#configuration)).
+  * `opts.count`: indicate a key that should be used as a counter, e.g., `-vvv` = `{v: 3}`.
+  * `opts.default`: provide default values for keys: `{default: {x: 33, y: 'hello world!'}}`.
+  * `opts.envPrefix`: environment variables (`process.env`) with the prefix provided should be parsed.
+  * `opts.narg`: specify that a key requires `n` arguments: `{narg: {x: 2}}`.
+  * `opts.normalize`: `path.normalize()` will be applied to values set to this key.
+  * `opts.number`: keys should be treated as numbers.
+  * `opts.string`: keys should be treated as strings (even if they resemble a number `-x 33`).
+
+**returns:**
+
+* `obj`: an object representing the parsed value of `args`
+  * `key/value`: key value pairs for each argument and their aliases.
+  * `_`: an array representing the positional arguments.
+  * [optional] `--`:  an array with arguments after the end-of-options flag `--`.
+
+### require('yargs-parser').detailed(args, opts={})
+
+Parses a command line string, returning detailed information required by the
+yargs engine.
+
+**expects:**
+
+* `args`: a string or array of strings representing options to parse.
+* `opts`: provide a set of hints indicating how `args`, inputs are identical to `require('yargs-parser')(args, opts={})`.
+
+**returns:**
+
+* `argv`: an object representing the parsed value of `args`
+  * `key/value`: key value pairs for each argument and their aliases.
+  * `_`: an array representing the positional arguments.
+* `error`: populated with an error object if an exception occurred during parsing.
+* `aliases`: the inferred list of aliases built by combining lists in `opts.alias`.
+* `newAliases`: any new aliases added via camel-case expansion.
+* `configuration`: the configuration loaded from the `yargs` stanza in package.json.
+
+<a name="configuration"></a>
+
+### Configuration
+
+The yargs-parser applies several automated transformations on the keys provided
+in `args`. These features can be turned on and off using the `configuration` field
+of `opts`.
+
+```js
+var parsed = parser(['--no-dice'], {
+  configuration: {
+    'boolean-negation': false
+  }
+})
+```
+
+### short option groups
+
+* default: `true`.
+* key: `short-option-groups`.
+
+Should a group of short-options be treated as boolean flags?
+
+```sh
+node example.js -abc
+{ _: [], a: true, b: true, c: true }
+```
+
+_if disabled:_
+
+```sh
+node example.js -abc
+{ _: [], abc: true }
+```
+
+### camel-case expansion
+
+* default: `true`.
+* key: `camel-case-expansion`.
+
+Should hyphenated arguments be expanded into camel-case aliases?
+
+```sh
+node example.js --foo-bar
+{ _: [], 'foo-bar': true, fooBar: true }
+```
+
+_if disabled:_
+
+```sh
+node example.js --foo-bar
+{ _: [], 'foo-bar': true }
+```
+
+### dot-notation
+
+* default: `true`
+* key: `dot-notation`
+
+Should keys that contain `.` be treated as objects?
+
+```sh
+node example.js --foo.bar
+{ _: [], foo: { bar: true } }
+```
+
+_if disabled:_
+
+```sh
+node example.js --foo.bar
+{ _: [], "foo.bar": true }
+```
+
+### parse numbers
+
+* default: `true`
+* key: `parse-numbers`
+
+Should keys that look like numbers be treated as such?
+
+```sh
+node example.js --foo=99.3
+{ _: [], foo: 99.3 }
+```
+
+_if disabled:_
+
+```sh
+node example.js --foo=99.3
+{ _: [], foo: "99.3" }
+```
+
+### boolean negation
+
+* default: `true`
+* key: `boolean-negation`
+
+Should variables prefixed with `--no` be treated as negations?
+
+```sh
+node example.js --no-foo
+{ _: [], foo: false }
+```
+
+_if disabled:_
+
+```sh
+node example.js --no-foo
+{ _: [], "no-foo": true }
+```
+
+### combine arrays
+
+* default: `false`
+* key: `combine-arrays`
+
+Should arrays be combined when provided by both command line arguments and
+a configuration file.
+
+### duplicate arguments array
+
+* default: `true`
+* key: `duplicate-arguments-array`
+
+Should arguments be coerced into an array when duplicated:
+
+```sh
+node example.js -x 1 -x 2
+{ _: [], x: [1, 2] }
+```
+
+_if disabled:_
+
+```sh
+node example.js -x 1 -x 2
+{ _: [], x: 2 }
+```
+
+### flatten duplicate arrays
+
+* default: `true`
+* key: `flatten-duplicate-arrays`
+
+Should array arguments be coerced into a single array when duplicated:
+
+```sh
+node example.js -x 1 2 -x 3 4
+{ _: [], x: [1, 2, 3, 4] }
+```
+
+_if disabled:_
+
+```sh
+node example.js -x 1 2 -x 3 4
+{ _: [], x: [[1, 2], [3, 4]] }
+```
+
+### negation prefix
+
+* default: `no-`
+* key: `negation-prefix`
+
+The prefix to use for negated boolean variables.
+
+```sh
+node example.js --no-foo
+{ _: [], foo: false }
+```
+
+_if set to `quux`:_
+
+```sh
+node example.js --quuxfoo
+{ _: [], foo: false }
+```
+
+### populate --
+
+* default: `false`.
+* key: `populate--`
+
+Should unparsed flags be stored in `--` or `_`.
+
+_If disabled:_
+
+```sh
+node example.js a -b -- x y
+{ _: [ 'a', 'x', 'y' ], b: true }
+```
+
+_If enabled:_
+
+```sh
+node example.js a -b -- x y
+{ _: [ 'a' ], '--': [ 'x', 'y' ], b: true }
+```
+
+### set placeholder key
+
+* default: `false`.
+* key: `set-placeholder-key`.
+
+Should a placeholder be added for keys not set via the corresponding CLI argument?
+
+_If disabled:_
+
+```sh
+node example.js -a 1 -c 2
+{ _: [], a: 1, c: 2 }
+```
+
+_If enabled:_
+
+```sh
+node example.js -a 1 -c 2
+{ _: [], a: 1, b: undefined, c: 2 }
+```
+
+### halt at non-option
+
+* default: `false`.
+* key: `halt-at-non-option`.
+
+Should parsing stop at the first positional argument? This is similar to how e.g. `ssh` parses its command line.
+
+_If disabled:_
+
+```sh
+node example.js -a run b -x y
+{ _: [ 'b' ], a: 'run', x: 'y' }
+```
+
+_If enabled:_
+
+```sh
+node example.js -a run b -x y
+{ _: [ 'b', '-x', 'y' ], a: 'run' }
+```
+
+### strip aliased
+
+* default: `false`
+* key: `strip-aliased`
+
+Should aliases be removed before returning results?
+
+_If disabled:_
+
+```sh
+node example.js --test-field 1
+{ _: [], 'test-field': 1, testField: 1, 'test-alias': 1, testAlias: 1 }
+```
+
+_If enabled:_
+
+```sh
+node example.js --test-field 1
+{ _: [], 'test-field': 1, testField: 1 }
+```
+
+### strip dashed
+
+* default: `false`
+* key: `strip-dashed`
+
+Should dashed keys be removed before returning results?  This option has no effect if
+`camel-case-exansion` is disabled.
+
+_If disabled:_
+
+```sh
+node example.js --test-field 1
+{ _: [], 'test-field': 1, testField: 1 }
+```
+
+_If enabled:_
+
+```sh
+node example.js --test-field 1
+{ _: [], testField: 1 }
+```
+
+## Special Thanks
+
+The yargs project evolves from optimist and minimist. It owes its
+existence to a lot of James Halliday's hard work. Thanks [substack](https://github.com/substack) **beep** **boop** \o/
+
+## License
+
+ISC

picata/blocks.py

@@ -2,7 +2,7 @@
 
 import pygments
 from django.forms import CharField
-from django.utils.html import format_html
+from django.utils.safestring import mark_safe
 from pygments import formatters, lexers
 from pygments.util import ClassNotFound
 from wagtail.blocks import (
@@ -110,12 +110,13 @@ class CodeBlock(StructBlock):
     language = ChoiceBlock(
         required=False,
         choices=[
-            ("python", "Python"),
-            ("javascript", "JavaScript"),
-            ("html", "HTML"),
-            ("css", "CSS"),
-            ("bash", "Bash"),
             ("plaintext", "Plain Text"),
+            ("bash", "Bash"),
+            ("css", "CSS"),
+            ("html", "HTML"),
+            ("javascript", "JavaScript"),
+            ("python", "Python"),
+            ("toml", "TOML"),
         ],
         help_text=None,
     )
@@ -124,6 +125,7 @@ class CodeBlock(StructBlock):
         """Render the code block with syntax highlighting."""
         code = value.get("code", "")
         language = value.get("language", "plaintext")
+
         try:
             lexer = lexers.get_lexer_by_name(language)
             formatter = formatters.HtmlFormatter(cssclass="pygments")
@@ -131,7 +133,7 @@ class CodeBlock(StructBlock):
         except ClassNotFound:
             highlighted_code = f"<pre><code>{code}</code></pre>"
 
-        return format_html(highlighted_code)
+        return mark_safe(highlighted_code)  # noqa: S308
 
     class Meta:
         """Meta information."""

picata/helpers/wagtail.py

@@ -53,7 +53,7 @@ def filter_pages_by_type(pages: list[Page], page_type_slugs: set[str]) -> list[P
     return filtered_pages
 
 
-def page_preview_data(request: HttpRequest, page: Page) -> dict[str, str]:
+def page_preview_data(page: Page, request: HttpRequest | None) -> 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"):

picata/models.py

@@ -110,7 +110,7 @@ class BasePage(Page):
         from picata.helpers.wagtail import page_preview_data
 
         context = super().get_context(request, *args, **kwargs)
-        context.update(page_preview_data(request, self))
+        context.update(page_preview_data(self, request))
         return cast(BasePageContext, {**context})
 
     class Meta:
@@ -472,7 +472,7 @@ class HomePage(BasePage):
         from picata.helpers.wagtail import page_preview_data
 
         recent_posts = Article.objects.live_for_user(request.user).by_date()
-        recent_posts = [page_preview_data(request, post) for post in recent_posts]
+        recent_posts = [page_preview_data(post, request) for post in recent_posts]
 
         return cast(
             HomePageContext,

picata/templatetags/__init__.py

@@ -1 +1 @@
-"""Package for custom Django template tags."""
+"""Django template tags & filters for the 'picata' application."""

picata/templatetags/{kill_orphans.py → filters/kill_orphans.py}

@@ -1,13 +1,10 @@
-"""Filter to wrap the last two words of text in a span which prevents word-wrapping."""
+"""Filter to wrap the last two words of text in a span which prevents word-wrapping."""  # noqa: INP001
 
 from html.parser import HTMLParser
 
-from django import template
 from django.utils.html import escape
 from django.utils.safestring import mark_safe
 
-register = template.Library()
-
 
 class KillOrphansParser(HTMLParser):
     """Parser that wraps the last two words of visible text in a span tag."""
@@ -54,7 +51,6 @@ class KillOrphansParser(HTMLParser):
         )
 
 
-@register.filter
 def killorphans(value: str) -> str:
     """Wrap the last two words of visible text in a span tag."""
     parser = KillOrphansParser()

picata/templatetags/{stringify.py → filters/stringify.py}

@@ -1,11 +1,6 @@
-"""Filter to transform Python types into human-readable strings."""
+"""Filter to transform Python types into human-readable strings."""  # noqa: INP001
 
-from django import template
 
-register = template.Library()
-
-
-@register.filter
 def stringify(value: list, quote_style: str | None = None) -> str:
     """Convert a list of strings into a human-readable string with optional quoting."""
     if not value:

picata/templatetags/picata_tags.py

@@ -0,0 +1,18 @@
+"""Package for custom Django template tags."""
+
+from django import template
+
+from .filters.kill_orphans import killorphans
+from .filters.stringify import stringify
+from .tags.absolute_static import absolute_static
+from .tags.menu_tags import render_site_menu
+
+register = template.Library()
+
+register.filter()(killorphans)
+register.filter()(stringify)
+
+register.simple_tag(takes_context=True)(absolute_static)
+register.inclusion_tag(filename="picata/tags/site_menu.html", takes_context=True)(render_site_menu)
+
+__all__ = ["absolute_static", "killorphans", "render_site_menu", "stringify"]

picata/templatetags/{absolute_static.py → tags/absolute_static.py}

@@ -1,14 +1,10 @@
-"""Simple template tag to produce absolute URLs from static file requests."""
+"""Simple template tag to produce absolute URLs from static file requests."""  # noqa: INP001
 
-from django import template
 from django.templatetags.static import static
 
 from picata.typing import Context
 
-register = template.Library()
 
-
-@register.simple_tag(takes_context=True)
 def absolute_static(context: Context, file: str) -> str:
     """Return the absolute path to a static file."""
     request = context["request"]

picata/templatetags/{menu_tags.py → tags/menu_tags.py}

@@ -1,4 +1,4 @@
-"""Template tags for rendering menus."""
+"""Template tags for rendering menus."""  # noqa: INP001
 
 # NB: Django's meta-class shenanigans over-complicate type hinting when QuerySets get involved.
 # pyright: reportAttributeAccessIssue=false

picata/urls.py

@@ -10,7 +10,7 @@ from wagtail.contrib.sitemaps.views import sitemap
 from wagtail.documents import urls as wagtaildocs_urls
 from wagtail.images.views.serve import ServeView
 
-from picata.views import search
+from picata.views import AtomArticleFeed, RSSArticleFeed, search
 
 urlpatterns = [
     path("django-admin/", admin.site.urls),  # Django Admin
@@ -20,6 +20,8 @@ urlpatterns = [
         r"^images/([^/]*)/(\d*)/([^/]*)/[^/]*$", ServeView.as_view(), name="wagtailimages_serve"
     ),
     path("sitemap.xml", sitemap),
+    path("feeds/rss/", RSSArticleFeed(), name="rss_feed"),
+    path("feeds/atom/", AtomArticleFeed(), name="atom_feed"),
     path("search/", search, name="search"),
 ]
 

picata/views.py

@@ -4,10 +4,13 @@
 # pyright: reportAttributeAccessIssue=false, reportArgumentType=false
 
 import logging
+from datetime import datetime
 from typing import TYPE_CHECKING, NoReturn
 
+from django.contrib.syndication.views import Feed
 from django.http import HttpRequest, HttpResponse
 from django.shortcuts import render
+from django.utils.feedgenerator import Atom1Feed, Rss201rev2Feed
 
 from picata.helpers.wagtail import (
     filter_pages_by_tags,
@@ -15,7 +18,7 @@ from picata.helpers.wagtail import (
     page_preview_data,
     visible_pages_qs,
 )
-from picata.models import ArticleType
+from picata.models import Article, ArticleType
 
 if TYPE_CHECKING:
     from wagtail.query import PageQuerySet
@@ -23,6 +26,54 @@ if TYPE_CHECKING:
 logger = logging.getLogger(__name__)
 
 
+class PostsFeed(Feed):
+    """Base class for RSS and Atom article feeds."""
+
+    title = "hpk.io Articles"
+    link = "https://hpk.io/blog/"
+    description = "Latest posts on hpk.io"
+
+    def items(self) -> list[Article]:
+        """Return the latest 10 published articles."""
+        return list(Article.objects.live().order_by("-first_published_at"))
+
+    def item_title(self, item: Article) -> str:
+        """Return the article title."""
+        return item.title
+
+    def item_link(self, item: Article) -> str:
+        """Return the absolute URL for the article."""
+        return item.full_url
+
+    def item_description(self, item: Article) -> str:
+        """Return the article body as HTML with absolute URLs."""
+        return item.content
+
+    def item_pubdate(self, item: Article) -> datetime:
+        """Return the article creation date."""
+        return item.first_published_at
+
+    def item_updateddate(self, item: Article) -> datetime:
+        """Return the article creation date."""
+        return item.last_published_at
+
+    def item_author_name(self, item: Article) -> str:
+        """Return the name of the author."""
+        return "Ada Wright"
+
+
+class RSSArticleFeed(PostsFeed):
+    """RSS feed for articles."""
+
+    feed_type = Rss201rev2Feed
+
+
+class AtomArticleFeed(PostsFeed):
+    """Atom feed for articles."""
+
+    feed_type = Atom1Feed
+
+
 def debug_shell(request: HttpRequest) -> NoReturn:
     """Just `assert False`, to force an exception and get to the Werkzeug debug console."""
     logger.info(
@@ -76,6 +127,6 @@ def search(request: HttpRequest) -> HttpResponse:
         specific_pages = []
 
     # Enhance pages with preview and publication data
-    page_previews = [page_preview_data(request, page) for page in specific_pages]
+    page_previews = [page_preview_data(page, request) for page in specific_pages]
 
     return render(request, "picata/search_results.html", {**results, "pages": page_previews})

{picata-0.0.6.dist-info → picata-0.0.8.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: picata
-Version: 0.0.6
+Version: 0.0.8
 Summary: Ada's Wagtail-based CMS & blog
 Project-URL: Documentation, https://github.com/hipikat/picata#readme
 Project-URL: Issues, https://github.com/hipikat/picata/issues