如何将 YAML 文件包含在另一个文件中？

Question

所以我有两个 YAML 文件，“A”和“B”，我希望将 A 的内容插入到 B 中，要么拼接到现有的数据结构中，如数组，要么作为元素的子元素，如值对于某个哈希键。

这有可能吗？ 如何？ 如果没有，是否有任何指向规范参考的指针？

Answer 1

也许这可以启发您，尝试与 jbb 约定保持一致：

https://docs.openstack.org/infra/jenkins-job-builder/definition.html#inclusion-tags


- 工作：
名称：测试作业-include-raw-1
建设者：
- 壳：
!include-raw: include-raw001-hello-world.sh


Answer 2

结合其他答案，这里有一个简短的解决方案，无需重载 Loader 类，它可以与任何对文件操作的加载程序一起使用：

import json
from pathlib import Path
from typing import Any

import yaml


def yaml_include_constructor(loader: yaml.BaseLoader, node: yaml.Node) -> Any:
    """Include file referenced with !include node"""

    # noinspection PyTypeChecker
    fp = Path(loader.name).parent.joinpath(loader.construct_scalar(node)).resolve()
    fe = fp.suffix.lstrip(".")

    with open(fp, 'r') as f:
        if fe in ("yaml", "yml"):
            return yaml.load(f, type(loader))
        elif fe in ("json", "jsn"):
            return json.load(f)
        else:
            return f.read()


def main():
    loader = yaml.SafeLoader  # Works with any loader
    loader.add_constructor("!include", yaml_include_constructor)

    with open(...) as f:
        yml = yaml.load(f, loader)

# noinspection PyTypeChecker 是为了防止 PEP 检查警告 将 node: yaml.Node 传递给 loader.construct_scalar() 时，预期类型为“ScalarNode”，但得到了“Node”。

如果 yaml.load 输入流不是文件流，则此解决方案将失败，因为在这种情况下 loader.name 不包含路径：

class Reader(object):
    ...
    def __init__(self, stream):
        ...
        if isinstance(stream, str):
            self.name = "<unicode string>"
            ...
        elif isinstance(stream, bytes):
            self.name = "<byte string>"
            ...
        else:
            self.name = getattr(stream, 'name', "<file>")
            ...

在我的用例中，我知道只有YAML 文件将被包含在内，因此解决方案可以进一步简化：

def yaml_include_constructor(loader: yaml.Loader, node: yaml.Node) -> Any:
    """Include YAML file referenced with !include node"""
    with open(Path(loader.name).parent.joinpath(loader.construct_yaml_str(node)).resolve(), 'r') as f:
        return yaml.load(f, type(loader))


Loader = yaml.SafeLoader  # Works with any loader
Loader.add_constructor("!include", yaml_include_constructor)


def main():
    with open(...) as f:
        yml = yaml.load(f, Loader=Loader)

甚至可以使用 lambda 进行单行：

Loader = yaml.SafeLoader  # Works with any loader
Loader.add_constructor("!include",
                       lambda l, n: yaml.load(Path(l.name).parent.joinpath(l.construct_scalar(n)).read_text(), type(l)))

Answer 3

添加上面 @Joshbode 的初始答案，我稍微修改了代码片段以支持 UNIX 风格的通配符模式。

不过我还没有在 Windows 中测试过。 我面临着将大型 yaml 中的数组拆分为多个文件以方便维护的问题，并且正在寻找一种解决方案来引用基本 yaml 的同一数组中的多个文件。 因此有下面的解决方案。 该解决方案不支持递归引用。 它仅支持基本 yaml 中引用的给定目录级别中的通配符。

import yaml
import os
import glob


# Base code taken from below link :-
# Ref:https://stackoverflow.com/a/9577670
class Loader(yaml.SafeLoader):

    def __init__(self, stream):

        self._root = os.path.split(stream.name)[0]

        super(Loader, self).__init__(stream)

    def include(self, node):
        consolidated_result = None
        filename = os.path.join(self._root, self.construct_scalar(node))

        # Below section is modified for supporting UNIX wildcard patterns
        filenames = glob.glob(filename)
        
        # Just to ensure the order of files considered are predictable 
        # and easy to debug in case of errors.
        filenames.sort()
        for file in filenames:
            with open(file, 'r') as f:
                result = yaml.load(f, Loader)

            if isinstance(result, list):
                if not isinstance(consolidated_result, list):
                    consolidated_result = []
                consolidated_result += result
            elif isinstance(result, dict):
                if not isinstance(consolidated_result, dict):
                    consolidated_result = {}
                consolidated_result.update(result)
            else:
                consolidated_result = result

        return consolidated_result


Loader.add_constructor('!include', Loader.include)

使用

a:
  !include a.yaml

b:
  # All yamls included within b folder level will be consolidated
  !include b/*.yaml

Answer 4

根据之前的帖子：

  class SimYamlLoader(yaml.SafeLoader):
        '''
        Simple custom yaml loader that supports include, e.g:

        main.yaml:

        - !include file1.yaml
        - !include dir/file2.yaml

        '''

        def __init__(self, stream):
            self.root = os.path.split(stream.name)[0]
            super().__init__(stream)

    def _include(loader, node):
        filename = os.path.join(loader.root, loader.construct_scalar(node))
        with open(filename, 'r') as f:
            return yaml.load(f, SimYamlLoader)
    SimYamlLoader.add_constructor('!include', _include)

    # example:
    with open('main.yaml', 'r') as f:
        lists = yaml.load(f, SimYamlLoader)
        # if you want to merge the lists
        data = functools.reduce(
            lambda x, y: x if y is None else {**x, **dict(y)}, lists, {})
        # python 3.10+:lambda x, y: x if y is None else x | dict(y), lists, {})

Answer 5

当提出问题时，可能不支持它，但您可以将其他 YAML 文件导入其中：

imports: [/your_location_to_yaml_file/Util.area.yaml]

虽然我没有任何在线参考，但这对我有用。

Answer 6

据我所知，YAML 不直接支持包含，您必须自己提供一种机制，但这通常很容易做到。

我在我的 python 应用程序中使用 YAML 作为配置语言，在这种情况下经常定义这样的约定：

>>> main.yml <<<
includes: [ wibble.yml, wobble.yml]

然后在我的（python）代码中我这样做：

import yaml
cfg = yaml.load(open("main.yml"))
for inc in cfg.get("includes", []):
   cfg.update(yaml.load(open(inc)))

唯一的缺点是包含中的变量将始终覆盖包含中的变量main，并且无法通过更改“includes: 语句在 main.yml 文件中出现的位置来更改该优先级。

稍有不同的是，YAML 不支持 include，因为它并不是真正设计为像文件一样排他性如果您在 AJAX 请求的响应中得到包含，那么它意味着什么？

Answer 7

扩展 @Josh_Bode 的答案，这是我自己的 PyYAML 解决方案，它的优点是成为 yaml.Loader 的独立子类。 它不依赖于任何模块级全局变量，也不依赖于修改 yaml 模块的全局状态。

import yaml, os

class IncludeLoader(yaml.Loader):                                                 
    """                                                                           
    yaml.Loader subclass handles "!include path/to/foo.yml" directives in config  
    files.  When constructed with a file object, the root path for includes       
    defaults to the directory containing the file, otherwise to the current       
    working directory. In either case, the root path can be overridden by the     
    `root` keyword argument.                                                      

    When an included file F contain its own !include directive, the path is       
    relative to F's location.                                                     

    Example:                                                                      
        YAML file /home/frodo/one-ring.yml:                                       
            ---                                                                   
            Name: The One Ring                                                    
            Specials:                                                             
                - resize-to-wearer                                                
            Effects: 
                - !include path/to/invisibility.yml                            

        YAML file /home/frodo/path/to/invisibility.yml:                           
            ---                                                                   
            Name: invisibility                                                    
            Message: Suddenly you disappear!                                      

        Loading:                                                                  
            data = IncludeLoader(open('/home/frodo/one-ring.yml', 'r')).get_data()

        Result:                                                                   
            {'Effects': [{'Message': 'Suddenly you disappear!', 'Name':            
                'invisibility'}], 'Name': 'The One Ring', 'Specials':              
                ['resize-to-wearer']}                                             
    """                                                                           
    def __init__(self, *args, **kwargs):                                          
        super(IncludeLoader, self).__init__(*args, **kwargs)                      
        self.add_constructor('!include', self._include)                           
        if 'root' in kwargs:                                                      
            self.root = kwargs['root']                                            
        elif isinstance(self.stream, file):                                       
            self.root = os.path.dirname(self.stream.name)                         
        else:                                                                     
            self.root = os.path.curdir                                            

    def _include(self, loader, node):                                    
        oldRoot = self.root                                              
        filename = os.path.join(self.root, loader.construct_scalar(node))
        self.root = os.path.dirname(filename)                           
        data = yaml.load(open(filename, 'r'))                            
        self.root = oldRoot                                              
        return data                                                      

Answer 8

使用 Yglu，您可以导入其他文件，如下所示：

A.yaml

foo: !? $import('B.yaml')

B.yaml

bar: Hello

$ yglu A.yaml
foo:
  bar: Hello

由于 $import 是一个函数，您还可以传递一个表达式作为参数：

  dep: !- b
  foo: !? $import($_.dep.toUpper() + '.yaml')

这将给出与上面相同的输出。

免责声明：我是 Yglu 的作者。

Answer 9

标准 YAML 1.2 本身不包含此功能。 然而，许多实现提供了一些扩展来做到这一点。

我提出了一种使用 Java 和 snakeyaml:1.24 （用于解析/发出 YAML 文件的 Java 库）实现此目标的方法，该方法允许创建自定义 YAML 标记来实现以下目标（您将看到我正在使用它加载在多个 YAML 文件中定义的测试套件，并且我使其作为目标 test: 节点的包含列表工作）：

# ... yaml prev stuff

tests: !include
  - '1.hello-test-suite.yaml'
  - '3.foo-test-suite.yaml'
  - '2.bar-test-suite.yaml'

# ... more yaml document

这是允许处理 的单类 Java !include 标签。 文件从类路径（Maven 资源目录）加载：

/**
 * Custom YAML loader. It adds support to the custom !include tag which allows splitting a YAML file across several
 * files for a better organization of YAML tests.
 */
@Slf4j   // <-- This is a Lombok annotation to auto-generate logger
public class MyYamlLoader {

    private static final Constructor CUSTOM_CONSTRUCTOR = new MyYamlConstructor();

    private MyYamlLoader() {
    }

    /**
     * Parse the only YAML document in a stream and produce the Java Map. It provides support for the custom !include
     * YAML tag to split YAML contents across several files.
     */
    public static Map<String, Object> load(InputStream inputStream) {
        return new Yaml(CUSTOM_CONSTRUCTOR)
                .load(inputStream);
    }


    /**
     * Custom SnakeYAML constructor that registers custom tags.
     */
    private static class MyYamlConstructor extends Constructor {

        private static final String TAG_INCLUDE = "!include";

        MyYamlConstructor() {
            // Register custom tags
            yamlConstructors.put(new Tag(TAG_INCLUDE), new IncludeConstruct());
        }

        /**
         * The actual include tag construct.
         */
        private static class IncludeConstruct implements Construct {

            @Override
            public Object construct(Node node) {
                List<Node> inclusions = castToSequenceNode(node);
                return parseInclusions(inclusions);
            }

            @Override
            public void construct2ndStep(Node node, Object object) {
                // do nothing
            }

            private List<Node> castToSequenceNode(Node node) {
                try {
                    return ((SequenceNode) node).getValue();

                } catch (ClassCastException e) {
                    throw new IllegalArgumentException(String.format("The !import value must be a sequence node, but " +
                            "'%s' found.", node));
                }
            }

            private Object parseInclusions(List<Node> inclusions) {

                List<InputStream> inputStreams = inputStreams(inclusions);

                try (final SequenceInputStream sequencedInputStream =
                             new SequenceInputStream(Collections.enumeration(inputStreams))) {

                    return new Yaml(CUSTOM_CONSTRUCTOR)
                            .load(sequencedInputStream);

                } catch (IOException e) {
                    log.error("Error closing the stream.", e);
                    return null;
                }
            }

            private List<InputStream> inputStreams(List<Node> scalarNodes) {
                return scalarNodes.stream()
                        .map(this::inputStream)
                        .collect(toList());
            }

            private InputStream inputStream(Node scalarNode) {
                String filePath = castToScalarNode(scalarNode).getValue();
                final InputStream is = getClass().getClassLoader().getResourceAsStream(filePath);
                Assert.notNull(is, String.format("Resource file %s not found.", filePath));
                return is;
            }

            private ScalarNode castToScalarNode(Node scalarNode) {
                try {
                    return ((ScalarNode) scalarNode);

                } catch (ClassCastException e) {
                    throw new IllegalArgumentException(String.format("The value must be a scalar node, but '%s' found" +
                            ".", scalarNode));
                }
            }
        }

    }

}

Answer 10

不幸的是，YAML 并没有在其标准中提供这一点。

但如果您使用 Ruby，那么有一个 gem 通过扩展 ruby​​ YAML 库来提供您所需的功能：
https://github.com/entwanderer/yaml_extend

Answer 11

使用 Symfony，它对 yaml 的处理将间接允许您嵌套 yaml 文件。 诀窍是利用 parameters 选项。 例如：

common.yml

parameters:
    yaml_to_repeat:
        option: "value"
        foo:
            - "bar"
            - "baz"

config.yml

imports:
    - { resource: common.yml }
whatever:
    thing: "%yaml_to_repeat%"
    other_thing: "%yaml_to_repeat%"

结果将与以下内容相同：

whatever:
    thing:
        option: "value"
        foo:
            - "bar"
            - "baz"
    other_thing:
        option: "value"
        foo:
            - "bar"
            - "baz"

Answer 12

我认为@maxy-B 使用的解决方案看起来很棒。 然而，对于我来说，嵌套包含物并没有成功。 例如，如果 config_1.yaml 包含 config_2.yaml，而 config_2.yaml 包含 config_3.yaml，则加载程序出现问题。 但是，如果您只是在加载时将新的加载器类指向其自身，那么它就可以工作！ 具体来说，如果我们用稍微修改过的版本替换旧的 _include 函数：

def _include(self, loader, node):                                    
     oldRoot = self.root                                              
     filename = os.path.join(self.root, loader.construct_scalar(node))
     self.root = os.path.dirname(filename)                           
     data = yaml.load(open(filename, 'r'), loader = IncludeLoader)                            
     self.root = oldRoot                                              
     return data

经过反思，我同意其他评论，嵌套加载通常不适合 yaml，因为输入流可能不是文件，但它非常有用！

Answer 13

我举几个例子供大家参考。

import yaml

main_yaml = """
Package:
 - !include _shape_yaml    
 - !include _path_yaml
"""

_shape_yaml = """
# Define
Rectangle: &id_Rectangle
    name: Rectangle
    width: &Rectangle_width 20
    height: &Rectangle_height 10
    area: !product [*Rectangle_width, *Rectangle_height]

Circle: &id_Circle
    name: Circle
    radius: &Circle_radius 5
    area: !product [*Circle_radius, *Circle_radius, pi]

# Setting
Shape:
    property: *id_Rectangle
    color: red
"""

_path_yaml = """
# Define
Root: &BASE /path/src/

Paths: 
    a: &id_path_a !join [*BASE, a]
    b: &id_path_b !join [*BASE, b]

# Setting
Path:
    input_file: *id_path_a
"""


# define custom tag handler
def yaml_import(loader, node):
    other_yaml_file = loader.construct_scalar(node)
    return yaml.load(eval(other_yaml_file), Loader=yaml.SafeLoader)


def yaml_product(loader, node):
    import math
    list_data = loader.construct_sequence(node)
    result = 1
    pi = math.pi
    for val in list_data:
        result *= eval(val) if isinstance(val, str) else val
    return result


def yaml_join(loader, node):
    seq = loader.construct_sequence(node)
    return ''.join([str(i) for i in seq])


def yaml_ref(loader, node):
    ref = loader.construct_sequence(node)
    return ref[0]


def yaml_dict_ref(loader: yaml.loader.SafeLoader, node):
    dict_data, key, const_value = loader.construct_sequence(node)
    return dict_data[key] + str(const_value)


def main():
    # register the tag handler
    yaml.SafeLoader.add_constructor(tag='!include', constructor=yaml_import)
    yaml.SafeLoader.add_constructor(tag='!product', constructor=yaml_product)
    yaml.SafeLoader.add_constructor(tag='!join', constructor=yaml_join)
    yaml.SafeLoader.add_constructor(tag='!ref', constructor=yaml_ref)
    yaml.SafeLoader.add_constructor(tag='!dict_ref', constructor=yaml_dict_ref)

    config = yaml.load(main_yaml, Loader=yaml.SafeLoader)

    pk_shape, pk_path = config['Package']
    pk_shape, pk_path = pk_shape['Shape'], pk_path['Path']
    print(f"shape name: {pk_shape['property']['name']}")
    print(f"shape area: {pk_shape['property']['area']}")
    print(f"shape color: {pk_shape['color']}")

    print(f"input file: {pk_path['input_file']}")


if __name__ == '__main__':
    main()

输出

shape name: Rectangle
shape area: 200
shape color: red
input file: /path/src/a

Update 2

，你可以将它组合起来，就像这样

# xxx.yaml
CREATE_FONT_PICTURE:
  PROJECTS:
    SUNG: &id_SUNG
      name: SUNG
      work_dir: SUNG
      output_dir: temp
      font_pixel: 24


  DEFINE: &id_define !ref [*id_SUNG]  # you can use config['CREATE_FONT_PICTURE']['DEFINE'][name, work_dir, ... font_pixel]
  AUTO_INIT:
    basename_suffix: !dict_ref [*id_define, name, !product [5, 3, 2]]  # SUNG30

# ↓ This is not correct.
# basename_suffix: !dict_ref [*id_define, name, !product [5, 3, 2]]  # It will build by Deep-level. id_define is Deep-level: 2. So you must put it after 2. otherwise, it can't refer to the correct value.

Answer 14

您的问题并不要求 Python 解决方案，但这里是使用 PyYAML 的解决方案。

PyYAML 允许您将自定义构造函数（例如 !include）附加到 YAML 加载器。 我已经包含了一个可以设置的根目录，以便该解决方案支持相对和绝对文件引用。

基于类的解决方案

这是一个基于类的解决方案，它避免了我原始响应的全局根变量。

请参阅此 gist，了解类似、更强大的 Python 3 解决方案，该解决方案使用元类来注册自定义构造函数。

import yaml
import os

class Loader(yaml.SafeLoader):

    def __init__(self, stream):

        self._root = os.path.split(stream.name)[0]

        super(Loader, self).__init__(stream)

    def include(self, node):

        filename = os.path.join(self._root, self.construct_scalar(node))

        with open(filename, 'r') as f:
            return yaml.load(f, Loader)

Loader.add_constructor('!include', Loader.include)

示例：

foo.yaml

a: 1
b:
    - 1.43
    - 543.55
c: !include bar.yaml

bar.yaml

- 3.6
- [1, 2, 3]

现在可以使用以下方式加载文件：

>>> with open('foo.yaml', 'r') as f:
>>>    data = yaml.load(f, Loader)
>>> data
{'a': 1, 'b': [1.43, 543.55], 'c': [3.6, [1, 2, 3]]}

Answer 15

对于 Python 用户，您可以尝试 pyyaml-include。

安装

pip install pyyaml-include

用法

import yaml
from yamlinclude import YamlIncludeConstructor

YamlIncludeConstructor.add_to_loader_class(loader_class=yaml.FullLoader, base_dir='/your/conf/dir')

with open('0.yaml') as f:
    data = yaml.load(f, Loader=yaml.FullLoader)

print(data)

考虑我们有这样的 YAML 文件：

├── 0.yaml
└── include.d
    ├── 1.yaml
    └── 2.yaml

• 1.yaml 的内容：

name: "1"

• 2.yaml 的内容：

name: "2"

按名称包含文件

• 在顶层：

  如果 0.yaml 是：

!include include.d/1.yaml

我们将得到：

{"name": "1"}

• 在映射中：

  如果 0.yaml 是：

file1: !include include.d/1.yaml
file2: !include include.d/2.yaml

我们将得到：

  file1:
    name: "1"
  file2:
    name: "2"

• 按顺序：

  >

  如果 0.yaml 是：

files:
  - !include include.d/1.yaml
  - !include include.d/2.yaml

我们将得到：

files:
  - name: "1"
  - name: "2"

ℹ注意：

文件名可以是绝对的（如/usr/conf/1.5/Make.yml）或相对的（如../../cfg/img.yml） >).

通过通配符包含

文件 文件名可以包含 shell 样式的通配符。 从通配符找到的文件加载的数据将按顺序设置。

如果 0.yaml 是：

files: !include include.d/*.yaml

我们将得到：

files:
  - name: "1"
  - name: "2"

ℹ注意：

• 对于 Python>=3.5，如果 !include 的递归参数 YAML 标记为 true，模式 “**” 将匹配任何文件以及零个或多个目录和子目录。
• 由于递归搜索，在大型目录树中使用“**”模式可能会消耗过多的时间。

为了启用recursive参数，我们应该在Mapping或Sequence模式下编写!include标签：

• Arguments in Sequence 模式：

!include [tests/data/include.d/**/*.yaml, true]

• Mapping 模式下的参数：

!include {pathname: tests/data/include.d/**/*.yaml, recursive: true}

Answer 16

YML 标准没有指定执行此操作的方法。 而且这个问题并不局限于 YML。 JSON 也有同样的限制。

许多使用基于 YML 或 JSON 的配置的应用程序最终都会遇到这个问题。 当这种情况发生时，他们会制定自己的惯例。

例如，对于 swagger API 定义：

$ref: 'file.yml'

例如，对于 docker compose 配置：

services:
  app:
    extends:
      file: docker-compose.base.yml

或者，如果您想将 yml 文件的内容拆分为多个文件（如内容树），您可以定义自己的文件夹结构约定并使用（现有的) 合并脚本。

Answer 17

不，标准 YAML 不包含任何类型的“导入”或“包含”语句。