envstack 1.0.3__py3-none-any.whl

envstack/envshell.py

@@ -0,0 +1,143 @@
+#!/usr/bin/env python3
+#
+# Copyright (c) 2024-2026, Ryan Galloway (ryan@rsgalloway.com)
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are met:
+#
+#  - Redistributions of source code must retain the above copyright notice,
+#    this list of conditions and the following disclaimer.
+#
+#  - Redistributions in binary form must reproduce the above copyright notice,
+#    this list of conditions and the following disclaimer in the documentation
+#    and/or other materials provided with the distribution.
+#
+#  - Neither the name of the software nor the names of its contributors
+#    may be used to endorse or promote products derived from this software
+#    without specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+# ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+# LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+# CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+# SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+# INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+# CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+# ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+# POSSIBILITY OF SUCH DAMAGE.
+#
+
+"""
+Contains envshell wrapper class.
+
+Goal: drop the user into an interactive shell *without* sourcing their usual
+shell rc files, so prompt vars (PS1/PROMPT) set by envstack can survive.
+
+Notes:
+- You can override the detected shell with ENVSTACK_SHELL.
+  Examples:
+    ENVSTACK_SHELL=/bin/zsh envstack --shell
+    ENVSTACK_SHELL=pwsh envstack --shell
+"""
+
+import os
+from pathlib import Path
+from typing import List
+
+from . import config
+from .wrapper import Wrapper
+
+
+def _basename(p: str) -> str:
+    """Return the lowercase basename of a path, robustly."""
+    try:
+        return Path(p).name.lower()
+    except Exception:
+        return os.path.basename(p).lower()
+
+
+def _detect_shell_argv() -> List[str]:
+    """
+    Return argv list for a *clean* interactive shell.
+    """
+    shell = os.environ.get("ENVSTACK_SHELL", config.SHELL)
+
+    if os.name == "nt":
+        # Prefer COMSPEC if it looks like cmd.exe; otherwise allow pwsh/powershell.
+        comspec = os.environ.get("COMSPEC", "cmd.exe")
+
+        # If user explicitly asked for pwsh/powershell, honor it.
+        base = _basename(shell)
+        if base in ("pwsh", "pwsh.exe"):
+            return [shell, "-NoExit", "-NoProfile"]
+        if base in ("powershell", "powershell.exe"):
+            return [shell, "-NoExit", "-NoProfile"]
+
+        # Otherwise use cmd.exe, with /K to keep it open.
+        # (Even if config.SHELL returned "cmd", use COMSPEC so we get the real path.)
+        return [comspec, "/K"]
+
+    # POSIX shells
+    base = _basename(shell)
+
+    # bash: skip /etc/profile, ~/.bash_profile, ~/.bashrc, but stay interactive
+    if base == "bash":
+        return [shell, "--noprofile", "--norc", "-i"]
+
+    # zsh: -f skips zshrcs; -i for interactive
+    if base == "zsh":
+        return [shell, "-f", "-i"]
+
+    # tcsh/csh: -f skips rc; interactive by default when attached to a tty
+    if base in ("tcsh", "csh"):
+        return [shell, "-f"]
+
+    # fish: --no-config skips config.fish; interactive by default
+    if base == "fish":
+        return [shell, "--no-config"]
+
+    # Fallback: try interactive flag if common; otherwise just exec the shell
+    # (Most shells become interactive when connected to a tty anyway.)
+    return [shell, "-i"]
+
+
+class EnvshellWrapper(Wrapper):
+    """A wrapper that spawns an interactive shell with the environment set."""
+
+    def __init__(self, *args, **kwargs):
+        super(EnvshellWrapper, self).__init__(*args, **kwargs)
+        self.shell = False  # exec the shell directly
+
+    def executable(self):
+        """
+        Kept for interface compatibility. The actual argv is produced in
+        get_subprocess_command().
+        """
+        return ""
+
+    def get_subprocess_command(self, env):
+        """
+        Override to return argv list for subprocess.Popen(..., shell=False).
+        """
+        return _detect_shell_argv()
+
+    def get_shell_prompt(self) -> str:
+        """
+        Return the environment variable that controls the shell prompt and its
+        desired value.
+        """
+        if os.name == "nt":
+            return ("PROMPT", "$E[32m(${ENV:=${STACK}})$E[0m $P$G ")
+        else:
+            return ("PS1", r"\[\e[32m\](${ENV:=${STACK}})\[\e[0m\] \w\$ ")
+
+    def get_subprocess_env(self):
+        """
+        Override to inject PS1/PROMPT if not already set.
+        """
+        prompt_env, prompt_value = self.get_shell_prompt()
+        if prompt_env not in self.env:
+            self.env[prompt_env] = prompt_value
+        return super().get_subprocess_env()

envstack/exceptions.py

@@ -0,0 +1,82 @@
+#!/usr/bin/env python3
+#
+# Copyright (c) 2024-2026, Ryan Galloway (ryan@rsgalloway.com)
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are met:
+#
+#  - Redistributions of source code must retain the above copyright notice,
+#    this list of conditions and the following disclaimer.
+#
+#  - Redistributions in binary form must reproduce the above copyright notice,
+#    this list of conditions and the following disclaimer in the documentation
+#    and/or other materials provided with the distribution.
+#
+#  - Neither the name of the software nor the names of its contributors
+#    may be used to endorse or promote products derived from this software
+#    without specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+# ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+# LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+# CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+# SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+# INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+# CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+# ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+# POSSIBILITY OF SUCH DAMAGE.
+#
+
+__doc__ = """
+Contains custom exceptions.
+"""
+
+
+class CyclicalReference(Exception):
+    """Exception for circular references."""
+
+    pass
+
+
+class DuplicateFieldValues(Exception):
+    """Exception for template paths with duplicate values for the same field."""
+
+    pass
+
+
+class InvalidPath(Exception):
+    """Exception for paths that do not match a template."""
+
+    pass
+
+
+class InvalidSource(Exception):
+    """Exception for invalid .env file."""
+
+    pass
+
+
+class InvalidSyntax(Exception):
+    """Exception for invalid .env file syntax."""
+
+    pass
+
+
+class MissingFieldError(Exception):
+    """Custom exception class for missing required field values."""
+
+    pass
+
+
+class TemplateNotFound(Exception):
+    """Custom exception class for missing Templates."""
+
+    pass
+
+
+class WriteError(Exception):
+    """Custom exception class for errors during export operations."""
+
+    pass

envstack/logger.py

@@ -0,0 +1,61 @@
+#!/usr/bin/env python3
+#
+# Copyright (c) 2024-2026, Ryan Galloway (ryan@rsgalloway.com)
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are met:
+#
+#  - Redistributions of source code must retain the above copyright notice,
+#    this list of conditions and the following disclaimer.
+#
+#  - Redistributions in binary form must reproduce the above copyright notice,
+#    this list of conditions and the following disclaimer in the documentation
+#    and/or other materials provided with the distribution.
+#
+#  - Neither the name of the software nor the names of its contributors
+#    may be used to endorse or promote products derived from this software
+#    without specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+# ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+# LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+# CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+# SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+# INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+# CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+# ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+# POSSIBILITY OF SUCH DAMAGE.
+#
+
+import logging
+
+from envstack.config import LOG_LEVEL
+
+
+class Logger(logging.Logger):
+    """Custom logger class."""
+
+    def setLevel(self, level):
+        if isinstance(level, str):
+            level = getattr(logging, level.upper(), logging.NOTSET)
+        super().setLevel(level)
+
+
+log = Logger("envstack")
+log.setLevel(LOG_LEVEL)
+log.addHandler(logging.NullHandler())
+
+
+def setup_stream_handler():
+    """Adds a new stdout stream handler."""
+    for h in log.handlers:
+        if h.name == log.name and "StreamHandler" in str(h):
+            del log.handlers[log.handlers.index(h)]
+    stream_hanlder = logging.StreamHandler()
+    stream_hanlder.set_name(log.name)
+    stream_hanlder.setFormatter(
+        logging.Formatter("%(asctime)s:%(name)s:%(levelname)s - %(message)s")
+    )
+    log.addHandler(stream_hanlder)

envstack/node.py

@@ -0,0 +1,410 @@
+#!/usr/bin/env python3
+#
+# Copyright (c) 2024-2026, Ryan Galloway (ryan@rsgalloway.com)
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are met:
+#
+#  - Redistributions of source code must retain the above copyright notice,
+#    this list of conditions and the following disclaimer.
+#
+#  - Redistributions in binary form must reproduce the above copyright notice,
+#    this list of conditions and the following disclaimer in the documentation
+#    and/or other materials provided with the distribution.
+#
+#  - Neither the name of the software nor the names of its contributors
+#    may be used to endorse or promote products derived from this software
+#    without specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+# ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+# LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+# CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+# SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+# INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+# CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+# ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+# POSSIBILITY OF SUCH DAMAGE.
+#
+
+__doc__ = """
+Contains custom yaml constructor classes and functions.
+"""
+
+import hashlib
+import os
+import re
+import string
+
+import yaml
+
+from envstack import util
+from envstack.encrypt import AESGCMEncryptor, Base64Encryptor, FernetEncryptor
+
+
+class Template(string.Template, str):
+    def __init__(self, value):
+        super().__init__(value)
+        self.value = value
+
+    def __repr__(self):
+        return f"Template(value={self.value})"
+
+
+class BaseNode(yaml.YAMLObject):
+    """Base class for custom yaml nodes."""
+
+    yaml_tag = None
+
+    def __init__(self, value):
+        self.value = value
+
+    def __repr__(self):
+        return f"{self.__class__.__name__}('{self.value}')"
+
+    def __str__(self):
+        return str(self.value)
+
+    def __eq__(self, other):
+        if isinstance(other, self.__class__):
+            return self.value == other.value
+        return False
+
+    @classmethod
+    def from_yaml(cls, loader: object, node: yaml.Node):
+        return cls(node.value)
+
+    @classmethod
+    def to_yaml(cls, dumper: object, node: yaml.Node):
+        return dumper.represent_scalar(cls.yaml_tag, node.value)
+
+    def resolve(self, env: dict = os.environ):
+        """Returns the decoded value."""
+        return self.value
+
+
+class Base64Node(BaseNode):
+    """Base64 encoded string node."""
+
+    yaml_tag = "!base64"
+
+    def __init__(self, value):
+        super().__init__(value)
+        self.original_value = None
+
+    @classmethod
+    def from_yaml(cls, loader: object, node: yaml.Node):
+        """Returns a new Base64Node instance."""
+        node = cls(node.value)
+        node.original_value = node.value
+        return node
+
+    @classmethod
+    def to_yaml(cls, dumper: object, node: yaml.Node):
+        """Encrypts the value before writing to yaml."""
+        if node.value == node.original_value:
+            encrypted = node.value
+        elif isinstance(node.value, cls):
+            encrypted = str(node.value)
+        else:
+            encrypted = Base64Encryptor().encrypt(node.value)
+        return dumper.represent_scalar(cls.yaml_tag, encrypted)
+
+    def resolve(self, env: dict = os.environ):
+        """Returns base64 decoded value."""
+        return Base64Encryptor().decrypt(self.value)
+
+
+class MD5Node(BaseNode):
+    """MD5 hash node."""
+
+    yaml_tag = "!md5"
+
+    @classmethod
+    def from_yaml(cls, loader: object, node: yaml.Node):
+        """Returns a new MD5Node instance."""
+        return cls(node.value)
+
+    @classmethod
+    def to_yaml(cls, dumper: object, node: yaml.Node):
+        """Encrypts the value before writing to yaml."""
+        md5_hash = hashlib.md5(node.value.encode()).hexdigest()
+        return dumper.represent_scalar(cls.yaml_tag, md5_hash)
+
+
+class EncryptedNode(BaseNode):
+    """Default encryption node. Supports multiple encryption schemes.
+    Favors AES-GCM, then Fernet, then base64."""
+
+    yaml_tag = "!encrypt"
+
+    def __init__(self, value):
+        super().__init__(value)
+        self.original_value = None
+
+    @classmethod
+    def encryptor(cls, env: dict = os.environ):
+        """Returns the encryptor class based on the environment."""
+        if env.get(AESGCMEncryptor.KEY_VAR_NAME):
+            return AESGCMEncryptor(env=env)
+        elif env.get(FernetEncryptor.KEY_VAR_NAME):
+            return FernetEncryptor(env=env)
+        else:
+            return Base64Encryptor()
+
+    @classmethod
+    def from_yaml(cls, loader: object, node: yaml.Node):
+        """Returns a new EncryptedNode instance."""
+        node = cls(node.value)
+        node.original_value = node.value
+        return node
+
+    @classmethod
+    def to_yaml(cls, dumper: object, node: yaml.Node):
+        """Encrypts the value before writing (do not double encrypt)."""
+        if node.value == node.original_value:
+            encrypted = node.value
+        elif isinstance(node.value, cls):
+            encrypted = str(node.value)
+        else:
+            encrypted = cls.encryptor().encrypt(node.value)
+        return dumper.represent_scalar(cls.yaml_tag, encrypted)
+
+    def resolve(self, env: dict = os.environ):
+        """Returns the decrypted original value, preserving original type.
+
+        :param env: environment with encryption keys.
+        :return: decrypted value.
+        """
+        try:
+            value = self.encryptor(env=env).decrypt(self.value)
+        except Exception:
+            value = self.value
+        return util.safe_eval(value)
+
+
+class AESGCMNode(BaseNode):
+    """Default encrypted node using AES-GCM."""
+
+    yaml_tag = "!aesgcm"
+
+    def __init__(self, value):
+        super().__init__(value)
+        self.original_value = None
+
+    @classmethod
+    def from_yaml(cls, loader: object, node: yaml.Node):
+        """Returns a new AESGCMNode instance."""
+        node = cls(node.value)
+        node.original_value = node.value
+        return node
+
+    @classmethod
+    def to_yaml(cls, dumper: object, node: yaml.Node):
+        """Encrypts the value before writing to yaml."""
+        if node.value == node.original_value:
+            encrypted = node.value
+        elif isinstance(node.value, cls):
+            encrypted = str(node.value)
+        else:
+            encrypted = AESGCMEncryptor().encrypt(node.value)
+        return dumper.represent_scalar(cls.yaml_tag, encrypted)
+
+    def resolve(self, env: dict = os.environ):
+        """Returns the decrypted value."""
+        return AESGCMEncryptor(env=env).decrypt(self.value)
+
+
+class FernetNode(BaseNode):
+    """Default encrypted node using Fernet."""
+
+    yaml_tag = "!fernet"
+
+    def __init__(self, value):
+        super().__init__(value)
+        self.original_value = None
+
+    @classmethod
+    def from_yaml(cls, loader: object, node: yaml.Node):
+        """Returns a new FernetNode instance."""
+        node = cls(node.value)
+        node.original_value = node.value
+        return node
+
+    @classmethod
+    def to_yaml(cls, dumper: object, node: yaml.Node):
+        """Encrypts the value before writing to yaml."""
+        if node.value == node.original_value:
+            encrypted = node.value
+        elif isinstance(node.value, cls):
+            encrypted = str(node.value)
+        else:
+            encrypted = FernetEncryptor().encrypt(node.value)
+        return dumper.represent_scalar(cls.yaml_tag, encrypted)
+
+    def resolve(self, env: dict = os.environ):
+        """Returns the decrypted value."""
+        return FernetEncryptor(env=env).decrypt(self.value)
+
+
+class CustomLoader(yaml.SafeLoader):
+    """Custom Loader class to preserve order of keys and ensure required
+    keys are first in the mapping."""
+
+    required_keys = {"include", "all", "darwin", "linux", "windows"}
+
+    def construct_mapping(self, node: yaml.Node, deep: bool = False):
+        """Construct a mapping from a YAML node, preserving the order of keys
+        and ensuring"""
+        # keep YAML merge keys (<<) working
+        self.flatten_mapping(node)
+
+        mapping = {}
+
+        for key_node, value_node in node.value:
+            # never implicit-resolve scalar KEYS (YES/NO/ON/OFF/null/date/etc)
+            if isinstance(key_node, yaml.ScalarNode):
+                key = key_node.value
+            else:
+                key = self.construct_object(key_node, deep=deep)
+
+            value = self.construct_object(value_node, deep=deep)
+            mapping[key] = value
+
+        # preserve order of keys and ensure required keys are first in the mapping
+        for key, value in list(mapping.items()):
+            if key in self.required_keys:
+                continue
+            mapping[key] = value
+
+        return mapping
+
+
+class CustomDumper(yaml.SafeDumper):
+    """
+    Custom Dumper class to handle anchors, references and flow style for nested
+    mappings.
+    """
+
+    _VAR_LIKE = re.compile(r"\$\{[A-Za-z_][A-Za-z0-9_]*\}")
+
+    def __init__(self, *args, **kwargs):
+        super(CustomDumper, self).__init__(*args, **kwargs)
+        self.depth = 0
+        self.basekey = None
+        self.newanchors = {}
+
+    def anchor_node(self, node: yaml.Node):
+        """Anchor the node and set the basekey for the node.
+
+        :param node: yaml node to anchor.
+        """
+        # increase depth on entering anchor_node
+        self.depth += 1
+
+        # set basekey for the node
+        if self.depth == 2:
+            assert isinstance(node, yaml.ScalarNode), (
+                "yaml node not a string: %s" % node
+            )
+            self.basekey = str(node.value)
+            node.value = self.basekey
+
+        # set anchor for the node
+        if self.depth == 3:
+            assert self.basekey, "could not find base key for value: %s" % node
+            self.newanchors[node] = self.basekey
+
+        super(CustomDumper, self).anchor_node(node)
+        if self.newanchors:
+            self.anchors.update(self.newanchors)
+            self.newanchors.clear()
+
+    def sanitize_value(self, node: yaml.Node):
+        """Sanitize node value by quoting it if it starts with special characters
+        or contains a colon followed by a space, e.g. "@var", "|value", "key: value".
+
+        :param node: yaml node to sanitize.
+        """
+        if isinstance(node, yaml.ScalarNode):
+            if node.value and node.value[0] in "@|?,%`&":
+                node.style = '"%s"' % node.value
+            elif node.value and node.value[-1] == ":":
+                node.style = '"%s"' % node.value
+            elif ": " in str(node.value):
+                node.style = '"%s"' % node.value
+
+    def quote_vars(self, node: yaml.Node):
+        """Quote embedded variables the node value, e.g. LIST: [1, 2, 3, ${VAR}].
+
+        :param node: yaml node to quote.
+        """
+        if isinstance(node, yaml.ScalarNode):
+            if self._VAR_LIKE.match(node.value):
+                node.style = '"%s"' % node.value
+
+    def represent_data(self, data: dict):
+        """Represent data and set flow_style for nested mappings.
+
+        :param data: Data to represent.
+        :return: yaml node.
+        """
+        # increase depth on entering represent_data
+        self.depth += 1
+        node = super().represent_data(data)
+        self.depth -= 1
+
+        # use flow style for nested mappings
+        if isinstance(node, yaml.MappingNode) and self.depth >= 2:
+            node.flow_style = True
+            for _, value in node.value:
+                self.quote_vars(value)
+        elif isinstance(node, yaml.SequenceNode) and self.depth >= 2:
+            node.flow_style = True
+            for element in node.value:
+                self.quote_vars(element)
+        elif isinstance(node, yaml.ScalarNode):
+            self.sanitize_value(node)
+
+        return node
+
+
+def get_keys_from_env(env: dict = os.environ):
+    """Return encryption keys from the environment.
+
+    :param env: Environment dictionary.
+    """
+    keys = {}
+    for key in [AESGCMEncryptor.KEY_VAR_NAME, FernetEncryptor.KEY_VAR_NAME]:
+        if key in env:
+            keys[key] = env[key]
+    return keys
+
+
+def add_custom_node_type(node_type: BaseNode):
+    """Add custom node type to yaml. Node type must be a subclass of BaseNode,
+    with local implementation of from_yaml and to_yaml methods, and definition
+    of yaml_tag.
+
+    :param node_type: Custom node class.
+    """
+
+    try:
+        yaml.SafeLoader.add_constructor(node_type.yaml_tag, node_type.from_yaml)
+        yaml.SafeDumper.add_representer(node_type, node_type.to_yaml)
+    except Exception as e:
+        print(f"error adding custom node type {node_type}: {e}")
+
+
+# add custom constructors and representers
+custom_node_types = [
+    Base64Node,
+    EncryptedNode,
+    AESGCMNode,
+    FernetNode,
+    MD5Node,
+]
+for node in custom_node_types:
+    add_custom_node_type(node)