yaml-reference 0.3.1__py3-none-any.whl

yaml_reference/__init__.py

@@ -0,0 +1,8 @@
+from yaml_reference.yaml import YAML
+
+__all__ = ["YAML"]
+
+# setattr(yaml, "load", recursively_resolve_after(yaml.load))
+# setattr(yaml, "load_all", recursively_resolve_after(yaml.load_all))
+# setattr(yaml, "dump", recursively_unresolve_before(yaml.dump))
+# setattr(yaml, "dump_all", recursively_unresolve_before(yaml.dump_all))

yaml_reference/anchor.py

@@ -0,0 +1,96 @@
+import io
+from typing import IO, Any
+
+from ruamel.yaml import (
+    YAML,
+    DocumentEndEvent,
+    DocumentStartEvent,
+    Event,
+    MappingEndEvent,
+    MappingStartEvent,
+    ScalarEvent,
+    SequenceEndEvent,
+    SequenceStartEvent,
+    StreamEndEvent,
+    StreamStartEvent,
+)
+
+
+def load_anchor_from_file(yaml: YAML, stream: IO, anchor: str) -> Any:
+    """
+    Load a YAML file and return the data as a dictionary.
+
+    Args:
+        yaml (YAML): The YAML loader object.
+        stream (IO): A file-like object containing the YAML data.
+        anchor (str): The anchor to resolve.
+
+    Returns:
+        Any: The loaded YAML data.
+    """
+    if anchor is None:
+        raise ValueError("Anchor cannot be None")
+    level = 0
+    events: list[Event] = []
+    for event in yaml.parse(stream):
+        if isinstance(event, ScalarEvent) and event.anchor == anchor:
+            event.anchor = None
+            events = [event]
+            break
+        elif isinstance(event, MappingStartEvent) and event.anchor == anchor:
+            event.anchor = None
+            events = [event]
+            level = 1
+        elif isinstance(event, SequenceStartEvent) and event.anchor == anchor:
+            event.anchor = None
+            events = [event]
+            level = 1
+        elif level > 0:
+            events.append(event)
+            if isinstance(event, (MappingStartEvent, SequenceStartEvent)):
+                level += 1
+            elif isinstance(event, (MappingEndEvent, SequenceEndEvent)):
+                level -= 1
+            if level == 0:
+                break
+    if not events:
+        raise ValueError(f"Anchor '{anchor}' not found in {stream.name}")
+    events = [StreamStartEvent(), DocumentStartEvent()] + events + [DocumentEndEvent(), StreamEndEvent()]
+
+    # Ensure we inherit the "stream name"
+    strio = io.StringIO()
+    setattr(strio, "name", stream.name)
+    # Get a fresh YAML instance
+    _yaml = yaml.__class__()
+    _yaml.emit(events, strio)
+    strio.seek(0)
+    return yaml.load(strio)
+
+
+def purge_anchors(yaml: YAML, stream: IO) -> IO:
+    """
+    Purge all anchors from the YAML stream.
+
+    Args:
+        yaml (YAML): The YAML loader object.
+        stream (IO): A file-like object containing the YAML data.
+
+    Returns:
+        IO: A file-like stream of YAML data with anchors removed.
+    """
+    events = list(yaml.parse(stream))
+    for i in range(len(events)):
+        if isinstance(events[i], ScalarEvent):
+            events[i].anchor = None
+        elif isinstance(events[i], MappingStartEvent):
+            events[i].anchor = None
+        elif isinstance(events[i], SequenceStartEvent):
+            events[i].anchor = None
+    # Ensure we inherit the "stream name"
+    strio = io.StringIO()
+    setattr(strio, "name", stream.name)
+    # Get a fresh YAML instance
+    _yaml = yaml.__class__()
+    _yaml.emit(events, strio)
+    strio.seek(0)
+    return strio

yaml_reference/cli.py

@@ -0,0 +1,47 @@
+def compile_main(
+    input_file: str = None,
+    output_file: str = None,
+):
+    """
+    Compile a YAML file containing !reference tags into a new YAML file with resolved references.
+
+    Args:
+        input_file (str): The path to the input YAML file. If not provided, the function will read from standard input.
+        output_file (str): The path to the output YAML file. If not provided, the function will write to standard output.
+    """
+    import sys
+    from pathlib import Path
+
+    from yaml_reference import YAML
+
+    yaml = YAML()
+
+    if input_file is None:
+        input_file = sys.stdin.read()
+        input_file = Path(input_file)
+    else:
+        input_file = Path(input_file)
+
+    if output_file is None:
+        output_file = sys.stdout
+    else:
+        output_file = Path(output_file)
+
+    data = yaml.load(input_file)
+    yaml.dump(data, output_file)
+
+
+def compile_cli():
+    import argparse
+
+    parser = argparse.ArgumentParser(
+        description="Compile a YAML file containing !reference tags into a new YAML file with resolved references."
+    )
+    parser.add_argument(
+        "-i", "--input", type=str, help="Path to the input YAML file. If not provided, reads from stdin."
+    )
+    parser.add_argument(
+        "-o", "--output", type=str, help="Path to the output YAML file. If not provided, writes to stdout."
+    )
+    args = parser.parse_args()
+    compile_main(args.input, args.output)

yaml_reference/errors.py

@@ -0,0 +1,10 @@
+class ConstructorException(Exception):
+    """Exception raised when a constructor fails to construct an object."""
+
+    pass
+
+
+class RepresenterException(Exception):
+    """Exception raised when a representer fails to represent an object."""
+
+    pass

yaml_reference/reference.py

@@ -0,0 +1,436 @@
+from pathlib import Path
+from typing import Any, Callable, Generic, Protocol, TypeVar, runtime_checkable
+
+from ruamel.yaml import BaseConstructor, Constructor, MappingNode, Node, Representer
+
+from yaml_reference import anchor
+from yaml_reference.errors import ConstructorException, RepresenterException
+
+
+def jmespath_search(data: Any, jmespath_expr: str) -> Any:
+    """
+    Perform a JMESPath search on the given data.
+
+    Args:
+        data (Any): The data to search.
+        jmespath_expr (str): The JMESPath expression to use for searching.
+
+    Returns:
+        Any: The result of the JMESPath search.
+    """
+    import jmespath
+
+    return jmespath.search(jmespath_expr, data)
+
+
+T = TypeVar("T")
+
+
+@runtime_checkable
+class Resolvable(Protocol, Generic[T]):
+    """
+    A protocol that defines a method for resolving a reference.
+
+    Attributes:
+        __resolved__ (bool): Indicates whether the reference has been resolved.
+        __resolved_value__ (T): The resolved value of the reference.
+
+    Methods:
+        resolve() -> T: Resolves the reference.
+    """
+
+    __resolved__: bool
+    __resolved_value__: T
+
+    @property
+    def resolved(self) -> bool:
+        """
+        Indicates whether the reference has been resolved.
+
+        Returns:
+            bool: True if the reference is resolved, False otherwise.
+        """
+        return self.__resolved__
+
+    def resolve(self, yaml) -> T:
+        """
+        Resolves the reference.
+
+        Returns:
+            T: The resolved value of the reference.
+        """
+        pass
+
+
+class Reference(Resolvable[Any]):
+    """
+    A class to represent a reference in a YAML file.
+
+    Attributes:
+        path (str): The path to the referenced file.
+    """
+
+    __local_file__: Path
+    path: Path
+    anchor: str | None  # Optional anchor name to reference in the file
+    jmespath: str | None  # Optional JMESPath expression to extract a specific value from the file
+
+    def __init__(self, local_file: Path, path: str, anchor: str | None = None, jmespath: str | None = None):
+        """
+        Initialize the Reference object with a path.
+
+        Args:
+            local_file (Path): The path to the local file containing the reference.
+            path (str): The path argument of the reference.
+            anchor (str, optional): The anchor name. Defaults to None.
+            jmespath (str, optional): The JMESPath expression. Defaults to None.
+        """
+        self.__resolved__ = False
+        self.__resolved_value__ = None
+        self.__local_file__ = local_file
+        self.path = local_file.parent / path
+        self.anchor = anchor
+        self.jmespath = jmespath
+
+    def __repr__(self) -> str:
+        """
+        Return a string representation of the Reference object.
+
+        Returns:
+            str: The string representation of the Reference object.
+        """
+        anchor_suffix = f"#{self.anchor}" if self.anchor else ""
+        jmespath_suffix = f", jmespath={self.jmespath}" if self.jmespath else ""
+        return f"Reference(path={self.path.relative_to(self.__local_file__.parent)}{anchor_suffix}{jmespath_suffix})"
+
+    def to_dict(self) -> dict[str, Any]:
+        """
+        Convert the Reference object to a dictionary.
+
+        Returns:
+            dict[str, Any]: The dictionary representation of the Reference object.
+        """
+        path_dict = {"path": str(self.path.relative_to(self.__local_file__.parent))}
+        if self.anchor:
+            path_dict["anchor"] = self.anchor
+        if self.jmespath:
+            path_dict["jmespath"] = self.jmespath
+        return path_dict
+
+    @classmethod
+    def from_yaml(cls, constructor: Constructor, node: Node) -> "Reference":
+        """
+        Create a Reference object from a YAML node.
+
+        Args:
+            constructor (Constructor): The YAML constructor.
+            node (Node): The YAML node.
+
+        Returns:
+            Reference: The created Reference object.
+        """
+        # local_file = Path(constructor.loader.reader.stream.name)
+        if not hasattr(constructor, "stream_name"):
+            raise ConstructorException("Constructor does not have a 'stream_name' attribute.")
+        local_file = Path(getattr(constructor, "stream_name", None))
+        if not isinstance(node, MappingNode):
+            raise ConstructorException(f"Invalid node type: {type(node)}")
+        dict_reference = BaseConstructor.construct_mapping(constructor, node)
+        return cls(local_file, **dict_reference)
+
+    @classmethod
+    def to_yaml(cls, representer: Representer, node: "Reference") -> Node:
+        """
+        Convert a Reference object to a YAML node.
+
+        Args:
+            representer (Representer): The YAML representer.
+            node (Reference): The Reference object.
+
+        Returns:
+            Node: The YAML node representing the Reference object.
+        """
+        if not isinstance(node, Reference):
+            raise RepresenterException(f"Invalid node type: {type(node)}")
+        return representer.represent_scalar("!reference", node.to_dict(), style="flow")
+
+    def resolve(self, loader: Any) -> Any:
+        """
+        Resolve the reference and return the resolved value.
+
+        Args:
+            loader (YAML): The YAML loader.
+
+        Returns:
+            Any: The resolved value of the reference.
+        """
+        if self.resolved:
+            return self.__resolved_value__
+
+        try:
+            if self.anchor:
+                data = anchor.load_anchor_from_file(loader, self.path.open("r"), self.anchor)
+            else:
+                data = loader.load(self.path.open("r"))
+            if self.jmespath:
+                data = jmespath_search(data, self.jmespath)
+        except ImportError as e:
+            raise ConstructorException(
+                "JMESPath expression is not supported because the 'jmespath' package is not installed.\n" + str(e)
+            ) from e
+        except Exception as e:
+            raise ConstructorException(f"Failed to resolve reference: {self.path.absolute()}\nException:\n{e}") from e
+        # setattr(data, "__resolvable__", self)
+        self.__resolved_value__ = data
+        self.__resolved__ = True
+        return self.__resolved_value__
+
+
+class ReferenceAll(Resolvable[list[Any]]):
+    """
+    A class to represent a reference to all YAML files matching a glob pattern.
+
+    Attributes:
+        path (str): The path to the referenced file.
+    """
+
+    __local_file__: Path
+    glob: str
+    anchor: str | None  # Optional anchor name to reference in each of the files
+    jmespath: str | None  # Optional JMESPath expression to extract a specific value from each of the files
+    paths: list[Path]  # List of paths matching the glob pattern
+
+    def __init__(self, local_file: Path, glob: str, anchor: str | None = None, jmespath: str | None = None):
+        """
+        Initialize the ReferenceAll object with a glob pattern.
+
+        Args:
+            local_file (Path): The path to the local file containing the reference.
+            glob (str): The glob pattern to match files.
+            anchor (str, optional): The anchor name. Defaults to None.
+            jmespath (str, optional): The JMESPath expression. Defaults to None.
+        """
+        self.__resolved__ = False
+        self.__resolved_value__ = None
+        self.__local_file__ = local_file
+        self.glob = glob
+        self.paths = list(local_file.parent.glob(glob))
+        self.anchor = anchor
+        self.jmespath = jmespath
+
+    def __repr__(self) -> str:
+        """
+        Return a string representation of the ReferenceAll object.
+
+        Returns:
+            str: The string representation of the ReferenceAll object.
+        """
+        anchor_suffix = f"#{self.anchor}" if self.anchor else ""
+        jmespath_suffix = f", jmespath={self.jmespath}" if self.jmespath else ""
+        return f"ReferenceAll(glob={self.glob}{anchor_suffix}{jmespath_suffix})"
+
+    def to_dict(self) -> dict[str, Any]:
+        """
+        Convert the ReferenceAll object to a dictionary.
+
+        Returns:
+            dict[str, Any]: The dictionary representation of the ReferenceAll object.
+        """
+        glob_dict = {"glob": str(self.glob)}
+        if self.anchor:
+            glob_dict["anchor"] = self.anchor
+        return glob_dict
+
+    @classmethod
+    def from_yaml(cls, constructor: Constructor, node: Node) -> "ReferenceAll":
+        """
+        Create a ReferenceAll object from a YAML node.
+
+        Args:
+            constructor (Constructor): The YAML constructor.
+            node (Node): The YAML node.
+
+        Returns:
+            ReferenceAll: The created ReferenceAll object.
+        """
+        # local_file = Path(constructor.loader.reader.stream.name)
+        if not hasattr(constructor, "stream_name"):
+            raise ConstructorException("Constructor does not have a 'stream_name' attribute.")
+        local_file = Path(getattr(constructor, "stream_name", None))
+        if not isinstance(node, MappingNode):
+            raise ConstructorException(f"Invalid node type: {type(node)}")
+        dict_reference = BaseConstructor.construct_mapping(constructor, node)
+        return cls(local_file, **dict_reference)
+
+    @classmethod
+    def to_yaml(cls, representer: Representer, node: "ReferenceAll") -> Node:
+        """
+        Convert a ReferenceAll object to a YAML node.
+
+        Args:
+            representer (Representer): The YAML representer.
+            node (ReferenceAll): The ReferenceAll object.
+
+        Returns:
+            Node: The YAML node representing the ReferenceAll object.
+        """
+        if not isinstance(node, ReferenceAll):
+            raise RepresenterException(f"Invalid node type: {type(node)}")
+        return representer.represent_scalar("!reference-all", node.to_dict(), style="flow")
+
+    def resolve(self, loader: Any) -> Any:
+        """
+        Resolve the reference and return the resolved value.
+
+        Args:
+            loader (YAML): The YAML loader.
+
+        Returns:
+            Any: The resolved value of the reference.
+        """
+        if self.resolved:
+            return self.__resolved_value__
+
+        data = []
+        for path in self.paths:
+            # we need to purge anchors from all loaded results.
+            anchored_yaml_stream = path.open("r")
+            anchorless_yaml_stream = anchor.purge_anchors(loader, path.open("r"))
+            next_data = (
+                anchor.load_anchor_from_file(loader, anchored_yaml_stream, self.anchor)
+                if self.anchor
+                else loader.load(anchorless_yaml_stream)
+            )
+            if self.jmespath:
+                next_data = jmespath_search(next_data, self.jmespath)
+            data.append(next_data)
+        if not data:
+            raise ConstructorException(f"Failed to resolve reference: {self.glob}")
+        # setattr(data, "__resolvable__", self)
+        self.__resolved_value__ = data
+        self.__resolved__ = True
+        return self.__resolved_value__
+
+
+def resolve(yaml, data: Any) -> Any:
+    """
+    Resolve a reference.
+
+    Args:
+        yaml (YAML): The YAML loader.
+        data (Any): The reference to resolve.
+
+    Returns:
+        Any: The resolved data.
+    """
+    if hasattr(data, "__resolved__") and hasattr(data, "resolve"):
+        return data.resolve(yaml)
+    return data
+
+
+def recursively_resolve(yaml: Any, data: Any) -> Any:
+    """
+    Recursively resolve all references in the given data.
+
+    Args:
+        yaml (YAML): The YAML loader.
+        data (Any): The data to resolve references in.
+
+    Returns:
+        Any: The data with all references resolved.
+    """
+    try:
+        if isinstance(data, list):
+            return [recursively_resolve(yaml, item) for item in data]
+        elif isinstance(data, dict):
+            return {key: recursively_resolve(yaml, value) for key, value in data.items()}
+        elif isinstance(data, Resolvable):
+            return resolve(yaml, data)
+        else:
+            return data
+    except ConstructorException as e:
+        raise ConstructorException(f"Error resolving reference: {e}") from e
+    except Exception as e:
+        raise ConstructorException(f"Unexpected error: {e}") from e
+
+
+def recursively_resolve_after(yaml, func: Callable) -> Callable:
+    """Decorator to resolve data after a function call.
+
+    Args:
+        yaml (YAML): The YAML loader.
+        func (Callable): Function to be decorated.
+
+    Returns:
+        Callable: Decorated function.
+    """
+
+    def wrapper(*args, **kwargs):
+        result = func(*args, **kwargs)
+        return recursively_resolve(yaml, result)
+
+    return wrapper
+
+
+##
+## Eventually, I'll figure out how to round-trip references and I'll use some sort of "unresolve" API.
+##
+
+
+def unresolve(data: Any) -> Any:
+    """
+    Unresolve a resolved value.
+
+    Args:
+        data (Any): The resolved value to unresolve.
+
+    Returns:
+        Any: The unresolved data.
+    """
+    if hasattr(data, "__resolvable__"):
+        return data.__resolvable__
+    return data
+
+
+def recursively_unresolve(data: Any) -> Any:
+    """
+    Recursively unresolve all references in the given data.
+
+    Args:
+        data (Any): The data to unresolve references in.
+
+    Returns:
+        Any: The data with all references unresolved.
+    """
+    try:
+        if isinstance(data, list):
+            return [recursively_unresolve(item) for item in data]
+        elif isinstance(data, dict):
+            return {key: recursively_unresolve(value) for key, value in data.items()}
+        elif isinstance(data, Resolvable):
+            return unresolve(data)
+        else:
+            return data
+    except RepresenterException as e:
+        raise RepresenterException(f"Error unresolving reference: {e}") from e
+    except Exception as e:
+        raise RepresenterException(f"Unexpected error: {e}") from e
+
+
+def recursively_unresolve_before(func: Callable) -> Callable:
+    """Decorator to unresolve data before a function call.
+
+    Args:
+        func (Callable): Function to be decorated.
+
+    Returns:
+        Callable: Decorated function.
+    """
+
+    def wrapper(*args, **kwargs):
+        result = recursively_unresolve(args[0])
+        args = (result,) + args[1:]
+        return func(*args, **kwargs)
+
+    return wrapper
+    return wrapper

yaml_reference/yaml.py

@@ -0,0 +1,47 @@
+from typing import IO, Callable
+
+from ruamel.yaml import YAML as _YAML
+from ruamel.yaml import Constructor, RoundTripConstructor
+
+from yaml_reference.reference import (
+    Reference,
+    ReferenceAll,
+    recursively_resolve_after,
+    recursively_unresolve_before,
+)
+
+
+def _attach_stream_name_to_constructor(yaml, func: Callable) -> Callable:
+    def wrapper(*args, **kwargs):
+        stream = args[0] if args else kwargs.get("stream")
+        yaml.constructor.stream_name = stream.name
+        yaml.Constructor.stream_name = stream.name
+        rval = func(*args, **kwargs)
+        yaml.constructor.stream_name = None
+        yaml.Constructor.stream_name = None
+        return rval
+
+    return wrapper
+
+
+class YAML(_YAML):
+    """
+    A class to represent a YAML object with custom loading and dumping behavior.
+    """
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.constructor.add_constructor("!reference", Reference.from_yaml)
+        self.constructor.add_constructor("!reference-all", ReferenceAll.from_yaml)
+        # I'm not sure which of these I should use, so I'll attach the state to both.
+        setattr(self.constructor, "stream_name", None)
+        setattr(self.Constructor, "stream_name", None)
+        self.load = _attach_stream_name_to_constructor(self, recursively_resolve_after(self, self.load))
+        self.load_all = _attach_stream_name_to_constructor(self, recursively_resolve_after(self, self.load_all))
+        # self.representer.add_representer(Reference, Reference.to_yaml)
+        # self.representer.add_representer(ReferenceAll, ReferenceAll.to_yaml)
+        # self.dump = recursively_unresolve_before(self.dump)
+        # self.dump_all = recursively_unresolve_before(self.dump_all)
+
+
+__all__ = ["YAML"]

yaml_reference-0.3.1.dist-info/METADATA

@@ -0,0 +1,157 @@
+Metadata-Version: 2.3
+Name: yaml-reference
+Version: 0.3.1
+Summary: 
+Author: David Sillman
+Author-email: dsillman2000@gmail.com
+Requires-Python: >=3.9,<4.0
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Requires-Dist: jmespath (>=1.0.1,<2.0.0)
+Requires-Dist: ruamel-yaml (>=0.18.11,<0.19.0)
+Description-Content-Type: text/markdown
+
+# yaml-reference
+
+Using `ruamel.yaml`, support cross-file references in YAML files using tags `!reference` and `!reference-all`.
+
+## Example
+
+```yaml
+# root.yaml
+version: "3.1"
+services:
+  - !reference
+    path: "services/website.yaml"
+
+  - !reference
+    path: "services/database.yaml"
+
+networkConfigs:
+  !reference-all
+  glob: "networks/*.yaml"
+
+```
+
+Supposing there are `services/website.yaml` and `services/database.yaml` files in the same directory as `root.yaml`, and a `networks` directory with YAML files, the above will be expanded to account for the referenced files with the following Python code:
+
+```python
+from yaml_reference import YAML
+
+yaml = YAML()
+with open("root.yaml", "r") as f:
+    data = yaml.load(f)
+```
+
+Note that the `YAML` class is a direct subclass of the base `ruamel.yaml.YAML` loader class, so the same API applies for customizing how it loads YAML files or other tags (e.g. `yaml = YAML(typ='safe')`).
+
+## CLI interface
+
+There is a CLI interface for this package which can be used to convert a YAML file which contains `!reference` tags into a single YAML file with all the references expanded. This is useful for generating a single file for deployment or other purposes.
+
+```bash
+$ yref-compile -h
+  usage: yref-compile [-h] [-i INPUT] [-o OUTPUT]
+
+  Compile a YAML file containing !reference tags into a new YAML file with resolved references.
+
+  options:
+    -h, --help            show this help message and exit
+    -i INPUT, --input INPUT
+                          Path to the input YAML file. If not provided, reads from stdin.
+    -o OUTPUT, --output OUTPUT
+                          Path to the output YAML file. If not provided, writes to stdout.
+$ yref-compile -i root.yaml
+  version: '3.1'
+  services:
+  - website
+  - database
+  networkConfigs:
+  - network: vpn
+    version: 1.1
+  - network: nfs
+    version: 1.0
+```
+
+## Anchor references
+
+You can supply the `!reference` / `!reference-all` tags with an anchor name to use for the reference.
+
+```yaml
+# root.yaml
+ports:
+  !reference-all
+  glob: "networks/*.yaml"
+  anchor: "port"
+```
+
+```yaml
+# networks/vpn.yaml
+name: vpn
+port: &port 8001
+```
+
+```yaml
+# networks/nfs.yaml
+name: nfs
+port: &port 2000
+```
+
+Loading the `root.yaml` file with the Python interface or converting it with the CLI will result in the following YAML (in no particular order):
+
+```yaml
+ports:
+  - 8001
+  - 2000
+```
+
+## JMESPath functionality
+
+You can also use JMESPath expressions to filter the results of references:
+
+```yaml
+# furthest.yml
+furthest-town-name:
+  !reference
+  path: "towns/all.yml"
+  jmespath: "max_by(towns, &distance).name"
+```
+
+```yaml
+#towns/all.yml
+towns:
+  !reference-all
+  glob: "towns/*.yml"
+```
+
+```yaml
+# towns/los_altos.yml
+name: Los Altos
+distance: 10
+# towns/sunnyvale.yml
+name: Sunnyvale
+distance: 5
+# towns/mountain_view.yml
+name: Mountain View
+distance: 15
+```
+
+Using the CLI or Python interface for loading the root `furthes.yml` file will yield the following result:
+
+```yaml
+furthest-town-name: Mountain View
+```
+
+See more information about JMESPath expressions in the [JMESPath documentation](https://jmespath.org/).
+
+## Acknowledgements
+
+Author(s):
+
+- David Sillman <dsillman2000@gmail.com>
+  - Personal website: https://www.dsillman.com
+

yaml_reference-0.3.1.dist-info/RECORD

@@ -0,0 +1,10 @@
+yaml_reference/__init__.py,sha256=HyIgDU13Yi4sS8ubNmUsk6yoetuGAP8K05stDbEuuuY,328
+yaml_reference/anchor.py,sha256=GbaNgoyy-NNSzRHkse3nb9eqWrcCNAR_ZRvZ0LKcRb8,2907
+yaml_reference/cli.py,sha256=jIMcepK4xzLdf_okklRZlojqO5pTaAZXX_KWevEgtTc,1427
+yaml_reference/errors.py,sha256=mrx2JpCPPA9zCLHLh_t7Wfuw6Ec0tMeKagAodvqYDQ4,252
+yaml_reference/reference.py,sha256=EZrEHa_EFuFW6LVU3snTnzZEHoD_fiHqDNDn5__YDzU,14294
+yaml_reference/yaml.py,sha256=pDXY4wj33l-hdaEF0AB8XgrJHpB4lPx6i-FW57rHZOQ,1785
+yaml_reference-0.3.1.dist-info/METADATA,sha256=1QpbShqmFsaH3MD-zXlqMB9jy-rKS8MTUD20rDoqhqw,3831
+yaml_reference-0.3.1.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
+yaml_reference-0.3.1.dist-info/entry_points.txt,sha256=BtGQpEHredeEjZrRp1IpeDPavol7YOuLF2aN2xw7pqI,63
+yaml_reference-0.3.1.dist-info/RECORD,,

yaml_reference-0.3.1.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: poetry-core 2.1.3
+Root-Is-Purelib: true
+Tag: py3-none-any

yaml_reference-0.3.1.dist-info/entry_points.txt

@@ -0,0 +1,3 @@
+[console_scripts]
+yref-compile=yaml_reference.cli:compile_cli
+