get_template source

        
def get_template(markata, template):
    """Get a template from the cache or compile it."""
    cache_key = str(template)
    if cache_key in _template_cache:
        return _template_cache[cache_key]

    if isinstance(template, str):
        template = markata.jinja_env.get_template(template)
    _template_cache[cache_key] = template
    return template

render_article source

        
def render_article(markata, cache, article):
    """Render an article using cached templates."""
    key = markata.make_hash(
        "post_template",
        __version__,
        article.key,
    )
    html = markata.precache.get(key)

    if html is not None:
        return html

    if isinstance(article.template, str):
        template = get_template(markata, article.template)
        html = render_template(markata, article, template)

    if isinstance(article.template, dict):
        html = {
            slug: render_template(markata, article, get_template(markata, template))
            for slug, template in article.template.items()
        }
    cache.set(key, html, expire=markata.config.default_cache_expire)
    return html

render_template source

        
def render_template(markata, article, template):
    """Render a template with article context."""
    merged_config = markata.config

    # Get the body content - prefer article_html, fallback to html
    body = getattr(article, "article_html", None)
    if body is None:
        body = getattr(article, "html", "")

    context = {
        "post": article,
        "markata": markata,
        "config": merged_config,
        "body": body,
    }

    try:
        return template.render(**context)
    except Exception as e:
        markata.console.print(f"[red]Error rendering template for {article.path}[/]")
        markata.console.print(f"[red]{str(e)}[/]")
        raise

cli source

        
def cli(app: typer.Typer, markata: "Markata") -> None:
    """
    Markata hook to implement base cli commands.
    """

    templates_app = typer.Typer()
    app.add_typer(templates_app, name="templates")

    @templates_app.callback()
    def templates():
        "template management"

    @templates_app.command()
    def show(
        template: str = typer.Argument(None, help="template to show"),
        theme: str = typer.Option(None, help="pygments syntax theme"),
    ) -> None:
        markata.console.quiet = False
        if template is not None:
            # Show specific template
            try:
                syntax = markata.jinja_env.get_template(template).source
                markata.console.print(syntax)
            except Exception as e:
                markata.console.print(
                    f"Error loading template {template}: {str(e)}", style="red"
                )

            return

        try:
            templates = markata.jinja_env.list_templates()
            markata.console.quiet = False
            markata.console.print("Templates directories:", style="green underline")

            # Show built-in templates directory
            markata_templates = Path(__file__).parents[1] / "templates"
            # markata.console.print(f"  {markata_templates} [grey50](built-in)[/]")

            # Show user template paths
            for path in markata.config.templates_dir:
                if path == markata_templates:
                    markata.console.print(f"  {path} [grey50](built-in)[/]")
                elif path == markata.config.dynamic_templates_dir:
                    markata.console.print(f"  {path} [grey50](dynamic)[/]")
                else:
                    markata.console.print(f"  {path}")

            markata.console.print("\nAvailable templates:", style="green underline")
            for template in sorted(templates):
                try:
                    source, file, uptodate = markata.jinja_env.loader.get_source(
                        markata.jinja_env, template
                    )
                    if Path(file).is_relative_to(markata.config.dynamic_templates_dir):
                        markata.console.print(
                            f"  {template} -> {file} [grey50](dynamic)[/]"
                        )
                    elif Path(file).is_relative_to(markata_templates):
                        markata.console.print(
                            f"  {template} -> {file} [grey50](built-in)[/]"
                        )
                    else:
                        markata.console.print(f"  {template} -> {file}")
                except Exception:
                    markata.console.print(f"  {template}")
        except Exception as e:
            markata.console.print(f"Error listing templates: {str(e)}", style="red")

MarkataTemplateCache source

        
class MarkataTemplateCache(jinja2.BytecodeCache):
    """Template bytecode cache for improved performance."""

    def __init__(self, directory):
        self.directory = Path(directory)
        self.directory.mkdir(parents=True, exist_ok=True)

    def load_bytecode(self, bucket):
        filename = self.directory / f"{bucket.key}.cache"
        if filename.exists():
            with open(filename, "rb") as f:
                bucket.bytecode_from_string(f.read())

    def dump_bytecode(self, bucket):
        filename = self.directory / f"{bucket.key}.cache"
        with open(filename, "wb") as f:
            f.write(bucket.bytecode_to_string())

configure source

        
def configure(markata: "Markata") -> None:
    """
    Massages the configuration limitations of toml to allow a little bit easier
    experience to the end user making configurations while allowing an simpler
    jinja template.  This enablees the use of the `markata.head.text` list in
    configuration.
    """

pre_render source

        
def pre_render(markata: "Markata") -> None:
    """
    FOR EACH POST: Massages the configuration limitations of toml/yaml to allow
    a little bit easier experience to the end user making configurations while
    allowing an simpler jinja template.  This enables the use of the
    `markata.head.text` list in configuration.
    """

    # markata.config.dynamic_templates_dir.mkdir(parents=True, exist_ok=True)
    # head_template = markata.config.dynamic_templates_dir / "head.html"
    # head_template.write_text(
    #     markata.jinja_env.get_template("dynamic_head.html").render(
    #         {"markata": markata}
    #     ),
    # )

    for article in [a for a in markata.articles if "config_overrides" in a]:
        raw_text = article.get("config_overrides", {}).get("head", {}).get("text", "")

        if isinstance(raw_text, list):
            article["config_overrides"]["head"]["text"] = "\n".join(
                flatten([t.values() for t in raw_text]),
            )

dynamic_templates_in_templates_dir source

        
def dynamic_templates_in_templates_dir(cls, value):
        """Ensure all required template directories are included in templates_dir.

        Args:
            value: The input templates_dir value, can be Path, str, or List[Path]

        Returns:
            List[Path]: List of template directories including markata templates and dynamic templates
        """
        markata_templates = Path(__file__).parents[1] / "templates"
        dynamic_templates_dir = Path(".markata.cache/templates")

        # Convert string to Path if needed
        if isinstance(value, str):
            value = Path(value)

        # Convert single Path to list
        if isinstance(value, Path):
            value = [value]

        # Ensure it's a list of Paths
        templates_dir = [Path(p) if isinstance(p, str) else p for p in value]

        # Add required directories if not present
        if markata_templates not in templates_dir:
            templates_dir.append(markata_templates)

        if dynamic_templates_dir not in templates_dir:
            templates_dir.append(dynamic_templates_dir)

        return templates_dir

templates source

        
def templates():
        "template management"