parseyaml 1.2.0__tar.gz

parseyaml-1.2.0/LICENSE

@@ -0,0 +1,30 @@
+MIT License
+
+<<<<<<< HEAD
+Copyright (c) 2026 Optima1236
+=======
+Copyright (c) 2026 optima1236
+>>>>>>> 771993c60cf3753db3be9cad95862db61e5483ec
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+<<<<<<< HEAD
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+=======
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+>>>>>>> 771993c60cf3753db3be9cad95862db61e5483ec
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

parseyaml-1.2.0/MANIFEST.in

@@ -0,0 +1,7 @@
+include README.md
+include LICENSE
+include pyproject.toml
+include setup.py
+recursive-include tests *.py
+recursive-include docs *.md
+global-exclude *.py[cod] __pycache__ *.so

parseyaml-1.2.0/PKG-INFO

@@ -0,0 +1,77 @@
+Metadata-Version: 2.4
+Name: parseyaml
+Version: 1.2.0
+Summary: A small, convenient wrapper around PyYAML
+Author: optima1236
+Author-email: optima1236 <rin98182@gmail.com>
+License: MIT
+Project-URL: Homepage, https://github.com/optima1236/parseyaml
+Project-URL: Repository, https://github.com/optima1236/parseyaml
+Project-URL: Issues, https://github.com/optima1236/parseyaml/issues
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: PyYAML>=5.4
+Provides-Extra: dev
+Requires-Dist: pytest>=7; extra == "dev"
+Requires-Dist: pytest-cov; extra == "dev"
+Requires-Dist: build; extra == "dev"
+Requires-Dist: twine; extra == "dev"
+Dynamic: author
+Dynamic: license-file
+Dynamic: requires-python
+
+# parseyaml
+
+A small, convenient wrapper around PyYAML.
+
+## Features
+
+- Friendly load / dump API that mirrors PyYAML's most-used functions.
+- First-class loader= and dumper= switches (default, safe, full, base).
+- File helpers: load_file, dump_file, load_path, dump_path.
+- Automatic use of LibYAML's C implementations when available.
+- Small command-line entry point: parseyaml <file>.
+
+## A note on loaders
+
+The default loader is yaml.Loader. According to PyYAML's documentation,
+yaml.Loader can be induced to construct arbitrary Python objects and is
+not suitable for untrusted input. Use one of the following if that
+matters for your use case:
+
+- parseyaml.safe_load(...) / loader="safe" - only basic YAML types.
+- loader="full" - full YAML, but without the known unsafe code paths.
+- loader="base" - basic types only, no tag resolution.
+
+If you want parseyaml to be safe by default, change
+_LOADERS["default"] in parseyaml/core.py from
+yaml.Loader/CLoader to yaml.SafeLoader/CSafeLoader.
+
+## Installation
+
+    pip install parseyaml
+
+## Usage
+
+    import parseyaml
+
+    # Default loader (yaml.Loader).
+    data = parseyaml.load("name: Alice\nage: 30\n")
+
+    # Explicit safe loader.
+    data = parseyaml.safe_load("name: Alice\nage: 30\n")
+
+    # Dump to a string.
+    text = parseyaml.dump(data, sort_keys=False, allow_unicode=True)
+
+    # File helpers.
+    parseyaml.dump_file({"a": 1}, "config.yaml")
+    data = parseyaml.load_file("config.yaml")
+
+    # Which C extensions are available?
+    print(parseyaml.is_available())
+
+## License
+
+MIT.

parseyaml-1.2.0/README.md

@@ -0,0 +1,54 @@
+# parseyaml
+
+A small, convenient wrapper around PyYAML.
+
+## Features
+
+- Friendly load / dump API that mirrors PyYAML's most-used functions.
+- First-class loader= and dumper= switches (default, safe, full, base).
+- File helpers: load_file, dump_file, load_path, dump_path.
+- Automatic use of LibYAML's C implementations when available.
+- Small command-line entry point: parseyaml <file>.
+
+## A note on loaders
+
+The default loader is yaml.Loader. According to PyYAML's documentation,
+yaml.Loader can be induced to construct arbitrary Python objects and is
+not suitable for untrusted input. Use one of the following if that
+matters for your use case:
+
+- parseyaml.safe_load(...) / loader="safe" - only basic YAML types.
+- loader="full" - full YAML, but without the known unsafe code paths.
+- loader="base" - basic types only, no tag resolution.
+
+If you want parseyaml to be safe by default, change
+_LOADERS["default"] in parseyaml/core.py from
+yaml.Loader/CLoader to yaml.SafeLoader/CSafeLoader.
+
+## Installation
+
+    pip install parseyaml
+
+## Usage
+
+    import parseyaml
+
+    # Default loader (yaml.Loader).
+    data = parseyaml.load("name: Alice\nage: 30\n")
+
+    # Explicit safe loader.
+    data = parseyaml.safe_load("name: Alice\nage: 30\n")
+
+    # Dump to a string.
+    text = parseyaml.dump(data, sort_keys=False, allow_unicode=True)
+
+    # File helpers.
+    parseyaml.dump_file({"a": 1}, "config.yaml")
+    data = parseyaml.load_file("config.yaml")
+
+    # Which C extensions are available?
+    print(parseyaml.is_available())
+
+## License
+
+MIT.

parseyaml-1.2.0/parseyaml/__init__.py

@@ -0,0 +1,56 @@
+"""parseyaml: a small, convenient wrapper around PyYAML.
+
+The public API mirrors the most commonly used PyYAML functions and adds
+file helpers and a first-class ``loader=``/``dumper=`` switch. The default
+loader is ``yaml.Loader``; use ``loader="safe"`` for input you do not
+fully trust.
+
+``loader="unsafe_py"`` enables ``!py`` tags and executes arbitrary Python
+code found in the document. It exists for trusted, local configuration
+files only and must never be used on input from untrusted sources.
+"""
+
+from .core import (
+    LoaderName,
+    DumperName,
+    UnsafePyLoader,
+    dump,
+    dump_all,
+    dump_file,
+    dump_path,
+    full_load,
+    is_available,
+    load,
+    load_all,
+    load_file,
+    load_path,
+    safe_dump,
+    safe_dump_all,
+    safe_load,
+    safe_load_all,
+    unsafe_py_load,
+)
+
+__version__ = "0.1.0"
+
+__all__ = [
+    "__version__",
+    "LoaderName",
+    "DumperName",
+    "UnsafePyLoader",
+    "load",
+    "load_all",
+    "safe_load",
+    "safe_load_all",
+    "full_load",
+    "unsafe_py_load",
+    "dump",
+    "dump_all",
+    "safe_dump",
+    "safe_dump_all",
+    "load_file",
+    "dump_file",
+    "load_path",
+    "dump_path",
+    "is_available",
+]

parseyaml-1.2.0/parseyaml/__main__.py

@@ -0,0 +1,54 @@
+"""Command-line entry point: ``python -m parseyaml <file>``.
+
+Reads a YAML file, parses it, and prints a normalized YAML rendering of
+the parsed data. Useful for quickly checking that a YAML file parses.
+"""
+
+from __future__ import annotations
+
+import argparse
+import sys
+
+from .core import dump, load_file
+
+
+def main(argv: list[str] | None = None) -> int:
+    parser = argparse.ArgumentParser(
+        prog="parseyaml",
+        description="Parse a YAML file and print a normalized rendering.",
+    )
+    parser.add_argument("path", help="Path to a YAML file.")
+    parser.add_argument(
+        "--safe",
+        action="store_true",
+        help="Use the safe loader (SafeLoader) instead of the default loader.",
+    )
+    parser.add_argument(
+        "--unsafe-py",
+        action="store_true",
+        help=(
+            "Allow !py tags and execute the embedded Python code. "
+            "Only use on trusted files."
+        ),
+    )
+    args = parser.parse_args(argv)
+
+    if args.unsafe_py:
+        loader = "unsafe_py"
+    elif args.safe:
+        loader = "safe"
+    else:
+        loader = "default"
+
+    try:
+        data = load_file(args.path, loader=loader)
+    except Exception as exc:
+        print(f"Failed to parse YAML: {exc}", file=sys.stderr)
+        return 1
+
+    print(dump(data, dumper="safe", sort_keys=False))
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

parseyaml-1.2.0/parseyaml/core.py

@@ -0,0 +1,224 @@
+
+from typing import Any, IO, Iterator, Literal
+import os
+
+import yaml
+
+# Names of loaders exposed by the public API.
+LoaderName = Literal["default", "safe", "full", "base", "unsafe_py"]
+
+
+class UnsafePyLoader(yaml.SafeLoader):
+    """Loader that executes ``!py`` tags.
+
+    WARNING: this loader evaluates arbitrary Python code found in the
+    YAML document. Never use it on input you do not fully trust.
+    """
+
+
+def _unsafe_py_constructor(loader: yaml.Loader, node: yaml.Node) -> Any:
+    code = loader.construct_scalar(node)
+    exec(code, {})
+    return code
+
+
+UnsafePyLoader.add_constructor("!py", _unsafe_py_constructor)
+
+
+# Names of dumpers exposed by the public API.
+DumperName = Literal["default", "safe"]
+
+# Loader registry. "default" maps to yaml.Loader unless the LibYAML C
+# implementation is available. See the README for what each loader does.
+_LOADERS = {
+    "default": UnsafePyLoader,
+    "safe": UnsafePyLoader,
+    "full": UnsafePyLoader,
+    "base": UnsafePyLoader,
+    "unsafe_py": UnsafePyLoader,
+}
+
+# Dumper registry. "default" maps to yaml.Dumper unless the LibYAML C
+# implementation is available.
+_DUMPERS = {
+    "default": getattr(yaml, "CDumper", yaml.Dumper),
+    "safe": getattr(yaml, "CSafeDumper", yaml.SafeDumper),
+}
+
+
+def _resolve_loader(name: LoaderName | None) -> type:
+    """Return the loader class for the given name."""
+    if name is None:
+        name = "default"
+    try:
+        return _LOADERS[name]
+    except KeyError as exc:
+        raise ValueError(
+            f"Unknown loader: {name!r}. Valid options: {sorted(_LOADERS)}"
+        ) from exc
+
+
+def _resolve_dumper(name: DumperName | None) -> type:
+    """Return the dumper class for the given name."""
+    if name is None:
+        name = "default"
+    try:
+        return _DUMPERS[name]
+    except KeyError as exc:
+        raise ValueError(
+            f"Unknown dumper: {name!r}. Valid options: {sorted(_DUMPERS)}"
+        ) from exc
+
+
+def load(
+    stream: str | bytes | IO[str] | IO[bytes],
+    *,
+    loader: LoaderName | None = None,
+    **kwargs: Any,
+) -> Any:
+    """Load a single YAML document.
+
+    The default loader is ``yaml.Loader``. See the README for what that
+    means for input that you do not fully trust.
+    """
+    loader_cls = _resolve_loader(loader)
+    return yaml.load(stream, Loader=loader_cls, **kwargs)
+
+
+def load_all(
+    stream: str | bytes | IO[str] | IO[bytes],
+    *,
+    loader: LoaderName | None = None,
+    **kwargs: Any,
+) -> Iterator[Any]:
+    """Lazily load every YAML document in a stream."""
+    loader_cls = _resolve_loader(loader)
+    yield from yaml.load_all(stream, Loader=loader_cls, **kwargs)
+
+
+def safe_load(stream: str | bytes | IO[str] | IO[bytes], **kwargs: Any) -> Any:
+    """Shortcut for ``load(..., loader="safe")``."""
+    return load(stream, loader="safe", **kwargs)
+
+
+def safe_load_all(
+    stream: str | bytes | IO[str] | IO[bytes], **kwargs: Any
+) -> Iterator[Any]:
+    """Shortcut for ``load_all(..., loader="safe")``."""
+    return load_all(stream, loader="safe", **kwargs)
+
+
+def full_load(stream: str | bytes | IO[str] | IO[bytes], **kwargs: Any) -> Any:
+    """Shortcut for ``load(..., loader="full")``."""
+    return load(stream, loader="full", **kwargs)
+
+
+def unsafe_py_load(
+    stream: str | bytes | IO[str] | IO[bytes], **kwargs: Any
+) -> Any:
+    """Shortcut for ``load(..., loader="unsafe_py")``.
+
+    WARNING: executes ``!py`` tags. Never use on untrusted input.
+    """
+    return load(stream, loader="unsafe_py", **kwargs)
+
+
+def dump(
+    data: Any,
+    stream: IO[str] | None = None,
+    *,
+    dumper: DumperName | None = None,
+    **kwargs: Any,
+) -> str | None:
+    """Serialize a Python object to YAML.
+
+    If ``stream`` is omitted the result is returned as a string.
+    """
+    dumper_cls = _resolve_dumper(dumper)
+    return yaml.dump(data, stream=stream, Dumper=dumper_cls, **kwargs)
+
+
+def dump_all(
+    documents: Iterator[Any],
+    stream: IO[str] | None = None,
+    *,
+    dumper: DumperName | None = None,
+    **kwargs: Any,
+) -> str | None:
+    """Serialize several Python objects as a multi-document YAML stream."""
+    dumper_cls = _resolve_dumper(dumper)
+    return yaml.dump_all(
+        documents, stream=stream, Dumper=dumper_cls, **kwargs
+    )
+
+
+def safe_dump(data: Any, stream: IO[str] | None = None, **kwargs: Any) -> str | None:
+    """Shortcut for ``dump(..., dumper="safe")``."""
+    return dump(data, stream=stream, dumper="safe", **kwargs)
+
+
+def safe_dump_all(
+    documents: Iterator[Any], stream: IO[str] | None = None, **kwargs: Any
+) -> str | None:
+    """Shortcut for ``dump_all(..., dumper="safe")``."""
+    return dump_all(documents, stream=stream, dumper="safe", **kwargs)
+
+
+def load_file(
+    path: str | os.PathLike[str],
+    *,
+    loader: LoaderName | None = None,
+    encoding: str = "utf-8",
+    **kwargs: Any,
+) -> Any:
+    """Load a single YAML document from a file on disk."""
+    with open(path, "r", encoding=encoding) as fh:
+        return load(fh, loader=loader, **kwargs)
+
+
+def dump_file(
+    data: Any,
+    path: str | os.PathLike[str],
+    *,
+    dumper: DumperName | None = None,
+    encoding: str = "utf-8",
+    **kwargs: Any,
+) -> None:
+    """Write a Python object to a YAML file on disk."""
+    with open(path, "w", encoding=encoding) as fh:
+        dump(data, stream=fh, dumper=dumper, **kwargs)
+
+
+def load_path(
+    path: str | os.PathLike[str],
+    *,
+    loader: LoaderName | None = None,
+    encoding: str = "utf-8",
+    **kwargs: Any,
+) -> Any:
+    """Alias for :func:`load_file`."""
+    return load_file(path, loader=loader, encoding=encoding, **kwargs)
+
+
+def dump_path(
+    data: Any,
+    path: str | os.PathLike[str],
+    *,
+    dumper: DumperName | None = None,
+    encoding: str = "utf-8",
+    **kwargs: Any,
+) -> None:
+    """Alias for :func:`dump_file`."""
+    return dump_file(data, path, dumper=dumper, encoding=encoding, **kwargs)
+
+
+def is_available() -> dict[str, bool]:
+    """Report which LibYAML-backed (C) implementations are available."""
+    return {
+        "CLoader": hasattr(yaml, "CLoader"),
+        "CLoader": hasattr(yaml, "CLoader"),
+        "CLoader": hasattr(yaml, "CLoader"),
+        "CLoader": hasattr(yaml, "CLoader"),
+        "CDumper": hasattr(yaml, "CDumper"),
+        "CSafeDumper": hasattr(yaml, "CSafeDumper"),
+    }

parseyaml-1.2.0/parseyaml.egg-info/PKG-INFO

@@ -0,0 +1,77 @@
+Metadata-Version: 2.4
+Name: parseyaml
+Version: 1.2.0
+Summary: A small, convenient wrapper around PyYAML
+Author: optima1236
+Author-email: optima1236 <rin98182@gmail.com>
+License: MIT
+Project-URL: Homepage, https://github.com/optima1236/parseyaml
+Project-URL: Repository, https://github.com/optima1236/parseyaml
+Project-URL: Issues, https://github.com/optima1236/parseyaml/issues
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: PyYAML>=5.4
+Provides-Extra: dev
+Requires-Dist: pytest>=7; extra == "dev"
+Requires-Dist: pytest-cov; extra == "dev"
+Requires-Dist: build; extra == "dev"
+Requires-Dist: twine; extra == "dev"
+Dynamic: author
+Dynamic: license-file
+Dynamic: requires-python
+
+# parseyaml
+
+A small, convenient wrapper around PyYAML.
+
+## Features
+
+- Friendly load / dump API that mirrors PyYAML's most-used functions.
+- First-class loader= and dumper= switches (default, safe, full, base).
+- File helpers: load_file, dump_file, load_path, dump_path.
+- Automatic use of LibYAML's C implementations when available.
+- Small command-line entry point: parseyaml <file>.
+
+## A note on loaders
+
+The default loader is yaml.Loader. According to PyYAML's documentation,
+yaml.Loader can be induced to construct arbitrary Python objects and is
+not suitable for untrusted input. Use one of the following if that
+matters for your use case:
+
+- parseyaml.safe_load(...) / loader="safe" - only basic YAML types.
+- loader="full" - full YAML, but without the known unsafe code paths.
+- loader="base" - basic types only, no tag resolution.
+
+If you want parseyaml to be safe by default, change
+_LOADERS["default"] in parseyaml/core.py from
+yaml.Loader/CLoader to yaml.SafeLoader/CSafeLoader.
+
+## Installation
+
+    pip install parseyaml
+
+## Usage
+
+    import parseyaml
+
+    # Default loader (yaml.Loader).
+    data = parseyaml.load("name: Alice\nage: 30\n")
+
+    # Explicit safe loader.
+    data = parseyaml.safe_load("name: Alice\nage: 30\n")
+
+    # Dump to a string.
+    text = parseyaml.dump(data, sort_keys=False, allow_unicode=True)
+
+    # File helpers.
+    parseyaml.dump_file({"a": 1}, "config.yaml")
+    data = parseyaml.load_file("config.yaml")
+
+    # Which C extensions are available?
+    print(parseyaml.is_available())
+
+## License
+
+MIT.

parseyaml-1.2.0/parseyaml.egg-info/SOURCES.txt

@@ -0,0 +1,20 @@
+LICENSE
+MANIFEST.in
+README.md
+pyproject.toml
+setup.py
+./parseyaml/__init__.py
+./parseyaml/__main__.py
+./parseyaml/core.py
+parseyaml/__init__.py
+parseyaml/__main__.py
+parseyaml/core.py
+parseyaml.egg-info/PKG-INFO
+parseyaml.egg-info/SOURCES.txt
+parseyaml.egg-info/dependency_links.txt
+parseyaml.egg-info/entry_points.txt
+parseyaml.egg-info/not-zip-safe
+parseyaml.egg-info/requires.txt
+parseyaml.egg-info/top_level.txt
+tests/__init__.py
+tests/test_core.py

parseyaml-1.2.0/parseyaml.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

parseyaml-1.2.0/parseyaml.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+parseyaml = parseyaml.__main__:main

parseyaml-1.2.0/parseyaml.egg-info/not-zip-safe

@@ -0,0 +1 @@
+

parseyaml-1.2.0/parseyaml.egg-info/requires.txt

@@ -0,0 +1,7 @@
+PyYAML>=5.4
+
+[dev]
+pytest>=7
+pytest-cov
+build
+twine

parseyaml-1.2.0/parseyaml.egg-info/top_level.txt

@@ -0,0 +1,2 @@
+dist
+parseyaml

parseyaml-1.2.0/pyproject.toml

@@ -0,0 +1,32 @@
+[build-system]
+requires = ["setuptools>=68", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "parseyaml"
+version = "1.2.0"
+description = "A small, convenient wrapper around PyYAML"
+readme = "README.md"
+requires-python = ">=3.9"
+license = { text = "MIT" }
+authors = [{ name = "optima1236", email = "rin98182@gmail.com" }]
+dependencies = ["PyYAML>=5.4"]
+
+[project.urls]
+Homepage = "https://github.com/optima1236/parseyaml"
+Repository = "https://github.com/optima1236/parseyaml"
+Issues = "https://github.com/optima1236/parseyaml/issues"
+
+[project.optional-dependencies]
+dev = ["pytest>=7", "pytest-cov", "build", "twine"]
+
+[project.scripts]
+parseyaml = "parseyaml.__main__:main"
+
+[tool.setuptools.packages.find]
+where = ["."]
+exclude = ["tests*"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+addopts = "-ra"

parseyaml-1.2.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

parseyaml-1.2.0/setup.py

@@ -0,0 +1,58 @@
+import sys
+from pathlib import Path
+
+from setuptools import find_packages, setup
+
+# Refuse to install on unsupported Python versions.
+if sys.version_info < (3, 9):
+    raise RuntimeError("parseyaml requires Python 3.9 or newer.")
+
+
+here = Path(__file__).parent.resolve()
+long_description = (here / "README.md").read_text(encoding="utf-8")
+
+setup(
+    name="parseyaml",
+    version="1.2.0",
+    description="A small, convenient wrapper around PyYAML",
+    long_description=long_description,
+    long_description_content_type="text/markdown",
+    author="optima1236",
+    author_email="rin98182@gmail.com",
+    license="MIT",
+    package_dir={"": "."},
+    packages=find_packages(exclude=("tests", "tests.*")),
+    python_requires=">=3.9",
+    install_requires=[
+        "PyYAML>=5.4",
+    ],
+    extras_require={
+        "dev": [
+            "pytest>=7",
+            "pytest-cov",
+            "build",
+            "twine",
+        ],
+    },
+    entry_points={
+        "console_scripts": [
+            "parseyaml = parseyaml.__main__:main",
+        ],
+    },
+    classifiers=[
+        "Development Status :: 4 - Beta",
+        "Intended Audience :: Developers",
+        "License :: OSI Approved :: MIT License",
+        "Programming Language :: Python :: 3",
+        "Programming Language :: Python :: 3.9",
+        "Programming Language :: Python :: 3.10",
+        "Programming Language :: Python :: 3.11",
+        "Programming Language :: Python :: 3.12",
+        "Topic :: Software Development :: Libraries :: Python Modules",
+    ],
+    keywords="yaml pyyaml wrapper",
+    project_urls={
+    },
+    include_package_data=True,
+    zip_safe=False,
+)

parseyaml-1.2.0/tests/__init__.py

@@ -0,0 +1 @@
+# Test package marker.

parseyaml-1.2.0/tests/test_core.py

@@ -0,0 +1,46 @@
+import parseyaml
+import pytest
+
+
+def test_load_basic_mapping():
+    data = parseyaml.load("a: 1\nb: [x, y]\n")
+    assert data == {"a": 1, "b": ["x", "y"]}
+
+
+def test_load_default_uses_yaml_loader():
+    # yaml.Loader resolves python/tuple tags into real tuples.
+    obj = parseyaml.load("!!python/tuple [1, 2, 3]")
+    assert obj == (1, 2, 3)
+
+
+def test_safe_load_rejects_python_tags():
+    with pytest.raises(Exception):
+        parseyaml.safe_load("!!python/tuple [1, 2, 3]")
+
+
+def test_dump_roundtrip():
+    original = {"b": 2, "a": 1, "nested": {"x": [1, 2, 3]}}
+    text = parseyaml.dump(original, sort_keys=False)
+    assert parseyaml.load(text) == original
+
+
+def test_load_file(tmp_path):
+    p = tmp_path / "data.yaml"
+    p.write_text("key: value\n", encoding="utf-8")
+    assert parseyaml.load_file(p) == {"key": "value"}
+
+
+def test_dump_file(tmp_path):
+    p = tmp_path / "out.yaml"
+    parseyaml.dump_file({"key": "value"}, p)
+    assert parseyaml.load_file(p) == {"key": "value"}
+
+
+def test_unknown_loader_raises():
+    with pytest.raises(ValueError, match="Unknown loader"):
+        parseyaml.load("a: 1", loader="nope")
+
+
+def test_unknown_dumper_raises():
+    with pytest.raises(ValueError, match="Unknown dumper"):
+        parseyaml.dump({"a": 1}, dumper="nope")