blurry-cli 0.11.0__tar.gz → 0.13.0__tar.gz

{blurry_cli-0.11.0 → blurry_cli-0.13.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: blurry-cli
-Version: 0.11.0
+Version: 0.13.0
 Summary: A Mistune-based static site generator for Python
 Home-page: https://github.com/blurry-dev/blurry
 License: MIT

{blurry_cli-0.11.0 → blurry_cli-0.13.0}/blurry/__init__.py

@@ -1,4 +1,5 @@
 import asyncio
+import concurrent.futures
 import dataclasses
 import importlib
 import json
@@ -7,7 +8,6 @@ import os
 import pkgutil
 import shutil
 import sys
-from collections.abc import Coroutine
 from copy import deepcopy
 from datetime import datetime
 from pathlib import Path
@@ -17,6 +17,10 @@ from jinja2 import Environment
 from livereload import Server
 from rich import print
 from rich.console import Console
+from rich.progress import BarColumn
+from rich.progress import Progress
+from rich.progress import TaskProgressColumn
+from rich.progress import TextColumn
 
 from blurry.async_typer import AsyncTyper
 from blurry.cli import print_blurry_name
@@ -54,51 +58,83 @@ warning_console = Console(stderr=True, style="bold yellow")
 app = AsyncTyper()
 
 
-async def process_non_markdown_file(filepath: Path):
+def process_non_markdown_file(
+    filepath: Path, file_data_by_directory, jinja_env: Environment
+):
+    # Process Jinja files
+    if ".jinja" in filepath.suffixes:
+        # Process file
+        process_jinja_file(filepath, jinja_env, file_data_by_directory)
+        return
+
     CONTENT_DIR = get_content_directory()
     mimetype, _ = mimetypes.guess_type(filepath, strict=False)
     relative_filepath = filepath.relative_to(CONTENT_DIR)
-    build_filepath = get_build_directory() / relative_filepath
-    output_file = Path(build_filepath)
-    output_file.parent.mkdir(exist_ok=True, parents=True)
+    output_file = get_build_directory() / relative_filepath
 
-    # Copy file to build directory
-    shutil.copyfile(filepath, build_filepath)
+    # Copy file to build directory if it is not already there
+    if not output_file.exists():
+        output_file.parent.mkdir(exist_ok=True, parents=True)
+        shutil.copyfile(filepath, output_file)
 
     # Create srcset images
     if mimetype in [
         mimetypes.types_map[".jpg"],
         mimetypes.types_map[".png"],
     ]:
-        await generate_images_for_srcset(filepath)
+        asyncio.run(generate_images_for_srcset(filepath))
 
 
-async def write_html_file(
-    file_data: MarkdownFileData,
-    file_data_list: list[MarkdownFileData],
+def process_jinja_file(filepath: Path, jinja_env: Environment, file_data_by_directory):
+    build_directory = get_build_directory()
+    content_directory = get_content_directory()
+    template = jinja_env.get_template(str(filepath.relative_to(content_directory)))
+    context = {
+        "file_data_by_directory": {
+            str(path): data for path, data in deepcopy(file_data_by_directory).items()
+        },
+        "settings": deepcopy(SETTINGS),
+        "datetime": datetime,
+    }
+    filepath_with_new_extension = filepath.with_suffix(
+        filepath.suffix.replace(".jinja", "")
+    )
+    filepath_in_build = build_directory / filepath_with_new_extension.relative_to(
+        content_directory
+    )
+    html = template.render(dataclasses=dataclasses, **context)
+    filepath_in_build.write_text(html)
+
+
+def write_html_file(
+    filepath: Path,
     file_data_by_directory: dict[Path, list[MarkdownFileData]],
     release: bool,
     jinja_env: Environment,
 ):
     extra_context: TemplateContext = {}
     # Gather data from other files in this directory if this is an index file
-    if file_data.path.name == "index.md":
+    file_data_list = file_data_by_directory[filepath.parent]
+    if filepath.name == "index.md":
         sibling_pages = [
             {
                 "url": content_path_to_url(f.path),
                 **f.front_matter,
             }
             for f in file_data_list
-            if f.path != file_data.path
+            if f.path != filepath
         ]
         extra_context["sibling_pages"] = sibling_pages
-    folder_in_build = convert_content_path_to_directory_in_build(file_data.path)
+    folder_in_build = convert_content_path_to_directory_in_build(filepath)
 
+    file_data = [
+        f for f in file_data_by_directory[filepath.parent] if f.path == filepath
+    ][0]
     schema_type = file_data.front_matter.get("@type")
     if not schema_type:
         raise ValueError(
             f"Required @type value missing in file or TOML front matter invalid: "
-            f"{file_data.path}"
+            f"{filepath}"
         )
     template_extension = SETTINGS["MARKDOWN_FILE_JINJA_TEMPLATE_EXTENSION"]
     template = jinja_env.get_template(f"{schema_type}{template_extension}")
@@ -124,12 +160,13 @@ async def write_html_file(
         default=json_converter_with_dates,
     )
 
-    validate_front_matter_as_schema(file_data.path, front_matter, warning_console)
+    validate_front_matter_as_schema(filepath, front_matter, warning_console)
 
     schema_type_tag = f'<script type="application/ld+json">{schema_data}</script>'
 
     template_context = {
         "body": file_data.body,
+        "filepath": filepath,
         "schema_data": schema_data,
         "schema_type_tag": schema_type_tag,
         "open_graph_tags": open_graph_meta_tags(file_data.front_matter),
@@ -154,40 +191,15 @@ async def write_html_file(
     write_index_file_creating_path(folder_in_build, html)
 
 
-@app.async_command()
-async def build(release=True):
-    """Generates HTML content from Markdown files."""
-
-    print_blurry_name()
-    print_plugin_table()
-
-    update_settings()
-    jinja_env = get_jinja_env()
-    os.environ.setdefault(f"{ENV_VAR_PREFIX}BUILD_MODE", "prod" if release else "dev")
-    CONTENT_DIR = get_content_directory()
-    BUILD_DIR = get_build_directory()
-    start = datetime.now()
-    path = Path(CONTENT_DIR)
+def gather_file_data_by_directory() -> DirectoryFileData:
+    # Sort file data by publishedDate/createdDate, descending, if present
     file_data_by_directory: DirectoryFileData = {}
-    if not BUILD_DIR.exists():
-        BUILD_DIR.mkdir(parents=True)
-
-    markdown_tasks: list[Coroutine] = []
-    non_markdown_tasks: list[Coroutine] = []
-
-    for filepath in path.glob("**/*.*"):
-        # Handle images and other files
-        if filepath.suffix != ".md":
-            non_markdown_tasks.append(process_non_markdown_file(filepath))
-            continue
-
-        # Handle Markdown files
+    content_directory = get_content_directory()
 
+    for filepath in content_directory.glob("**/*.md"):
         # Extract filepath for storing context data and writing out
-        relative_filepath = filepath.relative_to(CONTENT_DIR)
+        relative_filepath = filepath.relative_to(content_directory)
         directory = relative_filepath.parent
-        if directory not in file_data_by_directory:
-            file_data_by_directory[directory] = []
 
         # Convert Markdown file to HTML
         body, front_matter = convert_markdown_file_to_html(filepath)
@@ -196,33 +208,79 @@ async def build(release=True):
             front_matter=front_matter,
             path=relative_filepath,
         )
-        file_data_by_directory[directory].append(file_data)
+        try:
+            file_data_by_directory[directory].append(file_data)
+        except KeyError:
+            file_data_by_directory[directory] = [file_data]
 
-    non_markdown_tasks.append(write_sitemap_file(file_data_by_directory))
+    return sort_directory_file_data_by_date(file_data_by_directory)
 
-    # Sort file data by publishedDate/createdDate, descending, if present
-    file_data_by_directory = sort_directory_file_data_by_date(file_data_by_directory)
-
-    for file_data_list in file_data_by_directory.values():
-        for file_data in file_data_list:
-            markdown_tasks.append(
-                write_html_file(
-                    file_data,
-                    file_data_list,
+
+@app.async_command()
+async def build(release=True):
+    """Generates HTML content from Markdown files."""
+    start = datetime.now()
+
+    if release:
+        print_blurry_name()
+        print_plugin_table()
+
+    update_settings()
+    content_directory = get_content_directory()
+    build_directory = get_build_directory()
+    build_directory.mkdir(parents=True, exist_ok=True)
+    jinja_env = get_jinja_env()
+
+    os.environ.setdefault(f"{ENV_VAR_PREFIX}BUILD_MODE", "prod" if release else "dev")
+
+    file_data_by_directory = gather_file_data_by_directory()
+
+    markdown_task_count = 0
+    non_markdown_task_count = 1  # sitemap
+
+    with Progress(
+        TextColumn("[progress.description]{task.description}"),
+        BarColumn(),
+        TaskProgressColumn(),
+        transient=True,
+    ) as progress:
+        with concurrent.futures.ThreadPoolExecutor() as executor:
+            markdown_task = progress.add_task("[blue]Markdown")
+            other_task = progress.add_task("[blue]Other")
+
+            sitemap_future = executor.submit(write_sitemap_file, file_data_by_directory)
+            sitemap_future.add_done_callback(lambda _: progress.advance(other_task))
+
+            for filepath in content_directory.rglob("*"):
+                if filepath.is_dir():
+                    continue
+                if filepath.suffix == ".md":
+                    markdown_future = executor.submit(
+                        write_html_file,
+                        filepath.relative_to(content_directory),
+                        file_data_by_directory,
+                        release,
+                        jinja_env,
+                    )
+                    markdown_task_count += 1
+                    progress.update(markdown_task, total=markdown_task_count)
+                    markdown_future.add_done_callback(
+                        lambda _: progress.advance(markdown_task)
+                    )
+                    continue
+                other_future = executor.submit(
+                    process_non_markdown_file,
+                    filepath,
                     file_data_by_directory,
-                    release,
                     jinja_env,
                 )
-            )
-
-    content_dir_relative = CONTENT_DIR.relative_to(Path.cwd())
-    print(f"Blurring {len(markdown_tasks)} Markdown files from: {content_dir_relative}")
+                non_markdown_task_count += 1
+                progress.update(other_task, total=non_markdown_task_count)
+                other_future.add_done_callback(lambda _: progress.advance(other_task))
 
-    await asyncio.gather(*markdown_tasks)
-    loop = asyncio.new_event_loop()
-    asyncio.set_event_loop(loop)
-    for non_markdown_task in non_markdown_tasks:
-        await asyncio.to_thread(lambda: loop.run_until_complete(non_markdown_task))
+            print(
+                f"Blurring {markdown_task_count} Markdown files and {non_markdown_task_count} other files"
+            )
 
     end = datetime.now()
 
@@ -251,6 +309,9 @@ async def reload_local_plugins_and_build():
 @app.command()
 def runserver():
     """Starts HTTP server with live reloading."""
+    print_blurry_name()
+    print_plugin_table()
+
     update_settings()
     os.environ.setdefault(f"{ENV_VAR_PREFIX}BUILD_MODE", "dev")
 
@@ -259,14 +320,51 @@ def runserver():
     event_loop = asyncio.get_event_loop()
     event_loop.create_task(build_development())
 
+    jinja_env = get_jinja_env()
+
+    def handle_changed_jinja_files(filepaths: list[str]):
+        file_data_by_directory = gather_file_data_by_directory()
+        for filepath in filepaths:
+            process_jinja_file(
+                Path.cwd() / filepath,
+                jinja_env,
+                file_data_by_directory,
+            )
+
+    def handle_changed_markdown_files(filepaths: list[str]):
+        file_data_by_directory = gather_file_data_by_directory()
+        content_directory = get_content_directory()
+        for filepath in filepaths:
+            write_html_file(
+                filepath=(Path.cwd() / filepath).relative_to(content_directory),
+                file_data_by_directory=file_data_by_directory,
+                release=False,
+                jinja_env=jinja_env,
+            )
+
     livereload_server = Server()
+    livereload_server.watch(
+        f"{SETTINGS['CONTENT_DIRECTORY_NAME']}/**/*.jinja", handle_changed_jinja_files
+    )
+    livereload_server.watch(
+        f"{SETTINGS['CONTENT_DIRECTORY_NAME']}/**/*.md",
+        handle_changed_markdown_files,
+    )
     livereload_server.watch(
         f"{SETTINGS['CONTENT_DIRECTORY_NAME']}/**/*",
         lambda: event_loop.create_task(build_development()),
+        ignore=lambda filepath: any(
+            [
+                filepath.endswith(".md"),
+                filepath.endswith(".jinja"),
+                Path(filepath).is_dir(),
+            ]
+        ),
     )
     livereload_server.watch(
         f"{SETTINGS['TEMPLATES_DIRECTORY_NAME']}/**/*",
         lambda: event_loop.create_task(build_development()),
+        ignore=lambda filepath: Path(filepath).is_dir(),
     )
     livereload_server.watch(
         "./**/*.py",

{blurry_cli-0.11.0 → blurry_cli-0.13.0}/blurry/images.py

@@ -1,4 +1,4 @@
-import asyncio
+import concurrent.futures
 from pathlib import Path
 
 from wand.image import Image
@@ -30,7 +30,7 @@ def add_image_width_to_path(image_path: Path, width: int) -> Path:
     return Path(new_filename)
 
 
-async def convert_image_to_avif(image_path: Path, target_path: Path | None = None):
+def convert_image_to_avif(image_path: Path, target_path: Path | None = None):
     AVIF_COMPRESSION_QUALITY = SETTINGS["AVIF_COMPRESSION_QUALITY"]
     image_suffix = image_path.suffix
     avif_filepath = str(target_path or image_path).replace(image_suffix, ".avif")
@@ -42,31 +42,39 @@ async def convert_image_to_avif(image_path: Path, target_path: Path | None = Non
         image.save(filename=avif_filepath)
 
 
+def clone_and_resize_image(
+    image: Image, target_width: int, resized_image_destination: Path
+):
+    if resized_image_destination.exists():
+        return
+    image.transform(resize=str(target_width))
+    image.save(filename=resized_image_destination)
+
+
 async def generate_images_for_srcset(image_path: Path):
     BUILD_DIR = get_build_directory()
     CONTENT_DIR = get_content_directory()
+    filepaths_to_convert_to_avif = []
+
+    build_path = BUILD_DIR / image_path.resolve().relative_to(CONTENT_DIR)
+    with concurrent.futures.ThreadPoolExecutor() as executor:
+        with Image(filename=str(image_path)) as img:
+            width = img.width
+
+            for target_width in get_widths_for_image_width(width):
+                new_filepath = add_image_width_to_path(image_path, target_width)
+                relative_filepath = new_filepath.resolve().relative_to(CONTENT_DIR)
+                build_filepath = BUILD_DIR / relative_filepath
+                # We convert the resized images to AVIF, so do this synchronously
+                clone_and_resize_image(img, target_width, build_filepath)
+                filepaths_to_convert_to_avif.append(build_filepath)
 
-    with Image(filename=str(image_path)) as img:
-        width = img.width
         # Convert original image
-        build_path = BUILD_DIR / image_path.resolve().relative_to(CONTENT_DIR)
-        await convert_image_to_avif(image_path=image_path, target_path=build_path)
-
-        avif_files_to_create: list[Path] = []
-        for target_width in get_widths_for_image_width(width):
-            new_filepath = add_image_width_to_path(image_path, target_width)
-            relative_filepath = new_filepath.resolve().relative_to(CONTENT_DIR)
-            build_filepath = BUILD_DIR / relative_filepath
-            with img.clone() as resized:
-                avif_files_to_create.append(build_filepath)
-                if build_filepath.exists():
-                    continue
-                resized.transform(resize=str(target_width))
-                resized.save(filename=build_filepath)
-
-        await asyncio.gather(
-            *[convert_image_to_avif(avif_file) for avif_file in avif_files_to_create]
+        executor.submit(
+            convert_image_to_avif, image_path=image_path, target_path=build_path
         )
+        # Generate AVIF files for resized images
+        executor.map(convert_image_to_avif, filepaths_to_convert_to_avif)
 
 
 def get_widths_for_image_width(image_width: int) -> list[int]:

{blurry_cli-0.11.0 → blurry_cli-0.13.0}/blurry/markdown/__init__.py

@@ -84,7 +84,7 @@ class BlurryRenderer(mistune.HTMLRenderer):
                 attributes_str = " ".join(
                     f'{name}="{value}"' for name, value in attributes.items()
                 )
-                return f"<img {attributes_str} >"
+                return f"<img {attributes_str}>"
 
             image_widths = get_widths_for_image_width(image_width)
 
@@ -103,7 +103,7 @@ class BlurryRenderer(mistune.HTMLRenderer):
 
         return (
             f"<figure>"
-            f"<picture>{source_tag}<img {attributes_str} /></picture>"
+            f"<picture>{source_tag}<img {attributes_str}></picture>"
             f'<figcaption>{attributes["alt"]}</figcaption>'
             f"</figure>"
         )

{blurry_cli-0.11.0 → blurry_cli-0.13.0}/blurry/plugins/jinja_plugins/blurry_image_extension.py

@@ -73,4 +73,4 @@ class BlurryImage(StandaloneTag):
             f'{name}="{value}"' for name, value in attributes.items()
         )
 
-        return f"<img {attributes_str}/>"
+        return f"<img {attributes_str}>"

{blurry_cli-0.11.0 → blurry_cli-0.13.0}/blurry/sitemap.py

@@ -38,9 +38,7 @@ def generate_sitemap_for_file_data_list(file_data_list: list[MarkdownFileData])
     return SITEMAP_TEMPLATE.format(urls=sitemap_url_content)
 
 
-async def write_sitemap_file(
-    file_data_by_directory: dict[Path, list[MarkdownFileData]]
-):
+def write_sitemap_file(file_data_by_directory: dict[Path, list[MarkdownFileData]]):
     BUILD_DIR = get_build_directory()
     file_data = []
     for file_data_list in file_data_by_directory.values():

{blurry_cli-0.11.0 → blurry_cli-0.13.0}/blurry/templates.py

@@ -5,6 +5,7 @@ from jinja2 import select_autoescape
 
 from blurry.plugins import discovered_jinja_extensions
 from blurry.plugins import discovered_jinja_filter_plugins
+from blurry.settings import get_content_directory
 from blurry.settings import get_templates_directory
 from blurry.settings import SETTINGS
 
@@ -14,16 +15,16 @@ def get_jinja_env() -> Environment:
     Returns a Jinja environment complete with JinjaX and any installed Jinja extensions and filters.
     """
     templates_directory = get_templates_directory()
+    content_directory = get_content_directory()
     jinja_env = Environment(
-        loader=FileSystemLoader(templates_directory),
+        loader=FileSystemLoader([content_directory, templates_directory]),
         autoescape=select_autoescape(
-            list(
+            enabled_extensions=list(
                 {
                     SETTINGS["MARKDOWN_FILE_JINJA_TEMPLATE_EXTENSION"].lstrip("."),
-                    "html",
-                    "xml",
+                    "jinja",
                 }
-            )
+            ),
         ),
         extensions=[
             jinja_extension.load() for jinja_extension in discovered_jinja_extensions

{blurry_cli-0.11.0 → blurry_cli-0.13.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "blurry-cli"
-version = "0.11.0"
+version = "0.13.0"
 description = "A Mistune-based static site generator for Python"
 authors = ["John Franey <franey@duck.com>"]
 license = "MIT"