klank-docs/app.py

import os
from pathlib import Path
import shutil
import csv
import re
from datetime import datetime

from jinja2 import Environment, PackageLoader, select_autoescape
import frontmatter
import markdown
from slugify import slugify

env = Environment(
    loader=PackageLoader("src"),
    autoescape=select_autoescape()
)

CONTENT_D = os.path.abspath("src/content")
OUTPUT_D = "dist"
documents = {}


def listDocuments(params):
    param = params.split(" ")

    template = env.select_template([f"snippets/list-documents.jinja"])
    html = template.render(documents=documents, layout=param[0], type=param[1])

    return html

def detail(params):
    param = params.split(" ")
    modifier = False

    if len(param)> 2:
        modifier  = param[2]

    for doc in documents[param[0]]:
        if doc.filename == param[1]:
            template = env.select_template([f"snippets/detail.jinja"])
            html = template.render(document=doc, modifier = modifier)
            return html

    return ""


def listEvents(params):
    param = params.split(" ")

    if "events" not in documents:
        return ""

    template = env.select_template([f"snippets/list-events.jinja"])
    html = template.render(events=documents["events"], filter=param[0])

    return html


def slugify_filter(value):
    return slugify(value)


def prettydate(value, format='%d/%m/%Y'):
    return datetime.fromtimestamp(int(value)).strftime(format)


def shortcode_filter(value):

    shortcode_callbacks = {
        "show": listDocuments,
        "events": listEvents,
        "detail": detail
    }

    def shortcode_replacer(match):
        shortcode_name = match.group(1).strip()
        param = match.group(2).strip()

        if shortcode_name in shortcode_callbacks:
            return shortcode_callbacks[shortcode_name](param)

        return match.group(0)

    pattern = re.compile(r"{{\s*(\w+)\s+([^{}]+?)\s*}}")
    return pattern.sub(shortcode_replacer, value)


env.filters["shortcode"] = shortcode_filter
env.filters["slugify"] = slugify_filter
env.filters["prettydate"] = prettydate


def render_single_file(template, page, path, dist):
    html = template.render(documents=documents, page=page)
    name = Path(path).stem

    if not os.path.exists(dist):
        os.makedirs(dist)

    with open(f"{dist}/{name}.html", "w", encoding="utf-8") as output_file:
        output_file.write(html)


def get_page_data(path):
    filename = Path(path).stem

    page = frontmatter.load(path)
    page['slug'] = slugify(filename)
    page.filename = filename
    page.folder = os.path.basename(os.path.dirname(path))

    if "start_datetime" in page:
        now = datetime.now()
        page["has_passed"] = datetime.fromtimestamp(page["start_datetime"]) < now
        

    page.body = markdown.markdown(
        page.content,
        extensions=[
            'def_list',
            'footnotes'])

    return page


def render_posts(path):
    name = Path(path).stem
    print(f"looking for {name}.jinja")
    template = env.select_template([f"{name}.jinja", "post.jinja"])

    for filename in os.listdir(path):
        if filename.endswith(".md"):
            post_path = os.path.join(path, filename)
            page = get_page_data(post_path)
            render_single_file(template, page, post_path, f"{OUTPUT_D}/{name}")


def preload_documents():
    print("preload any needed data")

    for subdir in os.listdir(CONTENT_D):
        path = os.path.join(CONTENT_D, subdir)

        if os.path.isdir(path):
            name = Path(path).stem
            if name not in documents:
                documents[name] = []
            for filename in os.listdir(path):
                if filename.endswith(".md"):
                    post_path = os.path.join(path, filename)

                    documents[name].append(get_page_data(post_path))

        elif Path(path).suffix == '.md':
            documents[Path(path).stem] = get_page_data(path)


def copy_assets():
    if os.path.exists("dist/assets"):
        shutil.rmtree("dist/assets")

    shutil.copytree("src/assets", "dist/assets")


def get_inventory():

    with open("src/content/component-inventory.csv") as f:
        documents['inventory'] = []
        for line in csv.DictReader(
            f,
            fieldnames=(
                'ID',
                'Name',
                'Value',
                'type',
                'Date',
                'Where',
                'Mounting type')):
            documents['inventory'].append(line)


def main():
    get_inventory()
    preload_documents()

    print("render the content")
    for subdir in os.listdir(CONTENT_D):
        path = os.path.join(CONTENT_D, subdir)

        if os.path.isdir(path):
            render_posts(path)
        elif Path(path).suffix == '.md':
            template = env.select_template(
                [f"{Path(path).stem}.jinja", "post.jinja"])
            page = get_page_data(path)
            render_single_file(template, page, path, OUTPUT_D)
        elif Path(path).suffix in [".csv"]:
            print("not compiling this file!")
        else:
            print("i cannot handle this file yet: ", path)

    copy_assets()


main()