mkdocs-partial 1.2.1__py3-none-any.whl

mkdocs_partial/__init__.py

@@ -0,0 +1,24 @@
+import re
+
+from mkdocs_partial.mkdcos_helpers import replace_mkdocs_plugin_entrypoint
+
+PACKAGE_NAME_RESTRICTED_CHARS = re.compile(r"[^A-Za-z0-9+_-]")
+MODULE_NAME_RESTRICTED_CHARS = re.compile(r"[^a-z0-9+_]")
+PACKAGE_NAME = re.compile(r"^[A-Za-z0-9+_-]+$")
+
+SPELLCHECK_ENTRYPOINT_NAME = "spellcheck"
+SPELLCHECK_ENTRYPOINT_VALUE = "mkdocs_spellcheck.plugin:SpellCheckPlugin"
+SPELLCHECK_ENTRYPOINT_SHIM = "mkdocs_partial.integrations.spellcheck_plugin_shim:SpellCheckShim"
+SpellCheckShimActive = False  # pylint: disable=invalid-name
+
+MACROS_ENTRYPOINT_NAME = "macros"
+MACROS_ENTRYPOINT_VALUE = "mkdocs_macros.plugin:MacrosPlugin"
+MACROS_ENTRYPOINT_SHIM = "mkdocs_partial.integrations.macros_plugin_shim:MacrosPluginShim"
+
+REDIRECTS_ENTRYPOINT_NAME = "redirects"
+REDIRECTS_ENTRYPOINT_VALUE = "mkdocs_redirects.plugin:RedirectPlugin"
+REDIRECTS_ENTRYPOINT_SHIM = "mkdocs_partial.integrations.redirect_plugin_shim:RedirectPluginShim"
+
+replace_mkdocs_plugin_entrypoint(SPELLCHECK_ENTRYPOINT_NAME, SPELLCHECK_ENTRYPOINT_VALUE, SPELLCHECK_ENTRYPOINT_SHIM)
+replace_mkdocs_plugin_entrypoint(REDIRECTS_ENTRYPOINT_NAME, REDIRECTS_ENTRYPOINT_VALUE, REDIRECTS_ENTRYPOINT_SHIM)
+replace_mkdocs_plugin_entrypoint(MACROS_ENTRYPOINT_NAME, MACROS_ENTRYPOINT_VALUE, MACROS_ENTRYPOINT_SHIM)

mkdocs_partial/argparse_types.py

@@ -0,0 +1,14 @@
+import os
+from argparse import ArgumentTypeError
+
+
+def directory(value):
+    if not os.path.isdir(value):
+        raise ArgumentTypeError("Must be an existing directory")
+    return value
+
+
+def file(value):
+    if not os.path.isfile(value):
+        raise ArgumentTypeError("Must be an existing file")
+    return value

mkdocs_partial/docs_package_plugin.py

@@ -0,0 +1,224 @@
+# pylint: disable=unused-argument
+from __future__ import annotations
+
+import glob
+import inspect
+import logging
+import os
+import re
+from pathlib import Path
+from typing import Callable
+
+import frontmatter
+from mkdocs import plugins
+from mkdocs.config import Config, config_options
+from mkdocs.config.defaults import MkDocsConfig
+from mkdocs.livereload import LiveReloadServer
+from mkdocs.plugins import BasePlugin, PrefixedLogger, get_plugin_logger
+from mkdocs.structure.files import File, Files
+from mkdocs.structure.nav import Navigation
+from mkdocs.structure.pages import Page
+from mkdocs.utils.templates import TemplateContext
+
+import mkdocs_partial
+from mkdocs_partial import (
+    MACROS_ENTRYPOINT_NAME,
+    MACROS_ENTRYPOINT_SHIM,
+    REDIRECTS_ENTRYPOINT_NAME,
+    REDIRECTS_ENTRYPOINT_SHIM,
+    SPELLCHECK_ENTRYPOINT_NAME,
+    SPELLCHECK_ENTRYPOINT_SHIM,
+)
+from mkdocs_partial.integrations.material_blog_integration import MaterialBlogsIntegration
+from mkdocs_partial.mkdcos_helpers import get_mkdocs_plugin, get_mkdocs_plugin_name, normalize_path
+
+
+class DocsPackagePluginConfig(Config):
+    enabled = config_options.Type(bool, default=True)
+    docs_path = config_options.Optional(config_options.Type(str))
+    directory = config_options.Optional(config_options.Type(str))
+    edit_url_template = config_options.Optional(config_options.Type(str))
+    name = config_options.Optional(config_options.Type(str))
+    blog_categories = config_options.Optional(config_options.Type(str))
+
+
+class DocsPackagePlugin(BasePlugin[DocsPackagePluginConfig]):
+    supports_multiple_instances = True
+    H1_TITLE = re.compile(r"^#[^#]", flags=re.MULTILINE)
+    TITLE = re.compile(r"^#", flags=re.MULTILINE)
+
+    @property
+    def directory(self):
+        return self.__directory
+
+    def __init__(self, directory=None, edit_url_template=None, title=None, blog_categories=None):
+        self.__title = title
+        script_dir = os.path.dirname(os.path.realpath(inspect.getfile(self.__class__)))
+        self.__docs_path = os.path.join(script_dir, "docs")
+        self.__directory = directory
+        self.__edit_url_template = edit_url_template
+        self.__files: list[File] = []
+        self.__blog_integration = MaterialBlogsIntegration()
+        self.__plugin_name = ""
+        self.__log = get_plugin_logger("partial_docs")
+        self.__blog_categories = blog_categories
+        if self.__blog_categories is None:
+            self.__blog_categories = self.__title
+        if self.__blog_categories is None:
+            self.__blog_categories = self.__directory
+
+    def on_startup(self, *, command, dirty):
+        # Mkdocs handles plugins with on_startup singletons
+        pass
+
+    def on_shutdown(self) -> None:
+        # Disable shin in case mkdocs is rebuilding without doc_package plugins enabled
+        mkdocs_partial.SpellCheckShimActive = False
+        self.__blog_integration.shutdown()
+
+    @plugins.event_priority(100)
+    def on_pre_build(self, *, config: MkDocsConfig) -> None:
+        self.__blog_integration.sync()
+
+    @plugins.event_priority(-100)
+    def on_config(self, config: MkDocsConfig) -> MkDocsConfig | None:
+        if not self.config.enabled:
+            self.__blog_integration.stop()
+            return
+        if self.config.docs_path is not None:
+            self.__docs_path = self.config.docs_path
+
+        if self.config.directory is not None:
+            self.__directory = self.config.directory
+        if self.__directory is None:
+            self.__directory = ""
+        self.__directory = self.__directory.rstrip("/")
+
+        if self.config.name is not None:
+            self.__plugin_name = self.config.name
+        else:
+            self.__plugin_name = get_mkdocs_plugin_name(self, config)
+
+        logger = logging.getLogger(f"mkdocs.plugins.{__name__}")
+        self.__log = PrefixedLogger(f"partial_docs[{self.__plugin_name}]", logger)
+
+        if self.config.edit_url_template is not None:
+            self.__edit_url_template = self.config.edit_url_template
+        if self.config.blog_categories is not None:
+            self.__blog_categories = self.config.blog_categories
+
+        self.__blog_integration.init(config, self.__docs_path, self.__plugin_name, self.__blog_categories)
+
+        spellcheck_plugin = get_mkdocs_plugin(SPELLCHECK_ENTRYPOINT_NAME, SPELLCHECK_ENTRYPOINT_SHIM, config)
+        if spellcheck_plugin is not None and not mkdocs_partial.SpellCheckShimActive:
+            self.__log.info("Enabling `mkdocs_spellcheck` integration.")
+            mkdocs_partial.SpellCheckShimActive = True
+
+        macros_plugin = get_mkdocs_plugin(MACROS_ENTRYPOINT_NAME, MACROS_ENTRYPOINT_SHIM, config)
+        if macros_plugin is not None:
+            self.__log.info("Detected configured mkdocs_macros plugin. Registering filters")
+            macros_plugin.register_docs_package(self.__plugin_name, self)
+
+    def on_serve(
+        self, server: LiveReloadServer, /, *, config: MkDocsConfig, builder: Callable
+    ) -> LiveReloadServer | None:
+        if not self.config.enabled:
+            return server
+
+        if self.config.docs_path is not None:
+            if not self.__blog_integration.watch(server, config):
+                server.watch(self.config.docs_path)
+        return server
+
+    def on_files(self, files: Files, /, *, config: MkDocsConfig) -> Files | None:
+        if not self.config.enabled:
+            return files
+
+        self.__files = []
+        if not os.path.isdir(self.__docs_path):
+            return files
+
+        for file_path in glob.glob(os.path.join(self.__docs_path, "**/*.md"), recursive=True):
+            self.add_md_file(file_path, files, config)
+        for file_path in glob.glob(os.path.join(self.__docs_path, "**/*.png"), recursive=True):
+            self.add_media_file(file_path, files, config)
+
+        if mkdocs_partial.SpellCheckShimActive:
+            known_words = os.path.join(self.__docs_path, "known_words.txt")
+            if os.path.isfile(known_words):
+                self.add_media_file(known_words, files, config)
+
+        return files
+
+    def add_md_file(self, file_path, files: Files, config):
+        if self.__blog_integration.is_blog_related(file_path):
+            return
+
+        md = frontmatter.loads(Path(file_path).read_text(encoding="utf8"))
+        src_uri, is_index = self.get_src_uri(file_path)
+        existing_file = files.src_uris.get(src_uri, None)
+        if existing_file is not None:
+            existing = frontmatter.loads(existing_file.content_string)
+            content = existing.content + "\n\n" + md.content
+            if len(self.H1_TITLE.findall(content)) > 1:
+                content = self.TITLE.sub("##", content)
+
+            meta = dict(existing.metadata)
+            meta.update(md.metadata)
+            md = frontmatter.Post(content)
+            md.metadata.update(meta)
+            files.remove(existing_file)
+        if is_index and self.__title is not None:
+            md.metadata["title"] = self.__title
+        md.metadata["partial"] = True
+        md.metadata["docs_package"] = self.__plugin_name
+        file = File.generated(config=config, src_uri=src_uri, content=frontmatter.dumps(md))
+        files.append(file)
+        self.__files.append(file)
+
+        redirects_plugin = get_mkdocs_plugin(REDIRECTS_ENTRYPOINT_NAME, REDIRECTS_ENTRYPOINT_SHIM, config)
+        if redirects_plugin is not None:
+            normalized_redirects = [
+                f"{self.directory}/{redirect}".replace("\\", "/").replace("//", "/")
+                for redirect in md.metadata.get("redirects", [])
+            ]
+            redirects_plugin.add_redirects(files, file, normalized_redirects, config)
+
+    def on_page_context(
+        self, context: TemplateContext, /, *, page: Page, config: MkDocsConfig, nav: Navigation
+    ) -> TemplateContext | None:
+        if page.file in self.__files:
+            path = os.path.relpath(page.file.src_path, self.config.directory)
+            path = self.get_edit_url_template_path(path)
+        else:
+            path = self.__blog_integration.get_src_path(page.file.src_path)
+        if self.__edit_url_template is not None and path is not None:
+            page.edit_url = str(self.__edit_url_template).format(path=path)
+        return context
+
+    def add_media_file(self, path, files, config):
+        if self.__blog_integration.is_blog_related(path):
+            return
+        src_uri = self.get_src_uri(path)[0]
+        existing_file = files.src_uris.get(src_uri, None)
+        if existing_file is not None:
+            plugin_info = ""
+            if existing_file.generated_by is not None:
+                plugin_info = f"registered by '{existing_file.generated_by}' plugin"
+            self.__log.warning(
+                f"Can not register file '{src_uri}' as there is already file with same path.{plugin_info}"
+            )
+            return
+        file = File.generated(config=config, src_uri=src_uri, content=Path(path).read_bytes())
+        files.append(file)
+
+    def get_src_uri(self, file_path):
+        is_index = False
+        path = normalize_path(os.path.relpath(file_path, self.__docs_path))
+        if path.lower() == "index.md":
+            is_index = True
+        path = normalize_path(os.path.join(self.__directory, path)).lstrip("/")
+        return path, is_index
+
+    def get_edit_url_template_path(self, path):
+        return normalize_path(os.path.relpath(path, self.__directory))

mkdocs_partial/entry_point.py

@@ -0,0 +1,199 @@
+import logging
+import os
+import sys
+from argparse import ArgumentParser, ArgumentTypeError
+
+from mkdocs_partial import PACKAGE_NAME, PACKAGE_NAME_RESTRICTED_CHARS
+from mkdocs_partial.argparse_types import directory, file
+from mkdocs_partial.packages.packager import Packager
+from mkdocs_partial.version import __version__
+
+
+def package_name(value):
+    if not PACKAGE_NAME.match(value):
+        raise ArgumentTypeError(f"'{value}' is invalid package name")
+    return value
+
+
+def run():
+    logging.basicConfig(
+        level=logging.INFO,
+        format="{asctime} [{levelname}] {message}",
+        style="{",
+    )
+    parser = ArgumentParser(description=f"v{__version__}", prog="mkdocs-partial")
+    subparsers = parser.add_subparsers(help="commands")
+    package_command = add_command_parser(
+        subparsers, "package", "Creates partial documentation package from directory", func=package
+    )
+
+    add_packager_args(
+        package_command,
+        package_name_extra_help=" Default - normalized `--directory` value directory name.",
+        output_dir_extra_help=" Default - `--source-dir` value directory name.",
+    )
+    package_command.add_argument(
+        "--directory",
+        required=False,
+        help="Path in target documentation to inject documentation, relative to mkdocs `doc_dir`. "
+        "Pass empty string to inject files directly to mkdocs `docs_dir`"
+        "Default - `--source-dir` value directory name",
+    )
+    package_command.add_argument(
+        "--title",
+        required=False,
+        help="Override title if defined in package root index.md",
+    )
+    package_command.add_argument(
+        "--blog-categories",
+        required=False,
+        default="",
+        help="`/` separated list of  categories to  be prepended  to defined in blog posts of the package."
+        "Empty by default",
+    )
+    package_command.add_argument(
+        "--edit-url-template",
+        required=False,
+        help="f-string template for page edit url with {path} as placeholder for markdown file  path "
+        "relative to directory from --docs-dir",
+    )
+
+    site_package_command = add_command_parser(
+        subparsers, "site-package", "Creates documentation site-package package from  directory", func=site_package
+    )
+
+    add_packager_args(
+        site_package_command,
+        package_name_extra_help=" Default - `--source-dir` value directory name.",
+        output_dir_extra_help=" Default - `--source-dir` value directory name.",
+    )
+
+    freeze_command = add_command_parser(
+        subparsers, "freeze", "Pins doc package versions in requirements.txt to currently installed", func=freeze
+    )
+    freeze_command.add_argument(
+        "path",
+        type=file,
+        help="path to requirements.txt",
+    )
+
+    args = parser.parse_args()
+
+    if not hasattr(args, "func"):
+        parser.print_help()
+        sys.exit(0)
+    try:
+        success, message = args.func(args)
+        if not success:
+            print(message, file=sys.stderr)
+        elif message is not None:
+            print(message)
+    except Exception as e:  # pylint: disable=broad-exception-caught
+        logging.exception(f"FAIL! {e}")
+        success = False
+
+    sys.exit(0 if success else 1)
+
+
+def add_command_parser(subparsers, name, help_text, func):
+    command_parser = subparsers.add_parser(name, help=help_text)
+    command_parser.set_defaults(func=func, commandName=name)
+    return command_parser
+
+
+def add_packager_args(
+    parser,
+    source_dir_help="Directory to be packaged. Default - current directory",
+    package_name_extra_help="",
+    output_dir_extra_help="",
+):
+    parser.add_argument(
+        "--source-dir",
+        required=False,
+        default=os.getcwd(),
+        type=directory,
+        help=source_dir_help,
+    )
+    parser.add_argument(
+        "--package-name",
+        required=False,
+        type=package_name,
+        help=f"Name of the package to build. {package_name_extra_help}",
+    )
+    parser.add_argument("--package-version", required=True, help="Version of the package to build")
+    parser.add_argument("--package-description", required=False, help="Description of the package to build")
+    parser.add_argument(
+        "--output-dir",
+        required=False,
+        type=directory,
+        help=f"Directory to write generated package file.{output_dir_extra_help}",
+    )
+    parser.add_argument(
+        "--exclude",
+        action="append",
+        required=False,
+        default=[],
+        help="Exclude glob (should be relative to directory provided with `--source-dir` ",
+    )
+    parser.add_argument(
+        "--freeze",
+        dest="freeze",
+        action="store_true",
+        help="Pin doc package versions in requirements.txt to currently installed."
+        " (if there is no requirements.txt in `--source-dir` directory, has no effect)",
+    )
+
+
+def package(args):
+    if args.directory is None:
+        args.directory = os.path.basename(args.source_dir)
+    if args.output_dir is None:
+        args.output_dir = args.source_dir
+    if args.package_name is None:
+        args.package_name = PACKAGE_NAME_RESTRICTED_CHARS.sub("-", args.directory.lower())
+
+    Packager("docs-package").pack(
+        package_name=args.package_name,
+        package_version=args.package_version,
+        package_description=args.package_description,
+        resources_src_dir=args.source_dir,
+        output_dir=args.output_dir,
+        resources_package_dir="docs",
+        requirements_path="requirements.txt",
+        freeze=args.freeze,
+        excludes=["requirements.txt", "requirements.txt.j2"] + args.exclude,
+        directory="None" if args.directory is None else f'"{args.directory}"',
+        edit_url_template="None" if args.edit_url_template is None else f'"{args.edit_url_template}"',
+        title="None" if args.title is None else f'"{args.title}"',
+        blog_categories="None" if args.blog_categories is None else f'"{args.blog_categories}"',
+    )
+    return True, None
+
+
+def site_package(args):
+    if args.output_dir is None:
+        args.output_dir = args.source_dir
+    if args.package_name is None:
+        args.package_name = PACKAGE_NAME_RESTRICTED_CHARS.sub("-", os.path.basename(args.source_dir).lower())
+
+    Packager("site-package").pack(
+        package_name=args.package_name,
+        package_version=args.package_version,
+        package_description=args.package_description,
+        resources_src_dir=args.source_dir,
+        output_dir=args.output_dir,
+        resources_package_dir="site",
+        requirements_path="requirements.txt",
+        freeze=args.freeze,
+        excludes=["requirements.txt", "requirements.txt.j2"] + args.exclude,
+    )
+    return True, None
+
+
+def freeze(args):
+    Packager.freeze(args.__path)
+    return True, None
+
+
+if __name__ == "__main__":
+    run()

mkdocs_partial/integrations/macros_plugin_shim.py

@@ -0,0 +1,36 @@
+import os.path
+from typing import Dict
+
+from mkdocs.config.defaults import MkDocsConfig
+from mkdocs_macros.plugin import MacrosPlugin  # pylint: disable=import-error
+
+from mkdocs_partial.docs_package_plugin import DocsPackagePlugin
+
+
+# NOTE: has to be replaced with register_filters implementation in PartialDocsPlugin
+#       once https://github.com/fralau/mkdocs-macros-plugin/issues/237 is released
+class MacrosPluginShim(MacrosPlugin):
+    def __init__(self):
+        super().__init__()
+        self.__docs_packages: Dict[str, DocsPackagePlugin] = {}
+
+    def register_docs_package(self, name: str, package: DocsPackagePlugin):
+        self.__docs_packages[name] = package
+
+    def package_link(self, value, name: str = None):
+        page = self.page
+        if name is None:
+            name = page.meta.get("docs_package", None)
+
+        package = self.__docs_packages.get(name, None)
+        if package is not None:
+            url = os.path.relpath(f"{package.directory}/{value}", os.path.dirname(page.file.src_path))
+            url = url.replace("\\", "/")
+            return url
+        if name is None:
+            raise LookupError("`package_link` may be used only on pages managed with `docs_package` plugin")
+        raise LookupError(f"Package {name} is not installed")
+
+    def on_config(self, config: MkDocsConfig):
+        self.filter(self.package_link)
+        return super().on_config(config)

mkdocs_partial/integrations/material_blog_integration.py

@@ -0,0 +1,149 @@
+import filecmp
+import glob
+import os
+import posixpath
+import shutil
+from abc import ABC
+from pathlib import Path
+from typing import List
+
+import frontmatter
+import watchdog.events
+from mkdocs.config.defaults import MkDocsConfig
+from mkdocs.livereload import LiveReloadServer
+
+from mkdocs_partial.mkdcos_helpers import get_mkdocs_plugin, mkdocs_watch_ignore_path
+
+
+class MaterialBlogsIntegration(ABC):
+    def __init__(self):
+        super().__init__()
+        self.__enabled: bool = False
+
+        self.__partial: str | None = None
+        self.__source: str | None = None
+        self.__target: str | None = None
+        self.__categories: list[str] = []
+        self.__docs_path: str | None = None
+        self.__docs_dir: str | None = None
+        self.__stop = lambda *args: None
+
+    def init(self, config: MkDocsConfig, docs_path: str, name: str, categories: str = ""):
+        blog_plugin = get_mkdocs_plugin("material/blog", "material.plugins.blog.plugin:BlogPlugin", config)
+        self.__enabled = blog_plugin is not None
+        if self.__enabled:
+            root = posixpath.normpath(blog_plugin.config.data.get("blog_dir", "blog"))
+            blog_posts = blog_plugin.config.data.get("post_dir", "{blog}/posts").format(blog=root)
+            self.__source = os.path.join(docs_path, blog_posts)
+            self.__docs_dir = config.docs_dir
+            self.__partial = os.path.join(self.__docs_dir, blog_posts, "partial")
+            self.__target = os.path.join(self.__partial, name)
+            self.__categories = [] if categories == "" else categories.split("/")
+            self.__docs_path = docs_path
+        return self.__enabled
+
+    def watch(self, server: LiveReloadServer, config: MkDocsConfig):
+        if not self.__enabled:
+            return False
+        mkdocs_watch_ignore_path(server, config, self.__source, self.__docs_path)
+
+        def blogs_callback(event: watchdog.events.FileSystemEvent):
+            # ignore directory events - teh do not affect blogs
+            if event.is_directory:
+                return
+
+            # ignore events for files out of self.__source, likely self.__source was created after
+            # watch started and watched dir its parent
+            if not (event.src_path is not None and Path(event.src_path).is_relative_to(self.__source)) and not (
+                event.dest_path is not None and Path(event.dest_path).is_relative_to(self.__source)
+            ):
+                return
+
+            self.sync()
+
+        handler = watchdog.events.FileSystemEventHandler()
+        handler.on_any_event = blogs_callback  # type: ignore[method-assign]
+
+        # If source dir does not exist get up the tree in case it would be created later
+        source_watch_dir = self.__source
+        while not os.path.isdir(source_watch_dir) and source_watch_dir is not None:
+            if os.path.dirname(source_watch_dir) != source_watch_dir:
+                source_watch_dir = os.path.dirname(source_watch_dir)
+            else:
+                source_watch_dir = None
+
+        if source_watch_dir is not None:
+            watch = server.observer.schedule(handler, source_watch_dir, recursive=True)
+
+            def unsubscribe():
+                try:
+                    server.observer.unschedule(watch)
+                except KeyError:
+                    # At the moment mkdocs unschedules all watches,
+                    # unsubscribe is just in case it changes in later releases
+                    pass
+                self.__stop = lambda *args: None
+
+            self.__stop = unsubscribe
+        return True
+
+    def sync(self):
+        if not self.__enabled:
+            return
+        posts = []
+        for file_path in glob.glob(os.path.join(self.__source, "**/*.md"), recursive=True):
+            if os.path.isfile(file_path):
+                md = frontmatter.loads(Path(file_path).read_text(encoding="utf8"))
+                abs_path = os.path.join(self.__target, os.path.relpath(file_path, self.__source))
+                Path(os.path.dirname(abs_path)).mkdir(parents=True, exist_ok=True)
+                categories: List[str] = md.metadata.setdefault("categories", [])
+                if not isinstance(categories, list):
+                    md.metadata["categories"] = self.__categories
+                else:
+                    md.metadata["categories"] = self.__categories + categories
+                if not os.path.isfile(abs_path) or Path(abs_path).read_text(encoding="utf8") != frontmatter.dumps(md):
+                    frontmatter.dump(md, abs_path)
+                posts.append(os.path.normpath(abs_path))
+
+        for file_path in glob.glob(os.path.join(self.__target, "**/*.md"), recursive=True):
+            if os.path.isfile(file_path):
+                if os.path.normpath(file_path) not in posts:
+                    os.remove(file_path)
+
+        media = []
+        for file_path in glob.glob(os.path.join(self.__source, "**/*.png"), recursive=True):
+            if os.path.isfile(file_path):
+                abs_path = os.path.join(self.__target, os.path.relpath(file_path, self.__source))
+                if not os.path.isfile(abs_path) or not filecmp.cmp(abs_path, file_path):
+                    shutil.copyfile(file_path, abs_path)
+                media.append(os.path.normpath(abs_path))
+        for file_path in glob.glob(os.path.join(self.__target, "**/*.png"), recursive=True):
+            if os.path.isfile(file_path):
+                if os.path.normpath(file_path) not in media:
+                    os.remove(file_path)
+
+    def is_blog_related(self, path):
+        return self.__enabled and Path(path).is_relative_to(self.__source)
+
+    def shutdown(self):
+        if not self.__enabled:
+            return
+        self.stop()
+
+    def get_src_path(self, path):
+        if not self.__enabled:
+            return None
+        path = os.path.join(self.__docs_dir, path)
+        if Path(path).is_relative_to(self.__target):
+            path = os.path.join(self.__source, os.path.relpath(path, self.__target))
+            path = os.path.relpath(path, self.__docs_path)
+            return path
+        return None
+
+    def stop(self):
+        self.__stop()
+        if self.__enabled:
+            shutil.rmtree(self.__target, ignore_errors=True)
+            if os.path.isdir(self.__partial) and not os.listdir(self.__partial):
+                shutil.rmtree(self.__partial, ignore_errors=True)
+        self.__enabled = False

mkdocs_partial/integrations/redirect_plugin_shim.py

@@ -0,0 +1,23 @@
+import frontmatter
+from mkdocs import plugins
+from mkdocs.config.defaults import MkDocsConfig
+from mkdocs.structure.files import File, Files, InclusionLevel
+from mkdocs_redirects.plugin import RedirectPlugin  # pylint: disable=import-error
+
+
+class RedirectPluginShim(RedirectPlugin):
+
+    @plugins.event_priority(-100)
+    def on_files(self, files, config, **kwargs):
+        return super().on_files(files, config, **kwargs)
+
+    def add_redirects(self, files: Files, file, redirect_from: list[str], config: MkDocsConfig):
+        for redirect in redirect_from:
+            self.config.setdefault("redirect_maps", {})[redirect] = file.src_path.replace("\\", "/")
+            # Register stub page to avoid warnings about missing link targets
+            stub = frontmatter.Post("Redirect")
+            stub.metadata["layout"] = "redirect"
+            file = File.generated(
+                config=config, src_uri=redirect, content=frontmatter.dumps(stub), inclusion=InclusionLevel.EXCLUDED
+            )
+            files.append(file)