Compare commits

..

15 Commits

Author SHA1 Message Date
ktyl 7271899b78 feat(journal): include specific journal paths
continuous-integration/drone/push Build is failing Details
2023-12-04 22:51:03 +00:00
ktyl 3372bb108d build: fix clean rule 2023-12-04 22:48:55 +00:00
ktyl 7a29773169 build: update make target 2023-12-03 23:33:48 +00:00
ktyl 89bdaf95b9 feat(garden): generate html files 2023-11-18 00:32:49 +00:00
ktyl 2d0fb9ed84 feat(books): start collection
continuous-integration/drone/push Build is failing Details
2023-11-17 23:51:29 +00:00
ktyl 623a463d9f chore(journal): update subdmodule 2023-11-17 23:44:01 +00:00
ktyl f72c3e7f35 update journal
continuous-integration/drone/push Build is failing Details
2023-11-17 21:23:01 +00:00
ktyl 1cc66385ab feat(rss): generate unformatted file titles
continuous-integration/drone/push Build is failing Details
2023-11-15 01:18:53 +00:00
ktyl 17c12cadf4 feat: add journal as submodule 2023-11-15 01:18:53 +00:00
ktyl a76793e961 ci(garden): add rule file requirements
continuous-integration/drone/push Build is passing Details
2023-11-15 01:18:08 +00:00
ktyl 5b938fe2fa ci(garden): build garden site files 2023-11-15 01:17:12 +00:00
ktyl 7f4cc152ca feat: add navigation 2023-11-12 02:30:03 +00:00
ktyl 9849fff782 build: add make targets 2023-11-12 02:30:03 +00:00
ktyl 6ed995de6c feat(garden): generate rss 2023-11-12 02:29:55 +00:00
ktyl cb39047ee9 feat(garden): rss youtube subscriptions
Describe how to get RSS feeds for YouTube channels
2023-10-04 00:54:39 +01:00
14 changed files with 426 additions and 2 deletions

9
.gitmodules vendored
View File

@ -4,3 +4,12 @@
[submodule "blog"] [submodule "blog"]
path = blog path = blog
url = https://sauce.pizzawednes.day/ktyl/blog.git url = https://sauce.pizzawednes.day/ktyl/blog.git
[submodule "journal"]
path = sr/garden/journal
url = git@sauce.pizzawednes.day:ktyl/journal.git
[submodule "src/garden/period3.xyz"]
path = src/garden/period3.xyz
url = git@sauce.pizzawedney.day:ktyl/period3.xyz
[submodule "src/garden/journal"]
path = src/garden/journal
url = git@sauce.pizzawednes.day:ktyl/journal

View File

@ -15,6 +15,9 @@ BLOG_BUILD_DIR = $(BLOG_BASE_DIR)out/html/
BLOG_OUT_DIR = $(OUT_DIR)/blog BLOG_OUT_DIR = $(OUT_DIR)/blog
BLOG_INDEX = $(BLOG_BUILD_DIR)/index.html BLOG_INDEX = $(BLOG_BUILD_DIR)/index.html
GARDEN_BASE_DIR = $(SRC_DIR)/garden/
GARDEN_BUILD_DIR = $(GARDEN_BASE_DIR)html
PAGES = $(shell find $(ROOT_DIR) -wholename "$(ROOT_DIR)*.html") PAGES = $(shell find $(ROOT_DIR) -wholename "$(ROOT_DIR)*.html")
STYLES = $(shell find $(ROOT_DIR) -wholename "$(ROOT_DIR)*.css") STYLES = $(shell find $(ROOT_DIR) -wholename "$(ROOT_DIR)*.css")
IMAGES = $(shell find $(IMG_DIR) -wholename "$(IMG_DIR)/*.png") IMAGES = $(shell find $(IMG_DIR) -wholename "$(IMG_DIR)/*.png")
@ -26,7 +29,8 @@ HTML_TARGETS = $(PAGES:$(ROOT_DIR)/%.html=$(OUT_DIR)/%.html)
CSS_TARGETS = $(STYLES:$(ROOT_DIR)/%.css=$(OUT_DIR)/%.css) CSS_TARGETS = $(STYLES:$(ROOT_DIR)/%.css=$(OUT_DIR)/%.css)
PNG_TARGETS = $(IMG_DIR)/%.png=$(OUT_DIR)/%.png PNG_TARGETS = $(IMG_DIR)/%.png=$(OUT_DIR)/%.png
all: html blog | $(OUT_DIR) all: html blog garden | $(OUT_DIR)
cp -r src/garden/html $(OUT_DIR)/garden
html: $(HTML_TARGETS) $(CSS_TARGETS) | $(OUT_DIR) html: $(HTML_TARGETS) $(CSS_TARGETS) | $(OUT_DIR)
cp $(IMG_DIR)/*.png $(OUT_DIR)/ cp $(IMG_DIR)/*.png $(OUT_DIR)/
@ -62,8 +66,12 @@ blog: $(HTML_INCLUDES) $(CSS_TARGETS)
cp $(CSS_TARGETS) `dirname $$page` ; \ cp $(CSS_TARGETS) `dirname $$page` ; \
done done
garden:
make --directory $(GARDEN_BASE_DIR) site
clean: clean:
make --directory $(GARDEN_BASE_DIR) clean
make --directory $(BLOG_BASE_DIR) clean make --directory $(BLOG_BASE_DIR) clean
rm -rf $(OUT_DIR) rm -rf $(OUT_DIR)
.PHONY: blog .PHONY: blog garden

2
src/garden/.gitignore vendored Normal file
View File

@ -0,0 +1,2 @@
__pycache__
*.html

27
src/garden/Makefile Normal file
View File

@ -0,0 +1,27 @@
py = feed.py books.py
poetry = journal/poetry/fallen-leaves.md
journal-images = journal/poetry/tree.jpg
md = rss.md book-collecting.md gardens.md $(poetry)
html = $(md:%.md=%.html)
site: Makefile $(md) $(py) $(journal-images)
mkdir html
python md2html.py $(md)
cp -R $(html) $(py) $(journal-images) Makefile html
journal: $(poetry)
python journal.py $<
clean-html:
rm -r html
.PHONY: clean-html
feed:
python feed.py `pwd`
rss: feed
clean: clean-html
.PHONY: feed clean journal

View File

@ -0,0 +1,106 @@
how do you define a book collection?
my book collection is the set of all books.
i prefer physical books to e-readers.
unfortunately i have quite a few these days.
i want to read them all eventually!
i also tend to live in quite small places
and i want to be able to move city easily!
so here's my system for organising my physical book collection.
i want to:
* read books i already have
* read as many different books as possible
* minimise physical storage requirements
* keep track of books i've read
* gather books i don't already have
constraints
* i don't know for sure what book i will want to read next
for every book in the world
* i either have or have not read it
* i have access to it or i don't
so i sort my book collection with 4 categories
*-------------------*-----------------------*
| | |
| unread | read |
| have | have |
| | |
| 37º2 le matin | L'Homme des Jeux |
| | |
*-------------------*-----------------------*
| | |
| unread | read |
| haven't | haven't |
| | |
| Das Kapital | Frankisstein |
| | |
*-------------------*-----------------------*
i can then begin to optimise my collection.
* i do not have this book, and i have read it.
* i have this book, but i have not read it.
* i have this book, and i have read it.
* i do not have this book, but i have not read it.
the books i am most interested in having nearby are unread ones, as i would like to read as many different books as possible.
books i have already read i don't need nearby anymore.
i might pass it on, or store it somewhere with less of a premium on space.
i could also attempt to track where it is!
based on my requirements and my categories, i create four lists for the books
* ready
* all done
* read and gone
* hunted
that looks like a decent start to the system, so i suppose now i'll start collecting!
so i'll use markdown lists in the format
```
* [x] author - title # reading
* [ ] author - title # nearby
```
when collecting music i use artist - year - name
however, publication year is an extra step that will slow data entry, so won't use this to start with - i have a lot of books
i realised i had a gpt-4 sub and that it could look at pictures now so i gave it a go
i fed it some photos and some formatting preferences and i got out perfect markdown lists
```
- [ ] Doctorow, Cory - Walkaway
- [ ] Ferreira, Pedro G. - The Perfect Theory
- [ ] Hadfield, Chris - An Astronaut's Guide to Life on Earth
- [ ] Heinlein, Robert A. - Beyond This Horizon
```
books are lovely are great to look at, but the mishmash of fonts and presentation are a nightmare for indexing.
now we have some good and lovely metadata :)
this is an imperfect method, as the only way i can check it is still by combing through the physical books manually
but it does let me target my combing after identifying problems in the index
and in the meantime gives us a bunch of data to play with
markdown lists also allow me to mark some items in a list
this is looks flexible, so i think in my 'ready' list i will mark which book(s) i am currently reading
```
- [ ] Doctorow, Cory - Walkaway
- [ ] Ferreira, Pedro G. - The Perfect Theory
- [ ] Hadfield, Chris - An Astronaut's Guide to Life on Earth
- [ ] Heinlein, Robert A. - Beyond This Horizon
```
the other lists i will leave unmarked for now, until i think of something to do with them.
as for doing things with them, i wrote a [python script](#) which processes the data in the now-populated all-done and ready lists to yield some interesting (?) and fun (?) results?
[example output](#)

87
src/garden/books.py Normal file
View File

@ -0,0 +1,87 @@
import sys
import os
import re
def print_usage():
print(f"usage: python {sys.argv[0]} DIR")
print(f"")
print(f"\tDIR\tdirectory containing markdown lists in files.")
if len(sys.argv) != 2:
print_usage()
exit(1)
base_path = os.path.abspath(sys.argv[1])
ready_list_name = "ready.md"
done_list_name = "all-done.md"
def get_path(list_name : str) -> str:
return os.path.join(base_path, list_name)
def get_matches(list_name : str) -> list[re.Match]:
# Matches a markdown list item
entry_pattern = re.compile(r"^[*-] \[([ *x])\] (.+) - (.+)")
matches = []
with open(get_path(list_name)) as f:
matches = [entry_pattern.match(l) for l in f.readlines()]
return [m for m in matches if m is not None]
class Book:
def __init__(self, match : re.Pattern):
self.mark = match.group(1) != " "
self.author = match.group(2)
self.title = match.group(3)
def is_metadata_complete(self):
if not self.title or not self.author:
return False
if self.title == "???" or self.author == "???":
return False
return True
@staticmethod
def get_list(list_name : str, filter_partial_metadata = True) -> []:
books = [Book(m) for m in get_matches(list_name)]
if filter_partial_metadata:
books = [b for b in books if b.is_metadata_complete()]
return books
def print_section(title : str, books : list[str]):
print(f"# {title} ({len(books)})\n")
longest_title = max([len(b.title) for b in books])
title_column_width = longest_title + 2
for book in books:
row = [book.title, book.author]
format_str = "- {: <" + str(title_column_width) + "} {: <20}"
print(format_str.format(*row))
print()
def print_in_progress():
books = [b for b in Book.get_list(ready_list_name, False) if b.mark]
print_section("in progress", books)
def print_completed():
books = Book.get_list(done_list_name)
print_section("up for borrowing", books)
def print_partial_metadata():
books = Book.get_list(ready_list_name, False)
books += Book.get_list(done_list_name, False)
books = [b for b in books if not b.is_metadata_complete()]
print_section("metadata incomplete", books)
print_in_progress()
print_completed()
print_partial_metadata()

63
src/garden/feed.py Normal file
View File

@ -0,0 +1,63 @@
#!/usr/bin/env python3
import markdown
import pathlib
import sys
import re
import glob
import os
def print_usage():
print("\nusage: python feed.py ROOT\n")
print("\n")
print("\t\ROOT\tbase folder")
# check args for at most one file paths
if len(sys.argv) > 2:
print_usage()
sys.exit(1)
base_folder = sys.argv[1] if len(sys.argv) == 2 else os.getcwd()
print(base_folder)
def get_paths() -> [str]:
return [x for x in glob.glob(f"{base_folder}/*.md")]
def get_text(path):
with open(path) as f:
return f.read()
#def to_html(md : str) -> str:
# return markdown.markdown(md, extensions=["fenced_code"])
def get_title(md):
m = re.compile(r"^# (.+)\n").match(md)
if m is not None:
return m.groups(1)[0]
# truncated first line of file for auto-title
return md.splitlines()[0][0:30]
def get_entry(path):
return get_title(get_text(path))
def get_entries() -> [str]:
entries = [get_entry(p) for p in get_paths()]
return "\n\n".join(entries)
def get_header() -> str:
return """<?xml version="1.0" encoding="utf-8" ?>
<rss xmlns:atom="http://www.w3.org/2005/Atom" version="2.0">
<channel>
<title></title>
<link>https://ktyl.dev/garden</link>
<description></description>
<atom:link href="https://ktyl.dev/garden/feed.xml" rel="self" type="application/rss+xml"/>
"""
def get_footer() -> str:
return "\n</channel></rss>"
print(get_header())
print(get_entries())
print(get_footer())

15
src/garden/feed.xml Normal file
View File

@ -0,0 +1,15 @@
python feed.py `pwd`
<?xml version="1.0" encoding="utf-8" ?>
<rss xmlns:atom="http://www.w3.org/2005/Atom" version="2.0">
<channel>
<title></title>
<link>https://ktyl.dev/garden</link>
<description></description>
<atom:link href="https://ktyl.dev/garden/feed.xml" rel="self" type="application/rss+xml"/>
Digital Gardens
RSS
</channel></rss>

5
src/garden/gardens.md Normal file
View File

@ -0,0 +1,5 @@
# Digital Gardens
* Obsidian
* Notion
* Git

1
src/garden/journal Submodule

@ -0,0 +1 @@
Subproject commit 170fb442a8c4a0c06b47e28821ab5fb475e35be1

30
src/garden/journal.py Normal file
View File

@ -0,0 +1,30 @@
#!/usr/bin/env python
import sys
import os
import md2html
def print_usage():
print(f"usage: python {sys.argv[0]} PATHS")
print("")
print("\t\PATHS\tpaths of input markdown files")
if len(sys.argv) < 2:
print_usage()
exit(1)
# we don't want to publish *everything* in the journal, so for now let's just
# hardcode the files we want.
files = sys.argv[1:]
# TODO: copy images
# TODO: separate md fromm images
for f in files:
md2html.write_html(f)
html_path = f.replace(".md", ".html")
print(html_path)

35
src/garden/md2html.py Normal file
View File

@ -0,0 +1,35 @@
#!/usr/bin/env python
import sys
import markdown
def print_usage():
print(f"usage: python {sys.argv[0]} PATHS")
print("")
print("\t\PATHS\tpaths of input markdown files")
def write_html(src : str):
with open(src) as md:
dest = src.replace(".md", ".html")
with open(dest, "w") as html:
html.write(markdown.markdown(md.read()))
if __name__ == "__main__":
if len(sys.argv) < 2:
print_usage()
sys.exit(1)
paths = sys.argv[1:]
bad_paths = [p for p in paths if not p.endswith(".md")]
if len(bad_paths) != 0:
for p in bad_paths:
print(f"Not a markdown file: {p}")
exit(1)
for p in paths:
write_html(p)

35
src/garden/rss.md Normal file
View File

@ -0,0 +1,35 @@
# RSS
Really Simple Syndication (RSS) is an ancient file format for communicating updates over the Web, and my personal favourite.
* [It's Time for an RSS Revival](https://www.wired.com/story/rss-readers-feedly-inoreader-old-reader/)
### Stubs:
* my curated feeds
* reader applications
## Technical Simplicity
From a technical perspective, like [Gemini](gemini://gemini.circumlunar.space) [\(HTTP\)](https://gemini.circumlunar.space/) it's grokkable with a couple good reads of the specification.
I wrote [a simple generator](https://ktyl.dev/blog/2022/6/3/rss.md)] for my blog posts, and am now working on [a simpler one](./feed.py) for the garden.
To start with, I'd like to generate it as simply as possible, from just a directory structure, but I can already see I'd like to do more with it.
I work predominantly in [Git](https://git-scm.com/) repositories, which, like a directory, or a garden, is tree-based.
My blog's feed has a chronological hierarchy, but at present it's based on manually creating and naming folders.
It's also very much a _published_ format, rather than a living one.
This is silly!
Instead, I'd like to structure my feed around a Git repository, as I think it'd be a much better descriptor of activity.
## Managing YouTube Subscriptions
There are many reasons to avoid the YouTube homepage, such as recommended videos or the accursed Shorts.
YouTube publishes channel-specific RSS feeds, making it totally possible to circumvent its subscription system entirely - including having to make an account - and keep track of channels one enjoys with RSS feeds instead.
Get a channel's ID:
1. Go to the channel's page
2. Go to the About section
3. Share icon under Stats block
4. Copy channel ID
The channel's feed is available at `https://www.youtube.com/feeds/videos.xml?channel_id=CHANNEL_ID_HERE`.

View File

@ -2,4 +2,5 @@
<li><a href="/about.html">about</a></li> <li><a href="/about.html">about</a></li>
<li><a href="/blog.html">blog</a></li> <li><a href="/blog.html">blog</a></li>
<li><a href="/gallery.html">gallery</a></li> <li><a href="/gallery.html">gallery</a></li>
<li><a href="/garden/index.html">garden</a></li>
</ul> </ul>