yamling 1.1.1

Enhanced YAML loading and dumping.

yamling

Read the documentation!

Yamling is a YAML handling library that provides enhanced loading and dumping capabilities for YAML files. It builds upon PyYAML to offer additional features like environment variable support, file inclusion, and Jinja2 template resolution. Special mentions also to pyyaml_env_tag as well as pyyaml-include, this library exposes these YAML extensions with a unified interface.

Loading YAML

Basic Loading

To load YAML content from a string:

from yamling import load_yaml

# Simple YAML loading
data = load_yaml("""
name: John
age: 30
""")

To load from a file:

from yamling import load_yaml_file

# Load from local file
config = load_yaml_file("config.yaml")

# Load from remote file (S3, HTTP, etc.)
remote_config = load_yaml_file("s3://bucket/config.yaml")

Safety Modes

Yamling supports three safety modes when loading YAML:

# Safe mode - most restrictive, recommended for untrusted input
data = load_yaml(content, mode="safe")

# Full mode - allows some additional types but restricts dangerous ones
data = load_yaml(content, mode="full")

# Unsafe mode - allows all YAML features (default)
data = load_yaml(content, mode="unsafe")

Warning Always use "safe" mode when loading untrusted YAML content to prevent code execution vulnerabilities.

File Inclusion

Yamling supports including other YAML files using the !include tag:

# main.yaml
database:
  !include db_config.yaml
logging:
  !include logging_config.yaml

When loading, specify the base path for includes:

config = load_yaml_file("main.yaml", include_base_path="configs/")

Environment Variables

Use the !ENV tag to reference environment variables:

database:
  password: !ENV DB_PASSWORD
  host: !ENV ${DB_HOST:localhost}  # with default value

Template Resolution

Yamling can resolve Jinja2 templates in YAML:

from jinja2 import Environment
import yamling

env = Environment()
yaml_content = """
message: "Hello {{ name }}!"
"""

data = load_yaml(
    yaml_content,
    resolve_strings=True,
    jinja_env=env
)

Inheritance

YAML files can inherit from other files using the INHERIT key:

# base.yaml
database:
  host: localhost
  port: 5432

# prod.yaml
INHERIT: base.yaml
database:
  host: prod.example.com

Load with inheritance enabled:

config = load_yaml_file("prod.yaml", resolve_inherit=True)

Dumping YAML

To serialize Python objects to YAML:

from yamling import dump_yaml

data = {
    "name": "John",
    "scores": [1, 2, 3],
    "active": True
}

yaml_string = dump_yaml(data)

Dataclasses and Pydantic v2 models can also get dumped.

Custom Class Mapping

Map custom classes to built-in types for YAML representation:

from collections import OrderedDict

data = OrderedDict([("b", 2), ("a", 1)])
yaml_string = dump_yaml(data, class_mappings={OrderedDict: dict})

Custom Loader Configuration

For advanced use cases, you can create a custom loader:

from yamling import get_loader
import yaml

# Create custom loader with specific features
loader_cls = get_loader(
    yaml.SafeLoader,
    include_base_path="configs/",
    enable_include=True,
    enable_env=True,
    resolve_strings=True,
    jinja_env=jinja_env,
    type_converters={int: str}
)

# Use custom loader
data = yaml.load(content, Loader=loader_cls)

Universal load / dump interface

Yamling provides a universal load function that can handle YAML, JSON, TOML, and INI files. Apart from yaml, only stdlib modules are used, so no additional dependencies are required. Here's a simple example:

import yamling

# Load files based on their extension
config = yamling.load_file("config.yaml")    # YAML
settings = yamling.load_file("settings.json") # JSON
params = yamling.load_file("params.toml")    # TOML

# Or explicitly specify the format
data = yamling.load_file("config.txt", mode="yaml")

# Load directly from strings
yaml_text = """
name: John
age: 30
"""
data = yamling.load(yaml_text, mode="yaml")
# same in other direction
json_text = yamling.dump(data, mode="json")
yaml.dump_file("config.yaml", data)

Note If orjson is installed, the loader will automatically use it for JSON parsing / dumping, offering significantly better performance compared to the standard json module.