zensical 0.0.9__cp310-abi3-musllinux_1_2_i686.whl → 0.0.17__cp310-abi3-musllinux_1_2_i686.whl

zensical/config.py

@@ -1,7 +1,7 @@
-# Copyright (c) 2025 Zensical and contributors
+# Copyright (c) 2025-2026 Zensical and contributors
 
 # SPDX-License-Identifier: MIT
-# Third-party contributions licensed under DCO
+# All contributions are certified under the DCO
 
 # Permission is hereby granted, free of charge, to any person obtaining a copy
 # of this software and associated documentation files (the "Software"), to
@@ -26,22 +26,24 @@ from __future__ import annotations
 import hashlib
 import importlib
 import os
+from pathlib import Path
 import pickle
-import yaml
-
-try:
-    import tomllib
-except ModuleNotFoundError:
-    import tomli as tomllib  # type: ignore
+from typing import IO, Any
+from urllib.parse import urlparse
 
+import yaml
 from click import ClickException
 from deepmerge import always_merger
-from typing import Any, IO
 from yaml import BaseLoader, Loader, YAMLError
 from yaml.constructor import ConstructorError
-from urllib.parse import urlparse
 
-from .extensions.emoji import to_svg, twemoji
+from zensical.extensions.emoji import to_svg, twemoji
+
+try:
+    import tomllib
+except ModuleNotFoundError:
+    import tomli as tomllib  # type: ignore[no-redef]
+
 
 # ----------------------------------------------------------------------------
 # Globals
@@ -64,9 +66,7 @@ side, and use it directly when needed. It's a hack but will do for now.
 
 
 class ConfigurationError(ClickException):
-    """
-    Configuration resolution or validation failed.
-    """
+    """Configuration resolution or validation failed."""
 
 
 # ----------------------------------------------------------------------------
@@ -75,22 +75,17 @@ class ConfigurationError(ClickException):
 
 
 def parse_config(path: str) -> dict:
-    """
-    Parse configuration file.
-    """
+    """Parse configuration file."""
     # Decide by extension; no need to convert to Path
     _, ext = os.path.splitext(path)
     if ext.lower() == ".toml":
         return parse_zensical_config(path)
-    else:
-        return parse_mkdocs_config(path)
+    return parse_mkdocs_config(path)
 
 
 def parse_zensical_config(path: str) -> dict:
-    """
-    Parse zensical.toml configuration file.
-    """
-    global _CONFIG
+    """Parse zensical.toml configuration file."""
+    global _CONFIG  # noqa: PLW0603
     with open(path, "rb") as f:
         config = tomllib.load(f)
     if "project" in config:
@@ -102,11 +97,9 @@ def parse_zensical_config(path: str) -> dict:
 
 
 def parse_mkdocs_config(path: str) -> dict:
-    """
-    Parse mkdocs.yml configuration file.
-    """
-    global _CONFIG
-    with open(path, "r") as f:
+    """Parse mkdocs.yml configuration file."""
+    global _CONFIG  # noqa: PLW0603
+    with open(path, encoding="utf-8") as f:
         config = _yaml_load(f)
 
     # Apply defaults and return parsed configuration
@@ -114,24 +107,30 @@ def parse_mkdocs_config(path: str) -> dict:
     return _CONFIG
 
 
-def get_config():
-    """
-    Return configuration.
-    """
-    return _CONFIG
+def get_config() -> dict:
+    """Return configuration."""
+    # We assume this function is only called after populating `_CONFIG`.
+    return _CONFIG  # type: ignore[return-value]
 
 
 def get_theme_dir() -> str:
-    """
-    Return the theme directory.
-    """
+    """Return the theme directory."""
     path = os.path.dirname(os.path.abspath(__file__))
     return os.path.join(path, "templates")
 
 
+def get_custom_theme_dir(config: dict) -> str | None:
+    """Return the custom theme directory."""
+    path = os.path.dirname(os.path.abspath(__file__))
+    if config["theme"].get("custom_dir"):
+        return os.path.join(path, config["theme"].get("custom_dir"))
+
+    # Otherwise, return no path
+    return None
+
+
 def _apply_defaults(config: dict, path: str) -> dict:
-    """
-    Apply default settings in configuration.
+    """Apply default settings in configuration.
 
     Note that this is loosely based on the defaults that MkDocs sets in its own
     configuration system, which we won't port for compatibility right now, as
@@ -146,12 +145,12 @@ def _apply_defaults(config: dict, path: str) -> dict:
 
     # Set site directory
     set_default(config, "site_dir", "site", str)
-    if ".." in config.get("site_dir"):
+    if ".." in config.get("site_dir", ""):
         raise ConfigurationError("site_dir must not contain '..'")
 
     # Set docs directory
     set_default(config, "docs_dir", "docs", str)
-    if ".." in config.get("docs_dir"):
+    if ".." in config.get("docs_dir", ""):
         raise ConfigurationError("docs_dir must not contain '..'")
 
     # Set defaults for core settings
@@ -169,21 +168,27 @@ def _apply_defaults(config: dict, path: str) -> dict:
     set_default(config, "edit_uri", None, str)
 
     # Set defaults for repository name settings
+    docs_dir = config.get("docs_dir")
+    repo_names = {
+        "github.com": "GitHub",
+        "gitlab.com": "Gitlab",
+        "bitbucket.org": "Bitbucket",
+    }
+    edit_uris = {
+        "github.com": f"edit/master/{docs_dir}",
+        "gitlab.com": f"edit/master/{docs_dir}",
+        "bitbucket.org": f"src/default/{docs_dir}",
+    }
     repo_url = config.get("repo_url")
-    if repo_url and not config.get("repo_name"):
-        docs_dir = config.get("docs_dir")
+    if repo_url:
         host = urlparse(repo_url).hostname or ""
-        if host == "github.com":
-            set_default(config, "repo_name", "GitHub", str)
-            set_default(config, "edit_uri", f"edit/master/{docs_dir}", str)
-        elif host == "gitlab.com":
-            set_default(config, "repo_name", "GitLab", str)
-            set_default(config, "edit_uri", f"edit/master/{docs_dir}", str)
-        elif host == "bitbucket.org":
-            set_default(config, "repo_name", "Bitbucket", str)
-            set_default(config, "edit_uri", f"src/default/{docs_dir}", str)
-        elif host:
-            config["repo_name"] = host.split(".")[0].title()
+        if not config.get("repo_name"):
+            if host in repo_names:
+                set_default(config, "repo_name", repo_names[host], str)
+            elif host:
+                config["repo_name"] = host.split(".")[0].title()
+        if host in edit_uris:
+            set_default(config, "edit_uri", edit_uris[host], str)
 
     # Remove trailing slash from edit_uri if present
     edit_uri = config.get("edit_uri")
@@ -258,18 +263,12 @@ def _apply_defaults(config: dict, path: str) -> dict:
 
     # Set defaults for theme admonition icons
     admonition = set_default(icon, "admonition", {}, dict)
-    set_default(admonition, "note", None, str)
-    set_default(admonition, "abstract", None, str)
-    set_default(admonition, "info", None, str)
-    set_default(admonition, "tip", None, str)
-    set_default(admonition, "success", None, str)
-    set_default(admonition, "question", None, str)
-    set_default(admonition, "warning", None, str)
-    set_default(admonition, "failure", None, str)
-    set_default(admonition, "danger", None, str)
-    set_default(admonition, "bug", None, str)
-    set_default(admonition, "example", None, str)
-    set_default(admonition, "quote", None, str)
+    if isinstance(admonition, dict):
+        icon["admonition"] = {
+            str(key): str(value)
+            for key, value in admonition.items()
+            if value is not None
+        }
 
     # Set defaults for theme palette settings and normalize to list
     palette = theme.setdefault("palette", [])
@@ -292,73 +291,17 @@ def _apply_defaults(config: dict, path: str) -> dict:
             set_default(toggle, "name", None, str)
 
     # Set defaults for extra settings
+    if "extra" in config and not isinstance(config["extra"], dict):
+        raise ConfigurationError(
+            "The 'extra' setting must be a mapping/dictionary."
+        )
     extra = set_default(config, "extra", {}, dict)
-    set_default(extra, "homepage", None, str)
-    set_default(extra, "scope", None, str)
-    set_default(extra, "annotate", {}, dict)
-    set_default(extra, "tags", {}, dict)
-    set_default(extra, "generator", True, bool)
+
+    if "polyfills" in extra and not isinstance(extra["polyfills"], list):
+        raise ConfigurationError(
+            "The 'extra.polyfills' setting must be a list."
+        )
     set_default(extra, "polyfills", [], list)
-    set_default(extra, "analytics", None, dict)
-
-    # Set defaults for extra analytics settings
-    analytics = extra.get("analytics")
-    if analytics:
-        set_default(analytics, "provider", None, str)
-        set_default(analytics, "property", None, str)
-        set_default(analytics, "feedback", None, dict)
-
-        # Set defaults for extra analytics feedback settings
-        feedback = analytics.get("feedback")
-        if feedback:
-            set_default(feedback, "title", None, str)
-            set_default(feedback, "ratings", [], list)
-
-            # Set defaults for each rating entry
-            ratings = feedback.setdefault("ratings", [])
-            for entry in ratings:
-                set_default(entry, "icon", None, str)
-                set_default(entry, "name", None, str)
-                set_default(entry, "data", None, str)
-                set_default(entry, "note", None, str)
-
-    # Set defaults for extra consent settings
-    consent = extra.setdefault("consent", None)
-    if consent:
-        set_default(consent, "title", None, str)
-        set_default(consent, "description", None, str)
-        set_default(consent, "actions", [], list)
-
-        # Set defaults for extra consent cookie settings
-        cookies = consent.setdefault("cookies", {})
-        for key, value in cookies.items():
-            if isinstance(value, str):
-                cookies[key] = {"name": value, "checked": False}
-
-            # Set defaults for each cookie entry
-            set_default(cookies[key], "name", None, str)
-            set_default(cookies[key], "checked", False, bool)
-
-    # Set defaults for extra social settings
-    social = extra.setdefault("social", [])
-    for entry in social:
-        set_default(entry, "icon", None, str)
-        set_default(entry, "name", None, str)
-        set_default(entry, "link", None, str)
-
-    # Set defaults for extra alternate settings
-    alternate = extra.setdefault("alternate", [])
-    for entry in alternate:
-        set_default(entry, "name", None, str)
-        set_default(entry, "link", None, str)
-        set_default(entry, "lang", None, str)
-
-    # Set defaults for extra version settings
-    version = extra.setdefault("version", None)
-    if version:
-        set_default(version, "provider", None, str)
-        set_default(version, "default", None, str)
-        set_default(version, "alias", False, bool)
 
     # Ensure all non-existent values are all empty strings (for now)
     config["extra"] = _convert_extra(extra)
@@ -435,19 +378,38 @@ def _apply_defaults(config: dict, path: str) -> dict:
     tabbed = config["mdx_configs"].get("pymdownx.tabbed", {})
     if isinstance(tabbed.get("slugify"), dict):
         object = tabbed["slugify"].get("object", "pymdownx.slugs.slugify")
-        tabbed["slugify"] = _resolve(object)(**tabbed["slugify"].get("kwds"))
+        tabbed["slugify"] = _resolve(object)(
+            **tabbed["slugify"].get("kwds", {})
+        )
 
     # Table of contents extension configuration - resolve slugification function
     toc = config["mdx_configs"]["toc"]
     if isinstance(toc.get("slugify"), dict):
         object = toc["slugify"].get("object", "pymdownx.slugs.slugify")
-        toc["slugify"] = _resolve(object)(**toc["slugify"].get("kwds"))
+        toc["slugify"] = _resolve(object)(**toc["slugify"].get("kwds", {}))
 
     # Superfences extension configuration - resolve format function
     superfences = config["mdx_configs"].get("pymdownx.superfences", {})
     for fence in superfences.get("custom_fences", []):
         if isinstance(fence.get("format"), str):
             fence["format"] = _resolve(fence.get("format"))
+        elif isinstance(fence.get("format"), dict):
+            object = fence["format"].get(
+                "object", "pymdownx.superfences.fence_code_format"
+            )
+            fence["format"] = _resolve(object)(
+                **fence["format"].get("kwds", {})
+            )
+        if isinstance(fence.get("validator"), str):
+            fence["validator"] = _resolve(fence.get("validator"))
+        elif isinstance(fence.get("validator"), dict):
+            object = fence["validator"].get("object")
+            callable_object = (
+                _resolve(object) if object else lambda *args, **kwargs: True
+            )
+            fence["validator"] = callable_object(
+                **fence["validator"].get("kwds", {})
+            )
 
     # Ensure the table of contents title is initialized, as it's used inside
     # the template, and the table of contents extension is always defined
@@ -456,14 +418,31 @@ def _apply_defaults(config: dict, path: str) -> dict:
 
     # Convert plugins configuration
     config["plugins"] = _convert_plugins(config.get("plugins", []), config)
+
+    # Set up mkdocstrings, which touches plugins and Markdown extensions
+    if "mkdocstrings" in config["plugins"]:
+        mkdocstrings_config = config["plugins"]["mkdocstrings"]["config"]
+        if mkdocstrings_config.pop("enabled", True):
+            mkdocstrings_config["markdown_extensions"] = [
+                {ext: mdx_configs.get(ext, {})} for ext in markdown_extensions
+            ]
+            config["markdown_extensions"].append("mkdocstrings")
+            config["mdx_configs"]["mkdocstrings"] = mkdocstrings_config
+
+    # List all source files for mkdocstrings
+    config["source_files"] = _list_sources(config, path)
+
+    # Hash all templates, so we rebuild if something changes
+    config["template_hash"] = _hash(_list_templates(config))
     return config
 
 
 def set_default(
-    entry: dict, key: str, default: Any, data_type: type = None
-) -> any:
-    """
-    Set a key to a default value if it isn't set, and optionally cast it to the specified data type.
+    entry: dict, key: str, default: Any, data_type: type | None = None
+) -> Any:
+    """Set a key to a default value if it isn't set.
+
+    Optionally cast it to the specified data type.
     """
     if key in entry and entry[key] is None:
         del entry[key]
@@ -476,24 +455,70 @@ def set_default(
         try:
             entry[key] = data_type(entry[key])
         except (ValueError, TypeError) as e:
-            raise ValueError(f"Failed to cast key '{key}' to {data_type}: {e}")
+            raise ValueError(
+                f"Failed to cast key '{key}' to {data_type}: {e}"
+            ) from e
 
     # Return the resulting value
     return entry[key]
 
 
-def _hash(data: any) -> int:
-    """
-    Compute a hash for the given data.
-    """
-    hash = hashlib.sha1(pickle.dumps(data))
+def _hash(data: Any) -> int:
+    """Compute a hash for the given data."""
+    hash = hashlib.sha1(pickle.dumps(data))  # noqa: S324
     return int(hash.hexdigest(), 16) % (2**64)
 
 
+def _list_sources(config: dict, config_file: str) -> list[tuple[str, int]]:
+    """List all absolute links to source files for mkdocstrings."""
+    python_paths = (
+        config["plugins"]
+        .get("mkdocstrings", {})
+        .get("config", {})
+        .get("handlers", {})
+        .get("python", {})
+        .get("paths", ())
+    )
+    roots_with_hash = []
+    for python_path in python_paths:
+        path = Path(config_file).parent.joinpath(python_path).resolve()
+
+        # Collect all files under this root with modification times to detect
+        # changes. We'll replace this with proper dependency tracking later.
+        files = [(path, int(os.path.getmtime(path)))]
+        if path.is_dir():
+            for subpath in path.rglob("*"):
+                files.extend([(subpath, int(os.path.getmtime(subpath)))])
+        roots_with_hash.append((str(path), _hash(files)))
+
+    return sorted(roots_with_hash)
+
+
+def _list_templates(config: dict) -> list[tuple[str, int]]:
+    """List all template files in the theme directories."""
+    dirs = [get_theme_dir()]
+    if "custom_dir" in config["theme"]:
+        custom_dir = get_custom_theme_dir(config)
+        if custom_dir is not None:
+            dirs.append(custom_dir)
+
+    # Collect file paths and their mtimes
+    files_with_mtime = []
+    for directory in dirs:
+        for path, _, files in os.walk(directory):
+            if ".icons" in path:
+                continue
+            for file in files:
+                file_path = os.path.join(path, file)
+                mtime = int(os.path.getmtime(file_path))
+                files_with_mtime.append((file_path, mtime))
+
+    # Sort by file path for deterministic order
+    return sorted(files_with_mtime)
+
+
 def _convert_extra(data: dict | list) -> dict | list:
-    """
-    Recursively convert all None values in a dictionary or list to empty strings.
-    """
+    """Recursively convert None values in a dictionary/list to empty strings."""
     if isinstance(data, dict):
         # Process each key-value pair in the dictionary
         return {
@@ -502,7 +527,7 @@ def _convert_extra(data: dict | list) -> dict | list:
             else ("" if value is None else value)
             for key, value in data.items()
         }
-    elif isinstance(data, list):
+    if isinstance(data, list):
         # Process each item in the list
         return [
             _convert_extra(item)
@@ -510,14 +535,11 @@ def _convert_extra(data: dict | list) -> dict | list:
             else ("" if item is None else item)
             for item in data
         ]
-    else:
-        return data
+    return data
 
 
-def _resolve(symbol: str):
-    """
-    Resolve a symbol to its corresponding Python object.
-    """
+def _resolve(symbol: str) -> Any:
+    """Resolve a symbol to its corresponding Python object."""
     module_path, func_name = symbol.rsplit(".", 1)
     module = importlib.import_module(module_path)
     return getattr(module, func_name)
@@ -526,17 +548,15 @@ def _resolve(symbol: str):
 # -----------------------------------------------------------------------------
 
 
-def _convert_nav(nav: dict) -> dict:
-    """
-    Convert MkDocs navigation
-    """
+def _convert_nav(nav: list) -> list:
+    """Convert MkDocs navigation."""
     return [_convert_nav_item(entry) for entry in nav]
 
 
-def _convert_nav_item(item: str | dict | list) -> dict:
-    """
-    Convert MkDocs shorthand navigation structure into something more manageable
-    as we need to annotate each item with a title, URL, icon, and children.
+def _convert_nav_item(item: str | dict | list) -> dict | list:
+    """Convert MkDocs shorthand navigation structure into something manageable.
+
+    We need to annotate each item with a title, URL, icon, and children.
     """
     if isinstance(item, str):
         return {
@@ -550,19 +570,19 @@ def _convert_nav_item(item: str | dict | list) -> dict:
         }
 
     # Handle Title: URL
-    elif isinstance(item, dict):
+    if isinstance(item, dict):
         for title, value in item.items():
             if isinstance(value, str):
                 return {
                     "title": str(title),
-                    "url": value,
+                    "url": value.strip(),
                     "canonical_url": None,
                     "meta": None,
                     "children": [],
-                    "is_index": _is_index(value),
+                    "is_index": _is_index(value.strip()),
                     "active": False,
                 }
-            elif isinstance(value, list):
+            if isinstance(value, list):
                 return {
                     "title": str(title),
                     "url": None,
@@ -572,28 +592,25 @@ def _convert_nav_item(item: str | dict | list) -> dict:
                     "is_index": False,
                     "active": False,
                 }
+            raise TypeError(f"Unknown nav item value type: {type(value)}")
 
     # Handle a list of items
     elif isinstance(item, list):
         return [_convert_nav_item(child) for child in item]
-    else:
-        raise ValueError(f"Unknown nav item type: {type(item)}")
+
+    raise TypeError(f"Unknown nav item type: {type(item)}")
 
 
 def _is_index(path: str) -> bool:
-    """
-    Returns, whether the given path points to a section index.
-    """
-    return path.endswith(("index.md", "README.md"))
+    """Returns, whether the given path points to a section index."""
+    return os.path.basename(path) in ("index.md", "README.md")
 
 
 # -----------------------------------------------------------------------------
 
 
-def _convert_extra_javascript(value: list[any]) -> list:
-    """
-    Ensure extra_javascript uses a structured format.
-    """
+def _convert_extra_javascript(value: list) -> list:
+    """Ensure extra_javascript uses a structured format."""
     for i, item in enumerate(value):
         if isinstance(item, str):
             value[i] = {
@@ -608,9 +625,7 @@ def _convert_extra_javascript(value: list[any]) -> list:
             item.setdefault("async", False)
             item.setdefault("defer", False)
         else:
-            raise ValueError(
-                f"Unknown extra_javascript item type: {type(item)}"
-            )
+            raise TypeError(f"Unknown extra_javascript item type: {type(item)}")
 
     # Return resulting value
     return value
@@ -619,12 +634,10 @@ def _convert_extra_javascript(value: list[any]) -> list:
 # -----------------------------------------------------------------------------
 
 
-def _convert_markdown_extensions(value: any):
-    """
-    Convert Markdown extensions configuration to what Python Markdown expects.
-    """
+def _convert_markdown_extensions(value: Any) -> tuple[list[str], dict]:
+    """Convert Markdown extensions to what Python Markdown expects."""
     markdown_extensions = ["toc", "tables"]
-    mdx_configs = {"toc": {}, "tables": {}}
+    mdx_configs: dict[str, dict[str, Any]] = {"toc": {}, "tables": {}}
 
     # In case of Python Markdown Extensions, we allow to omit the necessary
     # quotes around the extension names, so we need to hoist the extensions
@@ -632,14 +645,24 @@ def _convert_markdown_extensions(value: any):
     # actually parse the configuration.
     if "pymdownx" in value:
         pymdownx = value.pop("pymdownx")
-        for ext, config in pymdownx.items():
+        for ext, conf in pymdownx.items():
             # Special case for blocks extension, which has another level of
             # nesting. This is the only extension that requires this.
             if ext == "blocks":
-                for block, config in config.items():
+                for block, config in conf.items():
                     value[f"pymdownx.{ext}.{block}"] = config
             else:
-                value[f"pymdownx.{ext}"] = config
+                value[f"pymdownx.{ext}"] = conf
+
+    # Same as for Python Markdown extensions, see above
+    if "zensical" in value:
+        zensical = value.pop("zensical")
+        for ext, conf in zensical.items():
+            if ext == "extensions":
+                for key, config in conf.items():
+                    value[f"zensical.{ext}.{key}"] = config
+            else:
+                value[f"zensical.{ext}"] = conf
 
     # Extensions can be defined as a dict
     if isinstance(value, dict):
@@ -664,16 +687,13 @@ def _convert_markdown_extensions(value: any):
 # ----------------------------------------------------------------------------
 
 
-def _convert_plugins(value: any, config: dict) -> list:
-    """
-    Convert plugins configuration to something we can work with.
-    """
+def _convert_plugins(value: Any, config: dict) -> dict:
+    """Convert plugins configuration to something we can work with."""
     plugins = {}
 
     # Plugins can be defined as a dict
     if isinstance(value, dict):
-        for name, data in value.items():
-            plugins[name] = data
+        plugins.update(value)
 
     # Plugins can also be defined as a list
     else:
@@ -730,8 +750,7 @@ def _convert_plugins(value: any, config: dict) -> list:
 def _yaml_load(
     source: IO, loader: type[BaseLoader] | None = None
 ) -> dict[str, Any]:
-    """
-    Load configuration file and resolve environment variables and parent files.
+    """Load configuration file, resolve environment variables and parent files.
 
     Note that INHERIT is only a bandaid that was introduced to allow for some
     degree of modularity, but with serious shortcomings. Zensical will use a
@@ -746,12 +765,12 @@ def _yaml_load(
             source.read()
             .replace("material.extensions", "zensical.extensions")
             .replace("materialx", "zensical.extensions"),
-            Loader=Loader,
+            Loader=Loader,  # noqa: S506
         )
     except YAMLError as e:
         raise ConfigurationError(
             f"Encountered an error parsing the configuration file: {e}"
-        )
+        ) from e
     if config is None:
         return {}
 
@@ -763,9 +782,10 @@ def _yaml_load(
         )
         if not os.path.exists(abspath):
             raise ConfigurationError(
-                f"Inherited config file '{relpath}' doesn't exist at '{abspath}'."
+                f"Inherited config file '{relpath}' "
+                f"doesn't exist at '{abspath}'."
             )
-        with open(abspath, "r") as fd:
+        with open(abspath, encoding="utf-8") as fd:
             parent = _yaml_load(fd, loader)
         config = always_merger.merge(parent, config)
 
@@ -773,9 +793,11 @@ def _yaml_load(
     return config
 
 
-def _construct_env_tag(loader: yaml.Loader, node: yaml.Node):
-    """
-    Assign value of ENV variable referenced at node.
+def _construct_env_tag(
+    loader: yaml.Loader,
+    node: yaml.ScalarNode | yaml.SequenceNode | yaml.MappingNode,
+) -> Any:
+    """Assign value of ENV variable referenced at node.
 
     MkDocs supports the use of !ENV to reference environment variables in YAML
     configuration files. We won't likely support this in Zensical, but for now
@@ -804,7 +826,7 @@ def _construct_env_tag(loader: yaml.Loader, node: yaml.Node):
     else:
         raise ConstructorError(
             context=f"expected a scalar or sequence node, but found {node.id}",
-            start_mark=node.start_mark,
+            context_mark=node.start_mark,
         )
 
     # Resolve environment variable