Posts tagged: markata

Share To Plaindown

2026-08-12T22:00:59Z

New workflow unlocked, sharing images and links straight to plaindown on my phone.

I’ve been working on my own markdown editor, yes I know making your own cms is a trap I’m crazy. Today I unlocked the ability to share images and links to post as shot posts or link posts. The video above created Nvim Cap Installed

Installed a new nvim cap

helix markata go lsp

2026-07-28T22:21:13Z

Helix has got to have one of the easiest configurations. It is this easy to get the markata-go lsp in helix.

markata-go lsp setup --editor helix
# Helix languages.toml (usually ~/.config/helix/languages.toml)
[language-server.markata-go]
command = "markata-go"
args = ["lsp"]

[[language]]
name = "markdown"
language-servers = ["markata-go"]

Mentions

2026-01-24T19:11:15Z

I can now just mention people from my markata Waylon Walker Blogroll like @simonwillison or @swyx.io

/now /now /now

Late Night Linux – Episode 335 - YouTube

2025-05-27T07:31:53Z

Markata got a shout out part way through the latest episode of LNL, I will go back, re-listen and take some of the feedback. His thoughts on Markata were interesting. On one hand it really is a thing for me that works for me, and as a person with too many side projects I don’t have the focus to really give it polish. On the other hand it really confirms why listen to podcasts, news, finger on the pulse, opinions and how often these guys are wrong, they are not the expert they probably look at 6 things like this a week. He said that it was some sort of javascript thing, that maybe he could fix or customize with javascript if he wanted, kinda shocking, I thought maybe I accidentally added node modules or something dumb, nope, I have a whopping 1.4% js. So most of the comments were plain wrong. I get it he probably peeked at it for 30s and realized it wasn’t the thing for his problem. At the same time I should probably do a better job at marketing what it really is, cleaning up the docs and demo.

m9a devlog 1

2025-05-11T09:33:44Z

It’s sad to see textualize.io close the doors, but textual is still alive and maintained as a n open source project. I tried to use it very early, and struggled, this was before docs and tutorials really existed, before a lot of the widgets and components existed. Then as we all do I got busy and moved on to other things in life and did not have the capacity to build TUIs.

I like tuis #

I like tuis, I like staying in the terminal. I use lf daily to move files around when I want something more than mv and cp. I use k9s hourly to monitor and manage my kubernetes cluster.

Are they worth the effort?? #

As awesome as tui’s are, they are more effort to build, and less automatable. I feel like the first stage into automation of a project really needs to be a good cli, and this is often good enough for the project and I move on.

m9a (em - nine - ah) #

inspired by k9s

Like I said I really like k9s and use it all the time, It really makes running kubectl commands a breeze and much less verbose. I don’t know how useful this will be, but as a learning exercise I am working on a k9s experience for my blog generator markata.

m9a-1-trimmed.webm

Learning #

So far this is just for learning and not quite the most useful thing, I am not sure if there is a way to do it, but I am interested in the idea of some sort of framework (maybe just widgets) that can more easily turn pydantic objects into this kind of tui. I don’t quite know how it would work, or if it could work, for now just exploring the idea, and I think I hit a fairly crude clone of k9s so far.

Markata list posts by year

2025-05-01T22:35:47Z

I was looking back at my analytics page today and wondered what were my posts about back at the beginning. My blog is managed by markata so I looked at a few ways you could pull those posts up. Turns out it’s pretty simple to do, use the markata map with a filter.

from markata import Markata

m.map('title, slug, date', filter='date.year==2016', sort='date')

Note

the filter is python eval that should evaluate to a boolean, all of the attributes of the post are available to filter on.

Result #

[
    ('⭐ jupyterlab jupyterlab', 'jupyterlab-jupyterlab', datetime.date(2016, 12, 13)),
    ('⭐ nickhould tidy-data-python', 'nickhould-tidy-data-python', datetime.date(2016, 12, 9)),
    (
        '⭐ mikeckennedy write-pythonic-code-demos',
        'mikeckennedy-write-pythonic-code-demos',
        datetime.date(2016, 11, 22)
    ),
    (
        '⭐ mikeckennedy write-pythonic-code-for-better-data-science-webcast',
        'mikeckennedy-write-pythonic-code-for-better-data-science-webcast',
        datetime.date(2016, 11, 22)
    ),
    ('⭐ rajshah4 dlgroup', 'rajshah4-dlgroup', datetime.date(2016, 11, 18)),
    ('⭐ pandas-dev pandas', 'pandas-dev-pandas', datetime.date(2016, 10, 5))
]

You could use the list command as well right within your shell and the same map and filters work.

⬢ [devtainer-0.1.3] ❯ markata list --map title --filter='date.year==2016'
[22:35:06] 2088/2145 posts skipped                                                                       skip.py:36
           57/2145 posts not skipped                                                                     skip.py:37

⭐ pandas-dev pandas
⭐ rajshah4 dlgroup
⭐ mikeckennedy write-pythonic-code-for-better-data-science-webcast
⭐ mikeckennedy write-pythonic-code-demos
⭐ nickhould tidy-data-python
⭐ jupyterlab jupyterlab

You could also do it with jin right inside of a markdown post using the jinja_md plugin.

{% for post in core.Filter("published==true and date!=nil") %}
{% if post.Date.Year() == 2016 %}
* [{{ post.Title }}]({{ post.Href }}) - {{ post.Date.Format("2006-01-02") }}
{% endif %}
{% endfor %}

Note

You do have to jinja: true in the frontmatter of the post.

Result #

The snippet lists each published post dated 2016. I keep those posts in the [[ archive ]].

markata 0.8.0

2025-01-31T20:17:00Z

I realize that I never did a post on markata 0.8.0, so here it is. 0.8.0 was released on Jan 2, 2024, just over a year ago at this point. This was the release that we got pydantic support, and multi feeds.

Pydantic Support Was kinda big #

Markata is leaning on pydantic for configuration and Post models. These models are filled with validators such that you can give it an empty markdown post and it will figure out some pretty sane default values for the frontmatter. From there you can progressively enhance your post with more information like title, date, tags, slug, description.

validators are awesome!! for instance I don’t set the description on many of my posts by hand, I let the auto_description grab the first bit of text from the post most of the time.

Multi Feeds #

Markata==0.8.1 brought multiple feeds into the mix, and started to take place of RSS and sitemap. Feeds are a list of posts that are configured with a slug, filter, sort, reverse, description, and a template. These feeds then become objects you can use to access posts, as well as html pages, RSS feeds and sitemaps.

Jinja Templates #

The final major change within this series is the change out from string templates to proper jinja templates with partial templates that you can include. This has made maintaining templates much easier, as well as the ability to customize. Markata will load templates from both your local templates directory then from its built in templates directory if it does not find a template locally.

[[markata.feeds]]
slug = 'python'
filter = "date<=today and 'python' in str(tags).lower()"
sort = "date"
reverse = true
description = 'A feed of all my python posts'

Directly from the release notes #

The rest of the post is details directly from the release notes.

0.8.2 #

Fix: markata installs setuptools required by one dependency
Fix: cleanup cli output
Fix: speed up cli startup with some lazy imports
Fix: all cache.adds were replaced with cache.set
Fix: Updated to new typer format requiring name=
Fix: teardown only runs if the build process was started, i.e. some cli’s will not need to teardown

0.8.1 #

Feeds have partials #

The feeds plugin now has configurable partial_template that can be used to render only the inside of the feeds page. This is indented to allow you to load small feeds into a page with htmx.

Better Jinja Templates #

Markata now fully supports jinja templates with a loader that will load from your templates directory, the markata built-in templates, and from a dynamically generated templates directory in your .markata.cache directory.

cli #

You can list out your templates and configuration with the following command

markata templates show

Variables #

The following variables are available within jinja templates for post templates. This is now consistent across all three built in plugins that render jinja templates.

post_template

__version__ - the version of markata
markata - the markata instance
config - the markata config
body - the body of the post
post - the current post object

feeds

Similarly from within rendering feeds.

__version__ - the version of markata
markata - the markata instance
config - the markata config
posts - the list of posts
post - a pseudo post object with title, slug, description, and date for template consistency
feed - the current feed object

jinja_md

Similar to posts from within jinja_md to render a markdown post as a template.

__version__ - the version of markata
markata - the markata instance
body - the body of the post
config - the markata config
post - the current post object

Feeds cli #

The feeds cli will help show which templates each feed will be using.

❯ markata feeds show
                                          Feeds 6
┏━━━━━━━━━━━━━━━━━┳━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┓
┃            Feed ┃ posts ┃ config                                                        ┃
┡━━━━━━━━━━━━━━━━━╇━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┩
│ project_gallery │ 2     │ DEFAULT_TITLE: All Posts                                      │
│                 │       │ title: Project Gallery                                        │
│                 │       │ slug: project-gallery                                         │
│                 │       │ name: project_gallery                                         │
│                 │       │ filter: 'project-gallery' in str(path)                        │
│                 │       │ sort: title                                                   │
│                 │       │ reverse: False                                                │
│                 │       │ rss: True                                                     │
│                 │       │ sitemap: True                                                 │
│                 │       │ card_template: card.html                                      │
│                 │       │ template: feed.html                                           │
│                 │       │ rss_template: rss.xml                                         │
│                 │       │ sitemap_template: sitemap.xml                                 │
│                 │       │ xsl_template: rss.xsl                                         │
│                 │       │                                                               │
│            docs │ 10    │ DEFAULT_TITLE: All Posts                                      │
│                 │       │ title: Documentation                                          │
│                 │       │ slug: docs                                                    │
│                 │       │ name: docs                                                    │
│                 │       │ filter: "markata" not in slug and "tests" not in slug and ... │
│                 │       │ sort: slug                                                    │
│                 │       │ reverse: False                                                │
│                 │       │ rss: True                                                     │
│                 │       │ sitemap: True                                                 │
│                 │       │ card_template: card.html                                      │
│                 │       │ template: feed.html                                           │
│                 │       │ rss_template: rss.xml                                         │
│                 │       │ sitemap_template: sitemap.xml                                 │
│                 │       │ xsl_template: rss.xsl                                         │
│                 │       │                                                               │
│         autodoc │ 17    │ DEFAULT_TITLE: All Posts                                      │
│                 │       │ title: AutoDoc Python Modules.                                │
│                 │       │ slug: autodoc                                                 │
│                 │       │ name: autodoc                                                 │
│                 │       │ filter: "markata" in slug and "plugin" not in slug and "te... │
│                 │       │ sort: slug                                                    │
│                 │       │ reverse: False                                                │
│                 │       │ rss: True                                                     │
│                 │       │ sitemap: True                                                 │
│                 │       │ card_template: card.html                                      │
│                 │       │ template: feed.html                                           │
│                 │       │ rss_template: rss.xml                                         │
│                 │       │ sitemap_template: sitemap.xml                                 │
│                 │       │ xsl_template: rss.xsl                                         │
│                 │       │                                                               │
│             all │ 73    │ DEFAULT_TITLE: All Posts                                      │
│                 │       │ title: All Markata Modules                                    │
│                 │       │ slug: all                                                     │
│                 │       │ name: all                                                     │
│                 │       │ filter: True                                                  │
│                 │       │ sort: date                                                    │
│                 │       │ reverse: False                                                │
│                 │       │ rss: True                                                     │
│                 │       │ sitemap: True                                                 │
│                 │       │ card_template: card.html                                      │
│                 │       │ template: feed.html                                           │
│                 │       │ rss_template: rss.xml                                         │
│                 │       │ sitemap_template: sitemap.xml                                 │
│                 │       │ xsl_template: rss.xsl                                         │
│                 │       │                                                               │
│    core_modules │ 17    │ DEFAULT_TITLE: All Posts                                      │
│                 │       │ title: Markata Core Modules                                   │
│                 │       │ slug: core_modules                                            │
│                 │       │ name: core_modules                                            │
│                 │       │ filter: 'plugin' not in slug and 'test' not in slug and ti... │
│                 │       │ sort: date                                                    │
│                 │       │ reverse: False                                                │
│                 │       │ rss: True                                                     │
│                 │       │ sitemap: True                                                 │
│                 │       │ card_template: card.html                                      │
│                 │       │ template: feed.html                                           │
│                 │       │ rss_template: rss.xml                                         │
│                 │       │ sitemap_template: sitemap.xml                                 │
│                 │       │ xsl_template: rss.xsl                                         │
│                 │       │                                                               │
│         plugins │ 42    │ DEFAULT_TITLE: All Posts                                      │
│                 │       │ title: Markata Plugins                                        │
│                 │       │ slug: plugins                                                 │
│                 │       │ name: plugins                                                 │
│                 │       │ filter: 'plugin' in slug and 'test' not in slug               │
│                 │       │ sort: date                                                    │
│                 │       │ reverse: False                                                │
│                 │       │ rss: True                                                     │
│                 │       │ sitemap: True                                                 │
│                 │       │ card_template: card.html                                      │
│                 │       │ template: feed.html                                           │
│                 │       │ rss_template: rss.xml                                         │
│                 │       │ sitemap_template: sitemap.xml                                 │
│                 │       │ xsl_template: rss.xsl                                         │
│                 │       │                                                               │
└─────────────────┴───────┴───────────────────────────────────────────────────────────────┘

0.8.0 #

pydantic support

Pydantic Support #

Now plugins are configured through a pydantic Config object.

breaking changes #

There are a number of breaking changes going into 0.8.0. Use caution when upgrading.

glob config is now under markata.glob #

- [markata]
- glob_patterns = "pages/**/*.md"
+ [markata.glob]
+ glob_patterns = "pages/**/*.md"

Feeds are now a list #

Feeds are now a list of Objects within the configuration that you choose from whether its toml or yaml. Also templates_dir is now configurable, and once you have a templates dir it is better to specify templates by name relative to your templates_dir.

[markata]
templates_dir = "pages/templates"

[markata.feeds.published]
template="archive_template.html"
card_template = "feed_card.html"
filter="date<=today and templateKey in ['blog-post', 'til'] and status.lower()=='published'"
sort="date"

old

[[markata.feeds.published]]
template="pages/templates/archive_template.html"
card_template = "pages/templates/feed_card.html"
filter="date<=today and templateKey in ['blog-post', 'til'] and status.lower()=='published'"
sort="date"

new

markata.summary.filter_count is now a list #

The old way was to set up a dict, where the keys were the name, now its a list of Objects with an explicit name field.

[markata.summary.filter_count.drafts]
filter="published == 'False'"
color='red'

Old

[[markata.summary.filter_count]]
name='drafts'
filter="published == 'False'"
color='red'

markata search

2025-01-30T20:21:36Z

A side effect of Markata DidYouMean is that we are able to implement some rudimentary search based on slug, title, tags, and description.

I made a video of the early work on using this side effect to search for content on markata.dev.

Replay markata-search-1.mp4

This was first implemented to solve 404 pages giving users a way to try to find the page that they tried to access. But it turned out to be a decent way to search through the docs.

My Reader Project

2024-07-07T10:24:28Z

In 2024 I built my own reader after years of being bitter about google killing reader more than a decade prior.

Seealso

All the way back in 2020 I made a post on what I wanted to build into my own reader. It went long forgotten until I tried to make this post and slugs clashed. Reader-2020

Built on markata #

I built it on top of my own static site generator markata, feedparser (🐍 Parsing RSS feeds with Python), some jinja templating, and tailwind.

After putting all the work I have into markata, it makes projects like this fairly easy to build out with just a custom loader to load new posts in.

I’ve added htmx to my blog

2024-06-15T20:50:12Z

I’ve added htmx to my blog. It’s extra bloatware that I long avoided, but it’s so damn convenient.

Ok so it’s not bloatware, but it’s not the theme I was going for. I wanted my site to be as lightweight as possible. I had at one point gone too far and had Mb’s of react that did not provide any value for the end user.

can it be done with jinja #

<div>
{% with feed = markata.feeds.recent_thoughts %}
{% include 'feed_sm_partial.html' %}
{% endwith %}
</div>

Feed Partials #

markata pre-release 0.8.1.dev10 has been released with support for feed partials on pypi.

It’s now part of my blog #

Commit aa233 added support for recent posts on each page to be loaded off of this partial.

Latest Page in Markata

2024-06-01T21:01:26Z

I just implemented a latest blog post link in Markata by asking for the first post slug from the blog feed. The implementation uses the jinja_md plugin to render jinja against the markdown and a tag to redirect.

My latest blog post is [[ {{ markata.feeds.blog.posts[0].slug }} ]].  Click the
link if you are not automatically redirected.

<meta http-equiv="Refresh" content="0; url='/{{ markata.feeds.blog.posts[0].slug }}'" />

Setting up the feed #

Feeds are setup in markata.toml configuration. They provide a handy way to create an html feed, rss feed, and quickly reference a filtered set of posts like this.

# you will need to enable the jinja_md plugin along with the defaults
[markata]
hooks = [
    "markata.plugins.jinja_md",
    "default",
    ]

# set up the blog feed
[[markata.feeds]]
slug = 'blog'
template = "feed.html"
filter = "date<=today and templateKey in ['blog-post'] and published"
sort = "date"
reverse = true

For more information on markata check out the full markata post.

markata

2024-05-30T13:45:54Z

This post is a work in progress.

Markata is the static site generator that I created to build my website about this site. I built it for me and I enjoy using it. I know everying it can do and I can extend it to do more easily. I have set it up for some friends to also use it and am proud that it helps them publish their content.

It’s a meme to create your own static site generator to make your website. Yes its funny, I don’t recommend it if your not ready for the level of work that comes with it, but at the end of the day it’s very rewarding and a great way to learn.

Static Sites were all the rage #

JAMStack was 🔥

Gatsby and Next.js hit the scene as the next generation of static site builders and were getting big around the time I started building my site in 2017. They were based on react. I dove into react and learned it enough to build my website, but I really lacked the depth of knowledge in the js ecosystem to really work on it effectively. For instance when it got slow, it was hard for me to profile and find out why. What I really wanted was my site written in python, which I knew the ecosystem for very well, but I did not find the existing site generators easy to extend to do the things I needed. Naively I thought it would be easier to just build my own than learn how to make one do what I wanted it to. Not invented here syndrome hitting hard.

In their Defense

I really lacked the depth of knowledge in the js ecosystem to really work on it (gatsby) effectively.

Plugins all the way down #

I started building this as I dove deeper into the Kedro framework for Data Engineering pipelines. They use a plugin framework for allowing users to extend it called pluggy. I had a great experience extending kedro using pluggy and wanted to build something with based on pluggy when I had started markata.

A Minimal Pluggy Example

Markata GitHub Pages

2022-10-19T18:03:31Z

11ty https://www.rockyourcode.com/how-to-deploy-eleventy-to-github-pages-with-github-actions/
hugo puts it in the base url https://gohugo.io/getting-started/configuration/#baseurl
mkdocs uses a special cli build command https://squidfunk.github.io/mkdocs-material/publishing-your-site/#github-pages

Markata Supports Jinja Plugins 0.5.0.dev2

2022-10-11T14:34:35Z

Markata now allows you to create jinja extensions that will be loaded right in with nothing more than a pip install.

From the Changelog #

The entry for 0.5.0.dev2 from markata’s changelog

Created entrypoint hook allowing for users to extend marka with jinja exensions #60 0.5.0.dev2

markata-gh #

The first example that you can use right now is markata-gh. It will render repos by GitHub topic and user using the gh cli, which is available in github actions!

Get it with a pip install

pip install markata-gh

Use it with some jinja in your markdown.

## Markata plugins

It uses the logged in uer by default.

{% gh_repo_list_topic "markata" %}

You can more explicitly grab your username, and a topic.
{% gh_repo_list_topic "waylonwalker", "personal-website" %}

How is this achieved #

The jinja extension details are for another post, but this is how markata-gh exposes itslef as a jinja extension.

class GhRepoListTopic(Extension):
    tags = {"gh_repo_list_topic"}

    def __init__(self, environment):
        super().__init__(environment)

    def parse(self, parser):
        line_number = next(parser.stream).lineno
        try:
            args = parser.parse_tuple().items
        except AttributeError:
            raise AttributeError(
                "Invalid Syntax gh_repo_list_topic expects <username>, or <username>,<topic> both must have the comma"
            )

        return nodes.CallBlock(self.call_method("run", args), [], [], "").set_lineno(
            line_number
        )

    def run(self, username=None, topic=None, caller=None):
        "get's markdown to inject into post"
        return repo_md(username=username, topic=topic)

Entrypoints #

Then markata-gh exposes itself as an extension through entrypoints.

Creating entrypoints in pyproject.toml #

If your project is using pyproject.toml for packaging you can setup an entrypoint as follows.

[project.entry-points."markata.jinja_md"]
markta_gh = "markata_gh.repo_list:GhRepoListTopic"

Creating entrypoints in setup.py #

If your project is using setup.py for packaging you can setup an entrypoint as follows.

setup(
    ...
    entry_points={
        "markata.jinja_md": ["markta_gh" = "markata_gh.repo_list:GhRepoListTopic"]
    },
    ...
)

Markata now uses hatch

2022-10-08T07:25:10Z

Markata now uses hatch as its build backend, and version bumping tool. setup.py, and setup.cfg are completely gone.

0.5.0 is big #

Markata 0.5.0 is now out, and it’s huge. Even though it’s the backend of this blog I don’t actually have that many posts directly about it. I’ve used it a bit for blog fuel in generic ways, like talking about pluggy and diskcache, but very little have I even mentioned it.

Over the last month I made a big push to get 0.5.0 out, which adds a whole bunch of new configurability to markata.

Here’s the changelog entry.

Moved to PEP 517 build #59 0.5.0.dev1

My Personal Simple CI/CD #

Before cutting all of my personal projects over to hatch. The first thing I did was to setup a solid github action, hatch-actionthat I can resue.

It automatically bumps versions, using pre-releases on all branches other than main, with special branches for bumping major, minor, patch, dev, alha, beta, and dev.

hatch new –init #

To convert the project over to hatch, and get rid of setup.py/setup.cfg, I ran hatch new --init. This automatically grabs all the metadata for the project and makes a pyproject.toml that has most of what I need.

hatch new --init

I then manually moved over my isort config, put flake8 config into .flake8, and dropped setup.cfg.

lint-test #

Part of my hatch-action is to run a before-command, for markata, this runs all of my linting and testing in one hatch script called lint-test. If this fails CI will fail and I can read the report in the logs, make a fix and re-publish.

[tool.hatch.envs.default.scripts]
cov = "pytest --cov-report=term-missing --cov-config=pyproject.toml --cov=markata --cov=tests"
no-cov = "cov --no-cov"
lint = "flake8 markata"
format = "black --check markata"
sort-imports = "isort markata"
build-docs = "markata build"
lint-test = [
 "lint",
 "format",
 "seed-isort-config",
 "sort-imports",
 "cov",
]
test-lint = "lint-test"

Typical branching workflow #

with automatic versioning

My typical workflow is to work on features in their own branch where they do not automatically version or publish, they keep the same version they were branched off of. Then I do a pr to develop, which will do a minor,dev bump and publish a pre-relese to pypi.

# starting with version 0.0.0
Feature1 -- │
Feature2 -- ├── dev 0.1.0.dev1,2,3 ── main 0.1.0
Feature3 -- │

I will let several features collect in develop before cutting a full relese over to main. This gives me time to make sure the solution is what makes the most sense, I try to use it in a few projects, and generally its edges show, and another pr is warranted to make the feature useful for more use cases. After running and using these new releases in a few projects, I am confident that its ready and release to main.

managing prs #

Doing PR’s with gh, probably deserves its own post but here are some helpful commands.

gh pr create --base develop --fill
gh pr edit
gh pr diff | dunk
gh pr merge -ds

Building and publishing #

hatch makes building and publishing pretty straightforward. It’s one command inside my hatch-action to build and one to publish. On each project that uses my hatch-action I only need to give it a token that I get from PyPi.

env:
  HATCH_INDEX_USER: __token__
  HATCH_INDEX_AUTH: ${{ secrets.pypi_password }}

Full set of changes #

If you want to see all of the details on how markata moved over to hatch, you can check out this diff.

https://github.com/WaylonWalker/markata/compare/v0.4.0..v0.5.0.dev0

markata extend in configuration

2022-09-11T20:25:45Z

A long needed feature of markata has been the ability to really configure out templates with configuration rather. It’s been long that you needed that if you really want to change the style, meta tags, or anything in the head you needed to write a plugin or eject out of the template and use your own.

Adding some Head #

Now you can add some extra style to your site with the existing built-in template.

[[markata.head]]
text = """
<style>
img {
  width: 100%;
  height: auto;
}
ul {
  display: flex;
  flex-wrap: wrap;
}
</style>
"""

You can have more than one Head #

Each text entry in markata.head just gets appended raw into the head.

[[markata.head]]
text = """
<style>
img {
  width: 100%;
  height: auto;
}
ul {
  display: flex;
  flex-wrap: wrap;
}
</style>
"""

[[markata.head]]
text = """
<script>
console.log('hey there')
</script
"""

Still need more? #

If this does not take you far enough yet, you can still eject out and use your own template pretty easy. If you are going for a full custom site it’s likely that this will be the workflow for awhile. Markata should only get better and make this required less often as it matures.

[markata]
post_template = "pages/templates/post_template.html"

Once you have this in your markata.toml you can put whatever you want in your own template.

From Markdown to Blog with Markata | lightning talk | python web conf 2022

2022-08-31T10:01:09Z

Markata is a great python framework that allows you to go from markdown to a full website very quickly. You can get up and running with nothing more than Markdown. It is also built on a full plugin architecture, so if there is extra functionality that you want to add, you can create a plugin to make it behave like you want.

Full transparancy… I built markata.

The talk #

The talk is live on YouTube. Make sure you check out the other videos from the conference. There were quite a few quality talks that deserve a watch as well.

https://youtu.be/Wq9YBamSgs0

Packages I Maintain

2022-08-30T20:02:38Z

Markata #

I open sourced the static site framework that I use to build my-blog among other side projects. It’s a plugins all the way down static site generator, that makes me happy to use.

{% gh_repo_list_topic “waylonwalker”, “markata” %}

Repos used to build this blog #

my-blog is built on a number of small repos. I set it up this way so that creating content is fast and easy to do. I don’t have to worry about carrying around large images with my lightweight text files just to make some posts.

{% gh_repo_list_topic “waylonwalker”, “personal-website” %}

Kedro #

I am a heavy user of the kedro framework, and a big advocate for using some sort of DAG framework for your data pipelines. kedro is built all in python which makes it easy for a python dev like me to extend, run, maintain, and deploy.

{% gh_repo_list_topic “waylonwalker”, “kedro” %}

Neovim Plugins #

I use vim for all of my text editing needs. It brings me joy to make any part of it just a bit smoother. I have written a few plugins that help me achieve that silky smooth workflow.

{% gh_repo_list_topic “waylonwalker”, “neovim-plugin” %}

markata 0.3.0 is 15-20% faster

2022-08-21T13:53:20Z

a sprinter edging out his opponent by Dall-e

It’s about time to release Markata 0.3.0. I’ve had 8 pre-releases since the last release, but more importantly it has about 3 months of updates. Many of which are just cleaning up bad practices that were showing up as hot spots on my pyinstrument reports

Markata started off partly as a python developer frustrated with using nodejs for everything, and a desire to learn how to make frameworks in pluggy. Little did I know how flexible pluggy would make it. It started out just as my blog generator, but has turned into quite a bit more.

Over time this side project has grown some warts and some of them were now becoming a big enough issue it was time to cut them out.

Let’s compare #

I like to use my tils articles for examples and tests like this as there are enough articles for a good test, but they are pretty short and quick to render.

mkdir ~/git/tils/tils
cp  ~/git/waylonwalker.com/pages/til/ ~/tils/tils -r
cd ~/git/tils/tils

running tils on 0.2.0 #

At the time of writing this is the current version of markata, so just make a new venv and run it.

python3 -m venv .venv --prompt $(basename $PWD)
pip install markata
markata clean
markata build

cold tils: 14.523 warm tils: 1.028

running tils on 0.3.0b8 #

python3 -m venv .venv --prompt $(basename $PWD)
# --pre installs pre-releases that include a b in their version name
pip install markata --pre
markata clean
markata build

cold tils: 11.551 (+20%) warm tils: 0.860 (+16%)

pyinstrument #

These measurements were taken with pyinstrument mostly out of convenience since there is already a pyinstrument hook built in, but also because I like pyinstrument.

Here is the pyinstrument report from the last run.

My Machine #

This comparison was not very exhaustive. It was ran on my pretty new to me Ryzen 5 3600 machine.

The changes #

Most of these changes revolve in how the lifecycle is ran. It was trying to be extra cautious and run previous steps for you if it thought it might be needes, in reality it was rerunning a few steps multiple times no matter what.

The other thing I turned off by default, but can be opted into, is beautifulasoup’s prettify. That was one of the slower steps ran on my site.

0.3.0 #

It should be out by the time you see this, I wanted to compare the changes I had made and make sure that it was still making forward progress and thought I would share the results.

LIVE-REPLAY - Python dev | Markata todoui | 4/6/2022

2022-05-12T19:28:20Z

https://youtu.be/-42A5210HYo

Super fun steam Broadcasted live on Twitch – Watch live at https://www.twitch.tv/waylonwalker

We worked on markata todoui, a command tui trello board written in python using only markdown files to store the data. I love markdown and I want to make this my workflow.

During this stream we get RAIDED by TEEJ_DV! and chat about tmux a bit before calling the changes to markata-tui good and signing off.

dotfiles: https://github.com/WaylonWalker/devtainer
today’s project: https://github.com/WaylonWalker/markata-todoui
website: https://waylonwalker.com/

Posts tagged: markata

Share To Plaindown

helix markata go lsp

Mentions

Late Night Linux – Episode 335 - YouTube

m9a devlog 1

I like tuis #

Are they worth the effort?? #

m9a (em - nine - ah) #

Learning #

Markata list posts by year

Result #

Result #

markata 0.8.0

Pydantic Support Was kinda big #

Multi Feeds #

Jinja Templates #

Directly from the release notes #

0.8.2 #

0.8.1 #

Feeds have partials #

Better Jinja Templates #

cli #

Variables #

post_template

feeds

jinja_md

Feeds cli #

0.8.0 #

Pydantic Support #

breaking changes #

glob config is now under markata.glob #

Feeds are now a list #

markata.summary.filter_count is now a list #

markata search

My Reader Project

Built on markata #

I’ve added htmx to my blog

can it be done with jinja #

Feed Partials #

It’s now part of my blog #

Latest Page in Markata

Setting up the feed #

markata

Static Sites were all the rage #

Plugins all the way down #

More Posts #

Markata GitHub Pages

Markata Supports Jinja Plugins 0.5.0.dev2

From the Changelog #

markata-gh #

How is this achieved #

Entrypoints #

Creating entrypoints in pyproject.toml #

Creating entrypoints in setup.py #

Markata now uses hatch

0.5.0 is big #

My Personal Simple CI/CD #

hatch new –init #

lint-test #

Typical branching workflow #

managing prs #

Building and publishing #

Full set of changes #

markata extend in configuration

Adding some Head #

You can have more than one Head #

Still need more? #

From Markdown to Blog with Markata | lightning talk | python web conf 2022

The talk #

Packages I Maintain

Markata #

Repos used to build this blog #

Kedro #

Neovim Plugins #

markata 0.3.0 is 15-20% faster

Let’s compare #

running tils on 0.2.0 #

running tils on 0.3.0b8 #

pyinstrument #