nyl 0.1.1__tar.gz → 0.2.2__tar.gz

{nyl-0.1.1 → nyl-0.2.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: nyl
-Version: 0.1.1
+Version: 0.2.2
 Summary: Advanced templating engine for Kubernetes and GitOps.
 Author-email: Niklas Rosenstein <rosensteinniklas@gmail.com>
 License: MIT
@@ -15,7 +15,7 @@ Requires-Dist: nr-stream>=1.1.5
 Requires-Dist: pyyaml>=6.0.1
 Requires-Dist: requests>=2.32.3
 Requires-Dist: stablehash<0.3.0,>=0.2.1
-Requires-Dist: structured-templates<0.1.0,>=0.0.6
+Requires-Dist: structured-templates>=0.1.1
 Requires-Dist: typer>=0.12.3
 Requires-Dist: typing-extensions>=4.12.2
 Description-Content-Type: text/markdown

{nyl-0.1.1 → nyl-0.2.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "nyl"
-version = "0.1.1"  # sed'ed on publish in CI
+version = "0.2.2"  # sed'ed on publish in CI
 description = "Advanced templating engine for Kubernetes and GitOps."
 authors = [
     {name = "Niklas Rosenstein", email = "rosensteinniklas@gmail.com"},
@@ -20,7 +20,7 @@ dependencies = [
     "pyyaml>=6.0.1",
     "requests>=2.32.3",
     "stablehash>=0.2.1,<0.3.0",
-    "structured-templates>=0.0.6,<0.1.0",
+    "structured-templates>=0.1.1",
     "typer>=0.12.3",
     "typing-extensions>=4.12.2",
 ]

{nyl-0.1.1 → nyl-0.2.2}/src/kubernetes/dynamic/resource.pyi

@@ -40,3 +40,4 @@ class ResourceInstance:
     attributes: ResourceField
 
     def __getitem__(self, key: str) -> ResourceField | Any: ...
+    def to_dict(self) -> dict[str, Any]: ...

{nyl-0.1.1 → nyl-0.2.2}/src/nyl/commands/__init__.py

@@ -29,12 +29,14 @@ from . import profile  # noqa: E402
 from . import run  # noqa: F401, E402
 from . import secrets  # noqa: E402
 from . import template  # noqa: F401,E402
+from . import tools  # noqa: E402
 from . import tun  # noqa: E402
 
 app.add_typer(argocd.app)
 app.add_typer(new.app)
 app.add_typer(profile.app)
 app.add_typer(secrets.app)
+app.add_typer(tools.app)
 app.add_typer(tun.app)
 
 

{nyl-0.1.1 → nyl-0.2.2}/src/nyl/commands/run.py

@@ -6,7 +6,7 @@ import sys
 from tempfile import TemporaryDirectory
 from loguru import logger
 from typer import Argument, Option
-import yaml
+from nyl.tools import yaml
 from nyl.profiles import ActivatedProfile, ProfileManager
 from nyl.profiles.kubeconfig import _trim_to_context
 from nyl.tools.logging import lazy_str
@@ -56,7 +56,7 @@ def run(
             sys.exit(1)
 
         try:
-            kubeconfig_data = yaml.safe_load(kubeconfig.read_text())
+            kubeconfig_data = yaml.loads(kubeconfig.read_text())
             kubeconfig_data = _trim_to_context(kubeconfig_data, profile_name)
         except ValueError:
             logger.debug("Failed to parse the kubeconfig file/find context '{}'.", profile_name)
@@ -83,7 +83,7 @@ def run(
             tmpdir = TemporaryDirectory()
             atexit.register(tmpdir.cleanup)
             kubeconfig = Path(tmpdir.name) / "kubeconfig"
-            kubeconfig.write_text(yaml.dump(kubeconfig_data))
+            kubeconfig.write_text(yaml.dumps(kubeconfig_data))
             kubeconfig.chmod(0o600)
 
     profile = ActivatedProfile(kubeconfig)

nyl-0.2.2/src/nyl/commands/secrets.py

@@ -0,0 +1,61 @@
+"""
+Interact with the secrets providers configured in `nyl-secrets.yaml`.
+"""
+
+import json
+
+from typer import Option
+from nyl.secrets.config import SecretsConfig
+from nyl.tools.typer import new_typer
+
+
+app = new_typer(name="secrets", help=__doc__)
+
+# Initialized from callback for access by subcommands.
+provider: str
+
+
+@app.callback()
+def callback(
+    _provider: str = Option(
+        "default",
+        "--provider",
+        help="The name of the configured secrets provider to use.",
+        envvar="NYL_SECRETS",
+    ),
+) -> None:
+    """
+    Interact with the secrets providers configured in `nyl-secrets.yaml`.
+    """
+
+    global provider
+    provider = _provider
+
+
+@app.command()
+def list(
+    providers: bool = Option(
+        False, help="List the configured secrets providers instead of the current provider's available keys."
+    ),
+) -> None:
+    """
+    List the keys for all secrets in the provider.
+    """
+
+    secrets = SecretsConfig.load()
+    if providers:
+        for alias, impl in secrets.providers.items():
+            print(alias, impl)
+    else:
+        for key in secrets.providers[provider].keys():
+            print(key)
+
+
+@app.command()
+def get(key: str, pretty: bool = False) -> None:
+    """
+    Get the value of a secret as JSON.
+    """
+
+    secrets = SecretsConfig.load()
+    print(json.dumps(secrets.providers[provider].get(key), indent=4 if pretty else None))

{nyl-0.1.1 → nyl-0.2.2}/src/nyl/commands/template.py

@@ -6,7 +6,7 @@ from textwrap import indent
 from typing import Optional
 from loguru import logger
 from typer import Argument, Option
-import yaml
+from nyl.tools import yaml
 from nyl.generator import reconcile_generator
 from nyl.generator.dispatch import DispatchingGenerator
 from nyl.profiles import ProfileManager
@@ -66,6 +66,18 @@ def template(
         "This option must be disabled when passing the generated manifests to `kubectl apply --applyset=...`, as it "
         "would otherwise cause an error due to the label being present on the input data.",
     ),
+    default_namespace: Optional[str] = Option(
+        None,
+        help="The name of the Kubernetes namespace to fill in to Kubernetes resource that don't have a namespace set. "
+        "If this is not specified as an argument or via environment variables, it will default to the stem of the "
+        "manifest source filename. Note that if a manifest defines a Namespace resource, that namespace is used "
+        "instead, regardless of the value of this option. If a manifest source file defines multiple namespaces and a "
+        "resource without namespace is encountered, this option is considered if it matches one of the namespaces "
+        "defined in the file. Note that this option is usually problematic when rendering multiple files, as often "
+        "a single file is intended to deploy into a single namespace.\n\n"
+        "Note that Nyl's detection for cluster-scoped vs. namespace-scoped resources is not very good, yet.",
+        envvar="ARGOCD_APP_NAMESPACE",
+    ),
     inline: bool = Option(True, help="Evaluate Nyl inlined resources."),
     state_dir: Optional[Path] = Option(
         None, help="The directory to store state in (such as kubeconfig files).", envvar="NYL_STATE_DIR"
@@ -168,10 +180,10 @@ def template(
             )
 
         # Find the namespaces that are defined in the file. If we find any manifests without a namespace, we will
-        # inject that namespace name into them.
-        # Also find the applyset defined in the file.
+        # inject that namespace name into them. Also find the applyset defined in the file.
         namespaces: set[str] = set()
         applyset: ApplySet | None = None
+
         for manifest in list(source.manifests):
             if is_namespace_resource(manifest):
                 namespaces.add(manifest["metadata"]["name"])
@@ -185,23 +197,40 @@ def template(
                 applyset = ApplySet.load(manifest)
                 source.manifests.remove(manifest)
 
+        # Determine what namespace to fill in if we encounter resources without it.
+        current_default_namespace = default_namespace
+        if current_default_namespace is None:
+            if len(namespaces) == 1:
+                current_default_namespace = next(iter(namespaces))
+            elif len(namespaces) == 0:
+                current_default_namespace = source.file.stem
+        elif len(namespaces) > 2 and current_default_namespace not in namespaces:
+            logger.error(
+                "The specified --default-namespace='{}' is not defined in manifest source file '{}', despite it "
+                "defining {} namespaces. If your manifest source file defines multiple namespaces, the specified "
+                "--default-namespace must be one of the namespaces defined in it (the file current defines "
+                "the following namespaces: {})",
+                default_namespace,
+                source.file,
+                len(namespaces),
+                ", ".join(namespaces),
+            )
+            exit(1)
+
         if not applyset and project.config.settings.generate_applysets:
-            if len(namespaces) > 1:
+            if not current_default_namespace:
                 logger.opt(ansi=True).error(
-                    "Multiple namespaces defined in <yellow>{}</>, but automatic ApplySet generation is enabled. "
-                    "There can only be one namespace per source in this case.",
+                    "No default namespace defined for <yellow>{}</>, but it is required for the automatically "
+                    "generated nyl.io/v1/ApplySet resource (the ApplySet is named after the default namespace).",
                     source.file,
                 )
                 exit(1)
-            elif len(namespaces) == 1:
-                applyset_name = next(iter(namespaces))
-            else:
-                applyset_name = source.file.stem
 
+            applyset_name = current_default_namespace
+            applyset = ApplySet.new(applyset_name)
             logger.opt(ansi=True).info(
                 "Automatically creating ApplySet for <blue>{}</> (name: <magenta>{}</>).", source.file, applyset_name
             )
-            applyset = ApplySet.new(applyset_name)
 
         if applyset is not None:
             applyset.set_group_kinds(source.manifests)
@@ -223,7 +252,7 @@ def template(
                 kubectl.diff(Manifests([applyset.dump()]))
             else:
                 print("---")
-                print(yaml.safe_dump(applyset.dump()))
+                print(yaml.dumps(applyset.dump()))
 
         # Find all manifests without a namespace and inject the namespace name into them.
         # If there is an applyset, ensure they are marked as part of the applyset.
@@ -236,9 +265,9 @@ def template(
 
             if "metadata" not in manifest:
                 logger.opt(ansi=True).error(
-                    "Manifest in <yellow>'{}'</> has no <cyan>metadata</> key:\n\n{}",
+                    "A manifest in <yellow>'{}'</> has no <cyan>metadata</> key:\n\n{}",
                     source.file,
-                    indent(yaml.safe_dump(manifest), "  "),
+                    indent(yaml.dumps(manifest), "  "),
                 )
                 exit(1)
 
@@ -247,30 +276,23 @@ def template(
                     labels[APPLYSET_LABEL_PART_OF] = applyset.id
 
             if not is_cluster_scoped_resource(manifest) and "namespace" not in manifest["metadata"]:
-                if len(namespaces) > 1:
+                if not current_default_namespace:
                     logger.error(
-                        "Multiple namespaces defined in '{}', but manifest {}/{} does not have a namespace.",
+                        "A namespace-scoped manifest in '{}' has no namespace, and no default namespace is defined. "
+                        "Try defining a single namespace in the manifest source file, naming the manifest source file "
+                        "the same as that default namespace or passing the --default-namespace option.",
                         source.file,
-                        manifest["kind"],
-                        manifest["metadata"]["name"],
                     )
                     exit(1)
-                elif len(namespaces) == 0:
-                    logger.warning(
-                        "No namespaces defined in '{}', injecting 'default' into manifest {}/{}.",
-                        source.file,
-                        manifest["kind"],
-                        manifest["metadata"]["name"],
-                    )
-                    manifest["metadata"]["namespace"] = "default"
-                else:
-                    logger.trace(
-                        "Injecting namespace '{}' into manifest {}/{}.",
-                        next(iter(namespaces)),
-                        manifest["kind"],
-                        manifest["metadata"]["name"],
-                    )
-                    manifest["metadata"]["namespace"] = next(iter(namespaces))
+
+                logger.trace(
+                    "Injecting namespace '{}' into manifest {}/{}.",
+                    current_default_namespace,
+                    manifest["kind"],
+                    manifest["metadata"]["name"],
+                )
+                manifest["metadata"]["namespace"] = current_default_namespace
+
             elif not is_cluster_scoped_resource(manifest) and manifest["metadata"]["namespace"] not in namespaces:
                 logger.warning(
                     "Resource '{}/{}' in '{}' references namespace '{}', which is not defined in the file.",
@@ -295,7 +317,7 @@ def template(
             # If we're not going to be applying the manifests immediately via `kubectl`, we print them to stdout.
             for manifest in source.manifests:
                 print("---")
-                print(yaml.safe_dump(manifest))
+                print(yaml.dumps(manifest))
 
 
 def load_manifests(paths: list[Path]) -> list[ManifestsWithSource]:
@@ -325,7 +347,7 @@ def load_manifests(paths: list[Path]) -> list[ManifestsWithSource]:
 
     result = []
     for file in files:
-        manifests = Manifests(list(map(Manifest, filter(None, yaml.safe_load_all(file.read_text())))))
+        manifests = Manifests(list(map(Manifest, filter(None, yaml.loads_all(file.read_text())))))
         result.append(ManifestsWithSource(manifests, file))
 
     return result

nyl-0.2.2/src/nyl/commands/tools/__init__.py

@@ -0,0 +1,13 @@
+"""
+Swiss-army-knife for various common operations in conjunction with Nyl (Kubernetes, secrets management, etc).
+"""
+
+from nyl.tools.typer import new_typer
+
+
+app = new_typer(name="tools", help=__doc__)
+
+from . import sops  # noqa: E402
+from . import bcrypt  # noqa: F401,E402
+
+app.add_typer(sops.app)

nyl-0.2.2/src/nyl/commands/tools/bcrypt.py

@@ -0,0 +1,17 @@
+import sys
+from typing import Optional
+
+from bcrypt import gensalt, hashpw
+from . import app
+
+
+@app.command()
+def bcrypt(text: Optional[str] = None) -> None:
+    """
+    Bcrypt-hash the specified text. If no argument is specified, read from stdin.
+    """
+
+    if text is None:
+        text = sys.stdin.read()
+
+    print(hashpw(text.encode("utf-8"), gensalt()).decode("utf-8"))

nyl-0.1.1/src/nyl/commands/secrets.py → nyl-0.2.2/src/nyl/commands/tools/sops.py

@@ -1,8 +1,7 @@
 """
-Interact with the secrets providers configured in `nyl-secrets.yaml`.
+Utilities for SOPS files.
 """
 
-import json
 from pathlib import Path
 from shlex import quote
 import sys
@@ -17,60 +16,17 @@ from nyl.tools.logging import lazy_str
 from nyl.tools.typer import new_typer
 
 
-app = new_typer(name="secrets", help=__doc__)
-
-sops = new_typer(name="sops", help=__doc__)
-app.add_typer(sops)
-
-# Initialized from callback for access by subcommands.
-provider: str
-
-
-@app.callback()
-def callback(
-    _provider: str = Option(
-        "default", "--provider", help="The name of the configured secrets provider to use.", envvar="NYL_SECRETS"
-    ),
-) -> None:
-    """
-    Interact with the secrets providers configured in `nyl-secrets.yaml`.
-    """
-
-    global provider
-    provider = _provider
-
-
-@app.command()
-def list(
-    providers: bool = Option(
-        False, help="List the configured secrets providers instead of the current provider's available keys."
-    ),
-) -> None:
-    """
-    List the keys for all secrets in the provider.
-    """
-
-    secrets = SecretsConfig.load()
-    if providers:
-        for alias, impl in secrets.providers.items():
-            print(alias, impl)
-    else:
-        for key in secrets.providers[provider].keys():
-            print(key)
+app = new_typer(name="sops", help=__doc__)
 
 
 @app.command()
-def get(key: str, pretty: bool = False) -> None:
-    """
-    Get the value of a secret as JSON.
-    """
-
-    secrets = SecretsConfig.load()
-    print(json.dumps(secrets.providers[provider].get(key), indent=4 if pretty else None))
-
-
-@sops.command()
 def re_encrypt(
+    provider: str = Option(
+        "default",
+        "--provider",
+        help="The name of the configured secrets provider to use.",
+        envvar="NYL_SECRETS",
+    ),
     file: Optional[Path] = Option(
         None,
         help="The SOPS-file to re-encrypt. Defaults to the SOPS file mentioned in `nyl-secrets.yaml` "
@@ -110,7 +66,7 @@ def re_encrypt(
     sops.save(file_type)
 
 
-@sops.command()
+@app.command()
 def export_dotenv(
     file: Path,
     prefix: str = Option("", help="Only export keys with the given prefix, and strip the prefix."),

{nyl-0.1.1 → nyl-0.2.2}/src/nyl/generator/helmchart.py

@@ -9,7 +9,7 @@ from textwrap import indent
 from urllib.parse import parse_qs, urlparse
 
 from loguru import logger
-import yaml
+from nyl.tools import yaml
 from nyl.generator import Generator
 from nyl.resources.helmchart import ChartRef, HelmChart, ReleaseMetadata
 from nyl.tools.shell import pretty_cmd
@@ -152,7 +152,7 @@ class HelmChartGenerator(Generator[HelmChart], resource_type=HelmChart):
 
         with TemporaryDirectory() as tmp:
             values_file = Path(tmp) / "values.yaml"
-            values_file.write_text(yaml.safe_dump(res.spec.values))
+            values_file.write_text(yaml.dumps(res.spec.values))
 
             command = [
                 "helm",
@@ -207,6 +207,6 @@ class HelmChartGenerator(Generator[HelmChart], resource_type=HelmChart):
                     f"stderr:\n{indent(e.stderr.decode(), prefix)}"
                 )
 
-            manifests = Manifests(list(filter(None, yaml.safe_load_all(result.stdout.decode()))))
+            manifests = Manifests(list(filter(None, yaml.loads_all(result.stdout.decode()))))
 
             return manifests

{nyl-0.1.1 → nyl-0.2.2}/src/nyl/profiles/kubeconfig.py

@@ -5,8 +5,8 @@ import shlex
 import subprocess
 from typing import Any
 from urllib.parse import urlparse
-import yaml
 
+from nyl.tools import yaml
 from nyl.tools.shell import pretty_cmd
 from .config import KubeconfigFromSsh, LocalKubeconfig
 from loguru import logger
@@ -87,7 +87,7 @@ class KubeconfigManager:
                 raise ValueError(f"Unsupported Kubeconfig type: {source.__class__.__name__}")
 
         # Find the Kubernetes API host and port.
-        kubeconfig_data = yaml.safe_load(raw_kubeconfig.read_text())
+        kubeconfig_data = yaml.loads(raw_kubeconfig.read_text())
         kubeconfig_data = _trim_to_context(kubeconfig_data, source.context)
         server: str = kubeconfig_data["clusters"][0]["cluster"]["server"]
         api_host, api_port = (lambda parsed: (parsed.hostname, parsed.port or 443))(urlparse(server))
@@ -108,7 +108,7 @@ class KubeconfigManager:
     def get_updated_kubeconfig(
         self, *, profile_name: str, path: Path, context: str, api_host: str, api_port: int
     ) -> Path:
-        kubeconfig_data = yaml.safe_load(path.read_text())
+        kubeconfig_data = yaml.loads(path.read_text())
         kubeconfig_data = _trim_to_context(kubeconfig_data, context, rename_context=profile_name)
 
         # TODO: Do we need to support the Kubernetes API hosted on a subpath?
@@ -116,7 +116,7 @@ class KubeconfigManager:
 
         final_kubeconfig = self._state_dir / profile_name / "kubeconfig.local"
         final_kubeconfig.parent.mkdir(parents=True, exist_ok=True)
-        final_kubeconfig.write_text(yaml.safe_dump(kubeconfig_data))
+        final_kubeconfig.write_text(yaml.dumps(kubeconfig_data))
         final_kubeconfig.chmod(0o600)
 
         return final_kubeconfig

{nyl-0.1.1 → nyl-0.2.2}/src/nyl/resources/placeholder.py

@@ -51,6 +51,16 @@ class Placeholder(NylResource, api_version=API_VERSION_K8S):
                             "properties": {
                                 "spec": {
                                     "type": "object",
+                                    "properties": {
+                                        "message": {
+                                            "type": "string",
+                                            "description": "A message that describes the missing resource.",
+                                        },
+                                        "reason": {
+                                            "type": "string",
+                                            "description": "The reason why the resource is missing (e.g. 'NotFound').",
+                                        },
+                                    },
                                 },
                             },
                         }

{nyl-0.1.1 → nyl-0.2.2}/src/nyl/templating.py

@@ -2,15 +2,17 @@
 Implements Nyl's variant of structured templating.
 """
 
+from collections.abc import Mapping
 from contextlib import contextmanager
 from dataclasses import dataclass
-from typing import Any, Callable, ClassVar, Iterator, TypeVar, cast
+from typing import Any, Callable, ClassVar, Iterator, Sequence, TypeVar, cast
 from structured_templates import TemplateEngine as _TemplateEngine
 from structured_templates.exceptions import TemplateError
 from kubernetes.client.api_client import ApiClient
 
 from kubernetes.dynamic.client import DynamicClient
 from kubernetes.client.exceptions import ApiException
+from kubernetes.dynamic.resource import ResourceField, ResourceInstance
 from nyl.secrets.config import SecretProvider
 from nyl.tools.types import Manifest, Manifests
 
@@ -90,7 +92,67 @@ def lookup(api_version: str, kind: str, name: str, namespace: str) -> Any:
             raise LookupError(f"Resource '{kind}/{name}' not found in namespace '{namespace}'.")
         else:
             raise
-    return obj
+    return LookupResourceWrapper(obj)
+
+
+class LookupResourceWrapper(Mapping[str, Any]):
+    """
+    A wrapper for a Kubernetes resources returned by `lookup()` that permits looking up fields by `__getitem__()`
+    and `__getattr__()`. This wraps a `ResourceInstance` or `ResourceField`, which can later be treated by the
+    `NylTemplateEngine` to serialize into a dictionary when embedded into a manifest.
+
+    This class is needed because the YAML serializer will not be able to serialize the `ResourceInstance` or
+    `ResourceField` objects returned by `lookup()`.
+    """
+
+    @staticmethod
+    def maybe_wrap(obj: Any) -> Any:
+        if isinstance(obj, (ResourceInstance, ResourceField)):
+            return LookupResourceWrapper(obj)
+        if isinstance(obj, Sequence) and not isinstance(obj, str):
+            obj = [LookupResourceWrapper.maybe_wrap(x) for x in obj]
+        return obj
+
+    @staticmethod
+    def materialize(obj: Any) -> Any:
+        match obj:
+            case LookupResourceWrapper():
+                return obj.__obj.to_dict()
+            case str():
+                return obj
+        if isinstance(obj, Sequence):
+            return [LookupResourceWrapper.materialize(x) for x in obj]
+        if isinstance(obj, Mapping):
+            return {k: LookupResourceWrapper.materialize(v) for k, v in obj.items()}
+        return obj
+
+    def __init__(self, obj: ResourceInstance | ResourceField) -> None:
+        assert isinstance(obj, (ResourceInstance, ResourceField)), f"got {type(obj).__name__}"
+        self.__obj = obj
+
+    def __iter__(self) -> Iterator[str]:
+        if isinstance(self.__obj, ResourceInstance):
+            target = self.__obj.attributes
+        else:
+            target = self.__obj
+        for key, _ in target:
+            yield key
+
+    def __len__(self) -> int:
+        # TODO: Find a better (faster) way to get the length of the resource instance/field attributes.
+        return len(self.__obj.to_dict())
+
+    def __getattr__(self, key: str) -> Any:
+        return LookupResourceWrapper.maybe_wrap(getattr(self.__obj, key))
+
+    def __getitem__(self, key: str) -> Any:
+        return LookupResourceWrapper.maybe_wrap(self.__obj[key])
+
+
+class LookupError(Exception):
+    """
+    Raised when a `lookup()` call fails because the resource was not found.
+    """
 
 
 @dataclass
@@ -159,6 +221,7 @@ class NylTemplateEngine:
                         )
                     )
 
+        result = LookupResourceWrapper.materialize(result)
         return Manifests(result)
 
 

nyl-0.2.2/src/nyl/tools/yaml.py

@@ -0,0 +1,27 @@
+from collections.abc import Iterator
+from typing import Any, TextIO
+from yaml import SafeDumper, SafeLoader
+import yaml
+
+
+class PatchedSafeLoader(SafeLoader):
+    yaml_implicit_resolvers = SafeLoader.yaml_implicit_resolvers.copy()
+
+    # See https://github.com/yaml/pyyaml/issues/89
+    yaml_implicit_resolvers.pop("=")
+
+
+class PatchedSafeDumper(SafeDumper):
+    pass
+
+
+def dumps(data: Any) -> str:
+    return yaml.dump(data, Dumper=PatchedSafeDumper)
+
+
+def loads(text: str) -> Any:
+    return yaml.load(text, Loader=PatchedSafeLoader)
+
+
+def loads_all(stream: str | TextIO) -> Iterator[Any]:
+    return yaml.load_all(stream, Loader=PatchedSafeLoader)

{nyl-0.1.1 → nyl-0.2.2}/uv.lock

@@ -340,7 +340,7 @@ requires-dist = [
     { name = "pyyaml", specifier = ">=6.0.1" },
     { name = "requests", specifier = ">=2.32.3" },
     { name = "stablehash", specifier = ">=0.2.1,<0.3.0" },
-    { name = "structured-templates", specifier = ">=0.0.6,<0.1.0" },
+    { name = "structured-templates", specifier = ">=0.1.1" },
     { name = "typer", specifier = ">=0.12.3" },
     { name = "typing-extensions", specifier = ">=4.12.2" },
 ]
@@ -554,11 +554,11 @@ wheels = [
 
 [[package]]
 name = "structured-templates"
-version = "0.0.6"
+version = "0.1.1"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/f5/13/ff59332e935cc3569a70b4048bceadae6edb3b0e68e701410e1642ec0e0f/structured_templates-0.0.6.tar.gz", hash = "sha256:fbdb689c5cafbeecd9b4bc6f90fc31a1990385692e9f6852db2cc05d5d5503fb", size = 4866 }
+sdist = { url = "https://files.pythonhosted.org/packages/04/97/89afe2eecb86ecb2673ebec1d18cc80bd252559ad27dc8940ff5d8a9b45f/structured_templates-0.1.1.tar.gz", hash = "sha256:b94d6c6c0b8a193e869dfa2511cc3b8b73a88f7edd69ecaa9ff4fd5539b6c5dc", size = 6044 }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/c6/67/31a676f5bbfb86c17468371e2c465e8168d8dcbd1e7658ce64275731590e/structured_templates-0.0.6-py3-none-any.whl", hash = "sha256:591fcefcf3e474a94e45880abca1d745d176c1019855a046fe540138bbfa8582", size = 6640 },
+    { url = "https://files.pythonhosted.org/packages/18/02/d9b2946086264afae6fe757af1a64b8f1629197106b2c93399f5814174d4/structured_templates-0.1.1-py3-none-any.whl", hash = "sha256:72b9e1b8ead52f33e91028838ccdf6ea69e1373da6d26b7b3d20e628472d3eaa", size = 7261 },
 ]
 
 [[package]]