tagflux 0.1.0__tar.gz

tagflux-0.1.0/PKG-INFO

@@ -0,0 +1,18 @@
+Metadata-Version: 2.3
+Name: tagflux
+Version: 0.1.0
+Summary: Static site generator
+Author: Roman
+Author-email: Roman <roman@adontz.com>
+Requires-Dist: dacite~=1.9.2
+Requires-Dist: jinja2~=3.1.6
+Requires-Dist: markdown~=3.9
+Requires-Dist: pillow~=12.1.1
+Requires-Dist: pygments~=2.19.2
+Requires-Dist: pyyaml~=6.0.3
+Requires-Dist: rcssmin~=1.2.2
+Requires-Dist: rjsmin~=1.2.5
+Requires-Dist: watchdog~=6.0.0
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+

tagflux-0.1.0/pyproject.toml

@@ -0,0 +1,28 @@
+[project]
+name = "tagflux"
+version = "0.1.0"
+description = "Static site generator"
+readme = "README.md"
+authors = [
+    { name = "Roman", email = "roman@adontz.com" }
+]
+requires-python = ">=3.12"
+dependencies = [
+    "dacite~=1.9.2",
+    "Jinja2~=3.1.6",
+    "Markdown~=3.9",
+    "pillow~=12.1.1",
+    "pygments~=2.19.2",
+    "PyYAML~=6.0.3",
+    "rcssmin~=1.2.2",
+    "rjsmin~=1.2.5",
+    "watchdog~=6.0.0",
+]
+
+[build-system]
+requires = ["uv_build>=0.11.1,<0.12.0"]
+build-backend = "uv_build"
+
+[tool.uv.build-backend]
+module-name = "tagflux"
+module-root = ""

tagflux-0.1.0/tagflux/__init__.py

@@ -0,0 +1,2 @@
+def hello() -> str:
+    return "Hello from tagflux!"

tagflux-0.1.0/tagflux/__main__.py

@@ -0,0 +1,101 @@
+#!/bin/env python3
+
+from argparse import ArgumentParser
+from concurrent.futures import ProcessPoolExecutor
+from concurrent.futures import ThreadPoolExecutor
+from dacite import from_dict
+from os.path import abspath
+from os.path import dirname
+from os.path import join
+from tagflux.config import Config
+from tagflux.processors.content import PageCatalog
+from tagflux.processors.static import StaticProcessor
+from tagflux.processors.template import TemplateProcessor
+from tagflux.watchers.content import ContentEventHandler
+from tagflux.watchers.static import StaticEventHandler
+from tagflux.watchers.templates import TemplateEventHandler
+from time import time
+from watchdog.observers import Observer
+from yaml import full_load
+
+argument_parser = ArgumentParser("tagflux")
+argument_parser.add_argument("--config", required=True, default="./tagflux.yml", metavar="CONFIG_PATH", help="a path to a YAML configuration file")
+argument_parser.add_argument("--watch", required=False, action="store_true", help="continuously watch for changes and rebuild if necessary")
+argument_parser.add_argument("--executor", required=False, default=None, choices=["thread", "process"], help="force specific task executor")
+arguments = argument_parser.parse_args()
+
+config_path = abspath(arguments.config)
+
+with open(config_path, "r") as config_file:
+    config_dict = full_load(config_file)
+
+base_path = dirname(config_path)
+config: Config = from_dict(Config, config_dict)
+config.content.path = join(base_path, config.content.path)
+config.output.path = join(base_path, config.output.path)
+config.static.path = join(base_path, config.static.path)
+config.templates.path = join(base_path, config.templates.path)
+
+executor_classes = {
+    "thread": ThreadPoolExecutor,
+    "process": ProcessPoolExecutor,
+}
+content_executor_class = executor_classes.get(arguments.executor, ThreadPoolExecutor)
+static_executor_class = executor_classes.get(arguments.executor, ProcessPoolExecutor)
+template_executor_class = executor_classes.get(arguments.executor, ProcessPoolExecutor)
+
+print("Fluxing...")
+
+since = time()
+
+content_executor = content_executor_class()
+page_catalog = PageCatalog(config)
+page_catalog.load_all(content_executor)
+content_executor.shutdown()
+
+until = time()
+delay = int(1000 * (until - since))
+
+print(f"X [{delay}ms] {config.content.path}")
+
+since = time()
+
+static_executor = static_executor_class()
+static_processor = StaticProcessor(config)
+static_processor.process_all(static_executor)
+static_executor.shutdown()
+
+until = time()
+delay = int(1000 * (until - since))
+
+print(f"X [{delay}ms] {config.static.path}")
+since = time()
+
+template_executor = template_executor_class()
+template_processor = TemplateProcessor(config, page_catalog)
+template_processor.process_all(template_executor, False)
+template_executor.shutdown()
+
+until = time()
+delay = int(1000 * (until - since))
+
+print(f"X [{delay}ms] {config.templates.path}")
+
+if arguments.watch:
+    content_executor = content_executor_class()
+    static_executor = static_executor_class()
+    template_executor = template_executor_class()
+
+    print("Watching...")
+    observer = Observer()
+    observer.schedule(ContentEventHandler(content_executor, page_catalog, template_processor), config.content.path, recursive=True)
+    observer.schedule(StaticEventHandler(static_executor, static_processor), config.static.path, recursive=True)
+    observer.schedule(TemplateEventHandler(template_executor, page_catalog, template_processor), config.templates.path, recursive=True)
+    observer.start()
+
+    try:
+        while observer.is_alive():
+            observer.join(1)
+    finally:
+        observer.stop()
+        observer.join()

tagflux-0.1.0/tagflux/config.py

@@ -0,0 +1,61 @@
+from dataclasses import dataclass
+from typing import Any
+from typing import Optional
+from typing import Literal
+
+
+@dataclass
+class ConfigContent:
+    path: str
+    variants: list[str]
+
+
+@dataclass
+class ConfigTemplates:
+    path: str
+
+
+@dataclass
+class ConfigStaticOptimizationImage:
+    extensions: list[str]
+    formats: dict[Literal["JPEG", "PNG", "WEBP"], dict[str, Any]]
+    resize: Optional[list[str]]
+
+
+@dataclass
+class ConfigStaticOptimizationStyle:
+    extensions: list[str]
+    formats: dict[Literal["CSS"], dict]
+
+
+@dataclass
+class ConfigStaticOptimizationScript:
+    extensions: list[str]
+    formats: dict[Literal["JS"], dict]
+
+
+@dataclass
+class ConfigStaticOptimizations:
+    images: dict[str, ConfigStaticOptimizationImage]
+    styles: dict[str, ConfigStaticOptimizationStyle]
+    scripts: dict[str, ConfigStaticOptimizationScript]
+
+
+@dataclass
+class ConfigStatic:
+    path: str
+    optimizations: ConfigStaticOptimizations
+
+
+@dataclass
+class ConfigOutput:
+    path: str
+
+
+@dataclass
+class Config:
+    context: dict
+    content: ConfigContent
+    templates: ConfigTemplates
+    static: ConfigStatic
+    output: ConfigOutput

tagflux-0.1.0/tagflux/processors/content.py

@@ -0,0 +1,368 @@
+from collections import defaultdict
+from concurrent.futures import ProcessPoolExecutor
+from dataclasses import dataclass
+from datetime import datetime
+from datetime import UTC
+from os import scandir
+from os import stat
+from os.path import basename
+from os.path import dirname
+from os.path import join
+from os.path import splitext
+from re import compile
+from re import fullmatch
+from re import Pattern
+from re import UNICODE
+from subprocess import run
+from tagflux.config import Config
+from yaml import full_load
+
+FRONTMATTER_PREFIX = "---\n"
+FRONTMATTER_SUFFIX = "\n---\n"
+
+
+@dataclass
+class PageFileInfo:
+    absolute_path: str
+    relative_path: str
+    name: str
+    modify_timestamp: int
+
+
+@dataclass
+class PageGit:
+    author_name: str
+    author_email: str
+    author_timestamp: datetime
+    committer_name: str
+    committer_email: str
+    committer_timestamp: datetime
+    hash: str
+
+
+@dataclass
+class PageMarkup:
+    absolute_path: str
+    relative_path: str
+    uri: str
+    git: PageGit
+    frontmatter: dict
+    content_md: str
+    modify_timestamp: int
+    update_timestamp: datetime
+    variants: dict[str, dict[str, "PageMarkup"]]
+
+
+class PageCatalog:
+    def _load_git_log(self, absolute_path: str):
+        git_output = run(
+            [
+                "git",
+                "rev-parse",
+                "--show-toplevel",
+            ],
+            capture_output=True,
+            check=True,
+            text=True,
+            cwd=absolute_path,
+        )
+        repository_path = git_output.stdout.strip()
+        assert absolute_path.startswith(repository_path)
+        prefix = absolute_path[len(repository_path) :].lstrip("/")
+        git_output = run(
+            [
+                "git",
+                "log",
+                "--format=%x1F%an%x1F%ae%x1F%at%x1F%cn%x1F%ce%x1F%ct%x1F%H",
+                "--name-only",
+            ],
+            capture_output=True,
+            check=True,
+            text=True,
+            cwd=absolute_path,
+        )
+        git_output_lines = git_output.stdout.splitlines()
+        page_git: PageGit = None
+
+        for git_output_line in git_output_lines:
+            if git_output_line.startswith("\u001f"):
+                parts = git_output_line.split("\u001f")
+                page_git = PageGit(
+                    parts[1], parts[2], datetime.fromtimestamp(int(parts[3]), UTC), parts[4], parts[5], datetime.fromtimestamp(int(parts[6]), UTC), parts[7]
+                )
+            elif (len(git_output_line) > 0) and (git_output_line.startswith(prefix)):
+                self.git_log[git_output_line[len(prefix) :]] = page_git
+
+    def _find_page_markups(self, absolute_path: str, relative_path: str):
+        page_file_infos: list[PageFileInfo] = []
+
+        with scandir(absolute_path) as it:
+            for entry in it:
+                if not entry.name.startswith("."):
+                    if entry.is_dir():
+                        page_file_infos.extend(self._find_page_markups(join(absolute_path, entry.name), join(relative_path, entry.name)))
+                    elif entry.is_file():
+                        name, ext = splitext(entry.name)
+
+                        if ext == ".md":
+                            page_file_infos.append(
+                                PageFileInfo(
+                                    join(absolute_path, entry.name),
+                                    join(relative_path, entry.name),
+                                    name,
+                                    entry.stat().st_mtime,
+                                )
+                            )
+
+        return page_file_infos
+
+    def _load_page_markup(self, git_log: dict, page_file_info: PageFileInfo) -> PageMarkup:
+        with open(page_file_info.absolute_path) as file:
+            file_content = file.read()
+
+        file_content = file_content.replace("\r\n", "\n").replace("\r", "\n")
+
+        if not file_content.startswith(FRONTMATTER_PREFIX):
+            return None
+
+        frontmatter_suffix_index = file_content.index(FRONTMATTER_SUFFIX, 1)
+
+        if frontmatter_suffix_index <= 0:
+            return None
+
+        frontmatter_text = file_content[len(FRONTMATTER_PREFIX) : frontmatter_suffix_index]
+        content_md = file_content[frontmatter_suffix_index + len(FRONTMATTER_SUFFIX) :]
+        frontmatter = full_load(frontmatter_text) or {}
+        page_git: PageGit = git_log.get(page_file_info.relative_path)
+        uri_format = frontmatter.get("uri_format", "{name}.html")
+
+        if page_git:
+            page_uri = (
+                dirname(page_file_info.relative_path)
+                + "/"
+                + str.format(
+                    uri_format,
+                    name=page_file_info.name,
+                    hash=page_git.hash,
+                    author_timestamp=page_git.author_timestamp,
+                    committer_timestamp=page_git.committer_timestamp,
+                )
+            )
+        else:
+            page_uri = (
+                dirname(page_file_info.relative_path)
+                + "/"
+                + str.format(
+                    uri_format,
+                    name=page_file_info.name,
+                    hash="0000000000000000000000000000000000000000",
+                    author_timestamp=datetime.min,
+                    committer_timestamp=datetime.min,
+                )
+            )
+
+        return PageMarkup(
+            page_file_info.absolute_path,
+            page_file_info.relative_path,
+            page_uri,
+            page_git,
+            frontmatter,
+            content_md,
+            page_file_info.modify_timestamp,
+            datetime.fromtimestamp(0, UTC),
+            defaultdict(dict),
+        )
+
+    def _load_page_markups(self, pool_executor: ProcessPoolExecutor, page_file_infos: list[PageFileInfo]):
+        results = []
+
+        for page_file_info in page_file_infos:
+            results.append(pool_executor.submit(self._load_page_markup, self.git_log, page_file_info))
+
+        self.pages: list[PageMarkup] = []
+
+        for result in results:
+            page_markup = result.result()
+
+            if page_markup:
+                self.pages.append(page_markup)
+
+    def _find_page_variants(self):
+        page_map = {}
+
+        for page in self.pages:
+            page_map[page.uri] = page
+
+        variants: dict[str, dict[str, dict[str, PageMarkup]]] = defaultdict(lambda: defaultdict(dict))
+        variant_patterns: list[Pattern] = []
+
+        for variant_pattern in self.config.content.variants:
+            variant_patterns.append(compile(variant_pattern, UNICODE))
+
+        for page in self.pages:
+            for variant_pattern in variant_patterns:
+                match = variant_pattern.fullmatch(page.uri)
+
+                if match and match.lastgroup and match.lastindex:
+                    generic_uri = page.uri[: match.start(match.lastindex)] + "*" + page.uri[match.end(match.lastindex) :]
+                    key = match.group(match.lastindex)
+                    variants[match.lastgroup][generic_uri][key] = page
+
+        for variant_group, variant_group_data in variants.items():
+            for variant_data in variant_group_data.values():
+                for key1, page1 in variant_data.items():
+                    for key2, page2 in variant_data.items():
+                        if key1 != key2:
+                            page1.variants[variant_group][key2] = page2
+
+    def __init__(self, config: Config):
+        self.config = config
+        self.git_log: dict[str, PageGit] = {}
+        self.pages: list[PageMarkup] = []
+
+    def load_all(self, pool_executor: ProcessPoolExecutor):
+        self.git_log: dict[str, PageGit] = {}
+        self._load_git_log(self.config.content.path)
+        page_file_infos = self._find_page_markups(self.config.content.path, "/")
+        self._load_page_markups(pool_executor, page_file_infos)
+        self._find_page_variants()
+
+    def load_one(self, pool_executor: ProcessPoolExecutor, absolute_path: str):
+        self.git_log: dict[str, PageGit] = {}
+        self._load_git_log(self.config.content.path)
+
+        for page in self.pages:
+            if page.absolute_path == absolute_path:
+                try:
+                    page_file_stat = stat(page.absolute_path)
+                    page_file_info = PageFileInfo(
+                        page.absolute_path,
+                        page.relative_path,
+                        basename(page.absolute_path),
+                        page_file_stat.st_mtime,
+                    )
+                    page_markup = self._load_page_markup(self.git_log, page_file_info)
+                    page.git = page_markup.git
+                    page.frontmatter = page_markup.frontmatter
+                    page.content_md = page_markup.content_md
+                    page.modify_timestamp = page_markup.modify_timestamp
+
+                    return page
+                except:
+                    break
+
+        self.load_all(pool_executor)
+
+    def sort(self):
+        self.pages.sort(key=lambda p: p.update_timestamp, reverse=True)
+
+    def get_by_absolute_path(self, absolute_path: str) -> PageMarkup:
+        for page in self.pages:
+            if page.absolute_path == absolute_path:
+                return page
+
+        return None
+
+    def filter(self, **filter_conditions):
+        def match(obj):
+            for key, value in filter_conditions.items():
+                *attribute_names, operation_name = key.split("__")
+                attribute_value = obj
+
+                for attribute_name in attribute_names:
+                    if isinstance(attribute_value, dict):
+                        attribute_value = attribute_value.get(attribute_name, None)
+                    else:
+                        attribute_value = getattr(attribute_value, attribute_name, None)
+
+                    if attribute_value is None:
+                        break
+
+                if attribute_value is None:
+                    continue
+
+                match operation_name:
+                    case "eq":
+                        return attribute_value == value
+                    case "gt":
+                        return attribute_value > value
+                    case "gte":
+                        return attribute_value >= value
+                    case "lt":
+                        return attribute_value > value
+                    case "lte":
+                        return attribute_value >= value
+                    case "startswith":
+                        return attribute_value.startswith(value)
+                    case "endswith":
+                        return attribute_value.endswith(value)
+                    case "re":
+                        return fullmatch(value, attribute_value)
+                    case _:
+                        return getattr(attribute_value, operation_name) == value
+
+            return True
+
+        return [x for x in self.pages if match(x)]
+
+    def aggregate(self, aggegate_descriptor, **filter_conditions):
+        pages = self.filter(**filter_conditions)
+        *attribute_names, operation_name = aggegate_descriptor.split("__")
+
+        def attribute_values(pages):
+            values = []
+
+            for page in pages:
+                attribute_value = page
+
+                for attribute_name in attribute_names:
+                    if isinstance(attribute_value, dict):
+                        attribute_value = attribute_value.get(attribute_name, None)
+                    else:
+                        attribute_value = getattr(attribute_value, attribute_name, None)
+
+                    if attribute_value is None:
+                        break
+
+                if attribute_value is not None:
+                    values.append(attribute_value)
+
+            return values
+
+        match operation_name:
+            case "count":
+                return len(pages)
+            case "sum":
+                result = None
+
+                for attribute_value in attribute_values(pages):
+                    result = attribute_value if result is None else (result + attribute_value)
+
+                return result
+            case "average" | "avg":
+                result = 0.0
+
+                for attribute_value in attribute_values(pages):
+                    result += float(attribute_value)
+
+                return result / len([pages])
+            case "minimum" | "min":
+                result = None
+
+                for attribute_value in attribute_values(pages):
+                    result = attribute_value if result is None else min(result, attribute_value)
+
+                return result
+            case "maximum" | "max":
+                result = None
+
+                for attribute_value in attribute_values(pages):
+                    result = attribute_value if result is None else max(result, attribute_value)
+
+                return result
+            case "unique":
+                return set(attribute_values(pages))
+            case _:
+                return None
+
+        return None

tagflux-0.1.0/tagflux/processors/static.py

@@ -0,0 +1,166 @@
+from concurrent.futures import ProcessPoolExecutor
+from rjsmin import jsmin
+from rcssmin import cssmin
+from os import stat
+from os.path import splitext
+from PIL import Image
+from shutil import copy2
+from shutil import copytree
+from tagflux.config import Config
+
+
+class StaticProcessor:
+    def __init__(self, config: Config):
+        self.config = config
+
+    def _copy_file(self, src_path, dst_path):
+        should_copy = True
+
+        if src_path.startswith(self.config.static.path) and dst_path.startswith(self.config.output.path):
+            try:
+                src_stat = stat(src_path)
+                dst_stat = stat(dst_path)
+
+                if src_stat.st_mtime < dst_stat.st_mtime:
+                    return
+            except FileNotFoundError:
+                pass
+
+            relative_src_path = src_path[len(self.config.static.path) :]
+
+            for base_path, config in self.config.static.optimizations.images.items():
+                if relative_src_path.startswith(base_path):
+                    dst_name, dst_ext = splitext(dst_path)
+
+                    if dst_ext in config.extensions:
+                        should_copy = False
+
+                        for format_name, format_parameters in config.formats.items():
+                            parameters = format_parameters.copy()
+                            extension = parameters.pop("extension")
+
+                            if config.resize:
+                                for size_name in config.resize:
+
+                                    if size_name.endswith("%"):
+                                        scale_value = int(10 * float(size_name[:-1]))
+                                        variant_dst_path = dst_name + f".x{scale_value:04d}" + extension
+                                        needs_update = True
+
+                                        try:
+                                            dst_stat = stat(variant_dst_path)
+
+                                            if src_stat.st_mtime < dst_stat.st_mtime:
+                                                needs_update = False
+                                        except FileNotFoundError:
+                                            pass
+
+                                        if needs_update:
+                                            src_image = Image.open(src_path).convert("RGB")
+                                            dst_image = src_image.resize(
+                                                (int(src_image.width * scale_value / 1000.0), int(src_image.height * scale_value / 1000.0)),
+                                                Image.Resampling.LANCZOS,
+                                            )
+                                            dst_image.save(variant_dst_path, format_name, **parameters)
+                                    elif size_name.endswith("w"):
+                                        width_value = int(size_name[:-1])
+                                        variant_dst_path = dst_name + f".w{width_value}" + extension
+                                        needs_update = True
+
+                                        try:
+                                            dst_stat = stat(variant_dst_path)
+
+                                            if src_stat.st_mtime < dst_stat.st_mtime:
+                                                needs_update = False
+                                        except FileNotFoundError:
+                                            pass
+
+                                        if needs_update:
+                                            src_image = Image.open(src_path).convert("RGB")
+                                            height_value = int(src_image.height * width_value / src_image.width)
+                                            dst_image = src_image.resize((width_value, height_value), Image.Resampling.LANCZOS)
+                                            dst_image.save(variant_dst_path, format_name, **parameters)
+                                    elif size_name.endswith("h"):
+                                        height_value = int(size_name[:-1])
+                                        variant_dst_path = dst_name + f".h{height_value}" + extension
+                                        needs_update = True
+
+                                        try:
+                                            dst_stat = stat(variant_dst_path)
+
+                                            if src_stat.st_mtime < dst_stat.st_mtime:
+                                                needs_update = False
+                                        except FileNotFoundError:
+                                            pass
+
+                                        if needs_update:
+                                            src_image = Image.open(src_path).convert("RGB")
+                                            width_value = int(src_image.width * height_value / src_image.height)
+                                            dst_image = src_image.resize((width_value, height_value), Image.Resampling.LANCZOS)
+                                            dst_image.save(variant_dst_path, format_name, **parameters)
+
+                            else:
+                                variant_dst_path = dst_name + extension
+                                needs_update = True
+
+                                try:
+                                    dst_stat = stat(variant_dst_path)
+
+                                    if src_stat.st_mtime < dst_stat.st_mtime:
+                                        needs_update = False
+                                except FileNotFoundError:
+                                    pass
+
+                                if needs_update:
+                                    src_image = Image.open(src_path).convert("RGB")
+                                    src_image.save(variant_dst_path, format_name, **parameters)
+
+            for base_path, config in self.config.static.optimizations.styles.items():
+                if relative_src_path.startswith(base_path):
+                    dst_name, dst_ext = splitext(dst_path)
+
+                    if dst_ext in config.extensions:
+                        should_copy = False
+
+                        with open(src_path, "rb") as style_file:
+                            style_data = style_file.read()
+
+                        style_data = cssmin(style_data)
+
+                        with open(dst_path, "wb") as style_file:
+                            style_file.write(style_data)
+
+            for base_path, config in self.config.static.optimizations.scripts.items():
+                if relative_src_path.startswith(base_path):
+                    dst_name, dst_ext = splitext(dst_path)
+
+                    if dst_ext in config.extensions:
+                        should_copy = False
+
+                        with open(src_path, "rb") as style_file:
+                            style_data = style_file.read()
+
+                        style_data = jsmin(style_data)
+
+                        with open(dst_path, "wb") as style_file:
+                            style_file.write(style_data)
+
+        if should_copy:
+            copy2(src_path, dst_path)
+
+    def process_all(self, pool_executor: ProcessPoolExecutor):
+        def copy(src_path, dst_path):
+            pool_executor.submit(
+                self._copy_file,
+                src_path=src_path,
+                dst_path=dst_path,
+            )
+
+        pool_executor.submit(copytree, src=self.config.static.path, dst=self.config.output.path, dirs_exist_ok=True, copy_function=copy)
+
+    def process_one(self, pool_executor: ProcessPoolExecutor, path: str):
+        pool_executor.submit(
+            self._copy_file,
+            src_path=self.config.static.path + path,
+            dst_path=self.config.output.path + path,
+        )

tagflux-0.1.0/tagflux/processors/template.py

@@ -0,0 +1,121 @@
+from concurrent.futures import ProcessPoolExecutor
+from datetime import datetime
+from datetime import UTC
+from itertools import batched
+from jinja2.loaders import FileSystemLoader
+from jinja2.sandbox import SandboxedEnvironment
+from markdown import markdown
+from os import makedirs
+from os import stat
+from os.path import dirname
+from tagflux.config import Config
+from tagflux.processors.content import PageCatalog
+from tagflux.processors.content import PageMarkup
+
+
+def _render_all(page_catalog: PageCatalog, pages: list[PageMarkup], context: dict, template_path: str, output_path: str, update: bool):
+    template_loader = FileSystemLoader(template_path)
+    template_environment = SandboxedEnvironment(loader=template_loader)
+
+    for page in pages:
+        content_html = markdown(page.content_md, extensions=["admonition", "codehilite", "smarty", "toc"])
+        output_file_path = output_path + page.uri
+
+        try:
+            output_stat = stat(output_file_path)
+        except FileNotFoundError:
+            output_stat = None
+
+        template = template_environment.get_template(page.frontmatter.get("template", "default.html"))
+        template_stat = stat(template.filename)
+
+        if (output_stat is None) or (page.modify_timestamp >= output_stat.st_mtime) or (template_stat.st_mtime >= output_stat.st_mtime):
+            output_dir_path = dirname(output_file_path)
+            makedirs(output_dir_path, exist_ok=True)
+
+            new_page_html = template.render({"page": page, "pages": page_catalog, "content": content_html, "context": context})
+
+            if update:
+                try:
+                    with open(output_file_path, "r") as page_file:
+                        old_page_html = page_file.read()
+
+                        if old_page_html != new_page_html:
+                            page.update_timestamp = datetime.now(UTC)
+
+                            with open(output_file_path, "w") as page_file:
+                                page_file.write(new_page_html)
+                except FileNotFoundError:
+                    page.update_timestamp = datetime.now(UTC)
+
+                    with open(output_file_path, "w") as page_file:
+                        page_file.write(new_page_html)
+            else:
+                with open(output_file_path, "w") as page_file:
+                    page_file.write(new_page_html)
+
+
+def _render_one(page_catalog: PageCatalog, page: PageMarkup, context: dict, template_path: str, output_path: str, update: bool):
+    content_html = markdown(page.content_md, extensions=["admonition", "codehilite", "smarty", "toc"])
+    output_file_path = output_path + page.uri
+
+    try:
+        output_stat = stat(output_file_path)
+    except FileNotFoundError:
+        output_stat = None
+
+    if (output_stat is None) or (page.modify_timestamp >= output_stat.st_mtime):
+        output_dir_path = dirname(output_file_path)
+        makedirs(output_dir_path, exist_ok=True)
+        template_loader = FileSystemLoader(template_path)
+        template_environment = SandboxedEnvironment(loader=template_loader)
+        template = template_environment.get_template(page.frontmatter.get("template", "default.html"))
+        new_page_html = template.render({"page": page, "pages": page_catalog, "content": content_html, "context": context})
+
+        if update:
+            try:
+                with open(output_file_path, "r") as page_file:
+                    old_page_html = page_file.read()
+
+                    if old_page_html != new_page_html:
+                        page.update_timestamp = datetime.now(UTC)
+
+                        with open(output_file_path, "w") as page_file:
+                            page_file.write(new_page_html)
+            except FileNotFoundError:
+                page.update_timestamp = datetime.now(UTC)
+
+                with open(output_file_path, "w") as page_file:
+                    page_file.write(new_page_html)
+        else:
+            with open(output_file_path, "w") as page_file:
+                page_file.write(new_page_html)
+
+
+class TemplateProcessor:
+    def __init__(self, config: Config, page_catalog: PageCatalog):
+        self.config = config
+        self.page_catalog = page_catalog
+
+    def process_all(self, pool_executor: ProcessPoolExecutor, update: bool):
+        for pages in batched(self.page_catalog.pages, 50):
+            pool_executor.submit(
+                _render_all,
+                self.page_catalog,
+                pages,
+                self.config.context,
+                self.config.templates.path,
+                self.config.output.path,
+                update,
+            )
+
+    def process_one(self, pool_executor: ProcessPoolExecutor, page: PageMarkup, update: bool):
+        pool_executor.submit(
+            _render_one,
+            self.page_catalog,
+            [page],
+            self.config.context,
+            self.config.templates.path,
+            self.config.output.path,
+            update,
+        )

tagflux-0.1.0/tagflux/watchers/content.py

@@ -0,0 +1,49 @@
+from concurrent.futures import ProcessPoolExecutor
+from tagflux.processors.content import PageCatalog
+from tagflux.processors.template import TemplateProcessor
+from time import time
+from watchdog.events import FileSystemEvent
+from watchdog.events import FileSystemEventHandler
+
+
+class ContentEventHandler(FileSystemEventHandler):
+    def __init__(self, pool_executor: ProcessPoolExecutor, page_catalog: PageCatalog, template_processor: TemplateProcessor):
+        self.pool_executor = pool_executor
+        self.page_catalog = page_catalog
+        self.template_processor = template_processor
+
+    def _render_all(self, code: str, event: FileSystemEvent):
+        if not event.is_directory:
+            since = time()
+            self.page_catalog.load_all(self.pool_executor)
+            self.template_processor.process_all(self.pool_executor, True)
+            self.page_catalog.sort()
+            until = time()
+            delay = int(1000 * (until - since))
+            print(f"{code} [{delay}ms] {event.src_path}")
+
+    def _render_one(self, code: str, event: FileSystemEvent):
+        if not event.is_directory:
+            since = time()
+            page = self.page_catalog.load_one(self.pool_executor, event.src_path)
+
+            if page:
+                self.template_processor.process_one(self.pool_executor, page, True)
+            else:
+                self.template_processor.process_all(self.pool_executor, True)
+
+            until = time()
+            delay = int(1000 * (until - since))
+            print(f"{code} [{delay}ms] {event.src_path}")
+
+    def on_created(self, event: FileSystemEvent):
+        self._render_all("+", event)
+
+    def on_deleted(self, event: FileSystemEvent):
+        self._render_all("-", event)
+
+    def on_moved(self, event: FileSystemEvent):
+        self._render_all("M", event)
+
+    def on_closed(self, event: FileSystemEvent) -> None:
+        self._render_one("U", event)

tagflux-0.1.0/tagflux/watchers/static.py

@@ -0,0 +1,47 @@
+from concurrent.futures import ProcessPoolExecutor
+from tagflux.processors.static import StaticProcessor
+from time import time
+from watchdog.events import FileSystemEvent
+from watchdog.events import FileSystemEventHandler
+
+
+class StaticEventHandler(FileSystemEventHandler):
+    def __init__(self, pool_executor: ProcessPoolExecutor, static_processor: StaticProcessor):
+        self.pool_executor = pool_executor
+        self.static_processor = static_processor
+
+    def on_created(self, event: FileSystemEvent):
+        since = time()
+
+        if event.is_directory:
+            self.static_processor.process_all(self.pool_executor)
+        else:
+            path = event.src_path[len(self.static_processor.config.static.path) :]
+            self.static_processor.process_one(self.pool_executor, path)
+
+        until = time()
+        delay = int(1000 * (until - since))
+        print(f"+ [{delay}ms] {event.src_path}")
+
+    def on_moved(self, event: FileSystemEvent):
+        since = time()
+
+        if event.is_directory:
+            self.static_processor.process_all(self.pool_executor)
+        else:
+            path = event.dest_path[len(self.static_processor.config.static.path) :]
+            self.static_processor.process_one(self.pool_executor, path)
+
+        until = time()
+        delay = int(1000 * (until - since))
+        print(f"M [{delay}ms] {event.dest_path}")
+
+    def on_closed(self, event: FileSystemEvent) -> None:
+        since = time()
+
+        path = event.src_path[len(self.static_processor.config.static.path) :]
+        self.static_processor.process_one(self.pool_executor, path)
+
+        until = time()
+        delay = int(1000 * (until - since))
+        print(f"U [{delay}ms] {event.src_path}")

tagflux-0.1.0/tagflux/watchers/templates.py

@@ -0,0 +1,34 @@
+from concurrent.futures import ProcessPoolExecutor
+from tagflux.processors.content import PageCatalog
+from tagflux.processors.template import TemplateProcessor
+from time import time
+from watchdog.events import FileSystemEvent
+from watchdog.events import FileSystemEventHandler
+
+
+class TemplateEventHandler(FileSystemEventHandler):
+    def __init__(self, pool_executor: ProcessPoolExecutor, page_catalog: PageCatalog, template_processor: TemplateProcessor):
+        self.pool_executor = pool_executor
+        self.page_catalog = page_catalog
+        self.template_processor = template_processor
+
+    def _render(self, code: str, event: FileSystemEvent):
+        if not event.is_directory:
+            since = time()
+            self.template_processor.process_all(self.pool_executor, True)
+            self.page_catalog.sort()
+            until = time()
+            delay = int(1000 * (until - since))
+            print(f"{code} [{delay}ms] {event.src_path}")
+
+    def on_created(self, event: FileSystemEvent):
+        self._render("+", event)
+
+    def on_deleted(self, event: FileSystemEvent):
+        self._render("-", event)
+
+    def on_moved(self, event: FileSystemEvent):
+        self._render("M", event)
+
+    def on_closed(self, event: FileSystemEvent) -> None:
+        self._render("U", event)