将一个 Yaml 文件包含在另一个文件中
Include One Yaml File Inside Another
我想要一个基本配置文件，其他配置文件使用它来共享通用配置。
例如，如果我有一个文件 base.yml 和
foo: 1
bar:
- 2
- 3
然后是第二个文件 some_file.yml
foo: 2
baz: "baz"
我希望以合并的配置文件结束
foo: 2
bar:
- 2
- 3
baz: "baz"
编写处理 !include 标签的自定义加载程序非常简单。
class ConfigLoader(yaml.SafeLoader):
def __init__(self, stream):
super().__init__(stream)
self._base = Path(stream.name).parent
def include(self, node):
file_name = self.construct_scalar(node)
file_path = self._base.joinpath(file_name)
with file_path.open("rt") as fh:
return yaml.load(fh, IncludeLoader)
然后我可以解析一个 !include 标签。所以如果我的文件是
inherit:
!include base.yml
foo: 2
baz: "baz"
但现在基本配置是一个映射。 IE。如果我加载文件，我将得到
config = {'a': [42], 'c': [3.6, [1, 2, 3]], 'include': [{'a': 1, 'b': [1.43, 543.55]}]}
但是如果我不将标签作为映射的一部分，例如
!include base.yml
foo: 2
baz: "baz"
我收到一个错误。 yaml.scanner.ScannerError: mapping values are not allowed here.
但我知道 yaml 解析器可以在不需要映射的情况下解析标签。因为我可以做
!!python/object:foo.Bar
x: 1.0
y: 3.14
那么我该如何编写加载器 and/or 构建我的 YAML 文件，以便我可以在我的配置中包含另一个文件？
在 YAML 中，您不能混合使用标量、映射键和序列元素。这是无效的 YAML：
- abc
d: e
这也是
some_file_name
a: b
而且你引用了那个标量，并提供了一个标签当然不会改变事实
它是无效的 YAML。
正如您已经发现的那样，您可以诱使加载程序返回 dict 而不是
字符串（就像解析器已经内置了 non-primitive 类型的构造函数，如 datetime.date）。
就是这个：
!!python/object:foo.Bar
x: 1.0
y: 3.14
有效是因为整个映射都被标记了，您只需标记一个标量值。
什么也是无效语法：
!include base.yaml
foo: 2
baz: baz
但你可以这样做：
!include
filename: base.yaml
foo: 2
baz: baz
并以特殊方式处理 'filename' 键，或者使
!include 标记一个空键：
!include : base.yaml # : is a valid tag character, so you need the space
foo: 2
baz: baz
但是我会考虑使用合并键，因为合并本质上就是
你正在尝试做。以下 YAML 有效：
import sys
import ruamel.yaml
from pathlib import Path
yaml_str = """
<<: {x: 42, y: 196, foo: 3}
foo: 2
baz: baz
"""
yaml = ruamel.yaml.YAML(typ='safe')
yaml.default_flow_style = False
data = yaml.load(yaml_str)
yaml.dump(data, sys.stdout)
给出：
baz: baz
foo: 2
x: 42
y: 196
所以你应该能够做到：
<<: !load base.yaml
foo: 2
baz: baz
任何了解合并键的人都会知道如果 base.yaml 包含键 foo 和值 3 会发生什么，
也会明白：
<<: [!load base.yaml, !load config.yaml]
foo: 2
baz: baz
（因为我倾向于将“including”与 C 预处理器中的文本 include 联系起来，我认为 `!load' 可能是一个
更合适的标签，但这可能是个人喜好问题）。
要使合并键起作用，可能最简单的方法是继承 Constructor，因为合并是在标记解析之前完成的：
import sys
import ruamel.yaml
from ruamel.yaml.nodes import MappingNode, SequenceNode, ScalarNode
from ruamel.yaml.constructor import ConstructorError
from ruamel.yaml.compat import _F
from pathlib import Path
class MyConstructor(ruamel.yaml.constructor.SafeConstructor):
def flatten_mapping(self, node):
# type: (Any) -> Any
"""
This implements the merge key feature http://yaml.org/type/merge.html
by inserting keys from the merge dict/list of dicts if not yet
available in this node
"""
merge = [] # type: List[Any]
index = 0
while index < len(node.value):
key_node, value_node = node.value[index]
if key_node.tag == 'tag:yaml.org,2002:merge':
if merge: # double << key
if self.allow_duplicate_keys:
del node.value[index]
index += 1
continue
args = [
'while constructing a mapping',
node.start_mark,
'found duplicate key "{}"'.format(key_node.value),
key_node.start_mark,
"""
To suppress this check see:
http://yaml.readthedocs.io/en/latest/api.html#duplicate-keys
""",
"""\
Duplicate keys will become an error in future releases, and are errors
by default when using the new API.
""",
]
if self.allow_duplicate_keys is None:
warnings.warn(DuplicateKeyFutureWarning(*args))
else:
raise DuplicateKeyError(*args)
del node.value[index]
if isinstance(value_node, ScalarNode) and value_node.tag == '!load':
file_path = None
try:
if self.loader.reader.stream is not None:
file_path = Path(self.loader.reader.stream.name).parent / value_node.value
except AttributeError:
pass
if file_path is None:
file_path = Path(value_node.value)
# there is a bug in ruamel.yaml<=0.17.20 that prevents
# the use of a Path as argument to compose()
with file_path.open('rb') as fp:
merge.extend(ruamel.yaml.YAML().compose(fp).value)
elif isinstance(value_node, MappingNode):
self.flatten_mapping(value_node)
print('vn0', type(value_node.value), value_node.value)
merge.extend(value_node.value)
elif isinstance(value_node, SequenceNode):
submerge = []
for subnode in value_node.value:
if not isinstance(subnode, MappingNode):
raise ConstructorError(
'while constructing a mapping',
node.start_mark,
_F(
'expected a mapping for merging, but found {subnode_id!s}',
subnode_id=subnode.id,
),
subnode.start_mark,
)
self.flatten_mapping(subnode)
submerge.append(subnode.value)
submerge.reverse()
for value in submerge:
merge.extend(value)
else:
raise ConstructorError(
'while constructing a mapping',
node.start_mark,
_F(
'expected a mapping or list of mappings for merging, '
'but found {value_node_id!s}',
value_node_id=value_node.id,
),
value_node.start_mark,
)
elif key_node.tag == 'tag:yaml.org,2002:value':
key_node.tag = 'tag:yaml.org,2002:str'
index += 1
else:
index += 1
if bool(merge):
node.merge = merge # separate merge keys to be able to update without duplicate
node.value = merge + node.value
yaml = ruamel.yaml.YAML(typ='safe', pure=True)
yaml.default_flow_style = False
yaml.Constructor = MyConstructor
yaml_str = """\
<<: !load base.yaml
foo: 2
baz: baz
"""
data = yaml.load(yaml_str)
yaml.dump(data, sys.stdout)
print('---')
file_name = Path('test.yaml')
file_name.write_text("""\
<<: !load base.yaml
bar: 2
baz: baz
""")
data = yaml.load(file_name)
yaml.dump(data, sys.stdout)
这会打印：
bar:
- 2
- 3
baz: baz
foo: 2
---
bar: 2
baz: baz
foo: 1
备注：
- 不要以文本形式打开 YAML 文件。它们是二进制的 (UTF-8)，您应该这样加载它们 (
open(filename, 'rb'))。
- 如果您在问题中包含了一个完整的工作程序（或者至少包含了
IncludeLoader 的文本，它
将有
可以用合并键提供一个完整的工作示例（或者为你找出它
由于某种原因不起作用）
- 事实上，不清楚你的
yaml.load()是实例方法调用（import ruamel.yaml; yaml = ruamel.yaml.YAML()）还是函数调用（from ruamel import yaml）。您不应该使用后者，因为它已被弃用。
我推荐这两个步骤：
- 为包括其他文件
编写或plug-in一个自定义load-constructor
- 构造 YAML 以 合并 其他键（在同一文件中）
或 包括 其他文件
与 类似...但具有 pyyaml.
如何合并 YAML 密钥（从同一文件中）
参见 YAML merge 语法 <<: 用于 键合并 :
---
- &OTHER { foo: 1, bar: [2, 3] }
# merge it in from above
<< : OTHER
# the base
foo: 1
bar:
- 2
- 3
如何包含 YAML 文件
YAML 标记语法没有 include-directive 或类似的语法。
但是每个 YAML-parser 实现都可以提供此功能。
例如，看到另一个answer of Josh这样做：
PyYAML allows you to attach custom constructors (such as !include) to the YAML loader.
这个构造函数可以 plugged-in 由 pyyaml-include 做：
import yaml
from yamlinclude import YamlIncludeConstructor
YamlIncludeConstructor.add_to_loader_class(loader_class=yaml.FullLoader, base_dir='/your/conf/dir') # or specify another dir relatively or absolutely
# default is: include YAML files from current working directory
with open('base.yaml') as f:
data = yaml.load(f, Loader=yaml.FullLoader)
print(data)
到 include（不合并）第二个文件 some_file.yaml（位于同一目录）给出为：
foo: 1
bar:
- 2
- 3
在 base.yaml 添加：
!include some_file.yaml # includes the file on top-level (relative path!)
foo: 1
bar:
- 2
- 3
另请参阅：
- How can I include a YAML file inside another?
推荐的文件扩展名
来自维基百科，YAML：
The official recommended filename extension for YAML files has been .yaml since 2006.12
（来源于官方 YAML-FAQ：“YAML Ain't Markup Language”。2006 年 9 月 24 日。原始存档于 2006-09-24。）
我想要一个基本配置文件，其他配置文件使用它来共享通用配置。
例如，如果我有一个文件 base.yml 和
foo: 1
bar:
- 2
- 3
然后是第二个文件 some_file.yml
foo: 2
baz: "baz"
我希望以合并的配置文件结束
foo: 2
bar:
- 2
- 3
baz: "baz"
编写处理 !include 标签的自定义加载程序非常简单。
class ConfigLoader(yaml.SafeLoader):
def __init__(self, stream):
super().__init__(stream)
self._base = Path(stream.name).parent
def include(self, node):
file_name = self.construct_scalar(node)
file_path = self._base.joinpath(file_name)
with file_path.open("rt") as fh:
return yaml.load(fh, IncludeLoader)
然后我可以解析一个 !include 标签。所以如果我的文件是
inherit:
!include base.yml
foo: 2
baz: "baz"
但现在基本配置是一个映射。 IE。如果我加载文件，我将得到
config = {'a': [42], 'c': [3.6, [1, 2, 3]], 'include': [{'a': 1, 'b': [1.43, 543.55]}]}
但是如果我不将标签作为映射的一部分，例如
!include base.yml
foo: 2
baz: "baz"
我收到一个错误。 yaml.scanner.ScannerError: mapping values are not allowed here.
但我知道 yaml 解析器可以在不需要映射的情况下解析标签。因为我可以做
!!python/object:foo.Bar
x: 1.0
y: 3.14
那么我该如何编写加载器 and/or 构建我的 YAML 文件，以便我可以在我的配置中包含另一个文件？
在 YAML 中，您不能混合使用标量、映射键和序列元素。这是无效的 YAML：
- abc
d: e
这也是
some_file_name
a: b
而且你引用了那个标量，并提供了一个标签当然不会改变事实 它是无效的 YAML。
正如您已经发现的那样，您可以诱使加载程序返回 dict 而不是
字符串（就像解析器已经内置了 non-primitive 类型的构造函数，如 datetime.date）。
就是这个：
!!python/object:foo.Bar
x: 1.0
y: 3.14
有效是因为整个映射都被标记了，您只需标记一个标量值。
什么也是无效语法：
!include base.yaml
foo: 2
baz: baz
但你可以这样做：
!include
filename: base.yaml
foo: 2
baz: baz
并以特殊方式处理 'filename' 键，或者使
!include 标记一个空键：
!include : base.yaml # : is a valid tag character, so you need the space
foo: 2
baz: baz
但是我会考虑使用合并键，因为合并本质上就是 你正在尝试做。以下 YAML 有效：
import sys
import ruamel.yaml
from pathlib import Path
yaml_str = """
<<: {x: 42, y: 196, foo: 3}
foo: 2
baz: baz
"""
yaml = ruamel.yaml.YAML(typ='safe')
yaml.default_flow_style = False
data = yaml.load(yaml_str)
yaml.dump(data, sys.stdout)
给出：
baz: baz
foo: 2
x: 42
y: 196
所以你应该能够做到：
<<: !load base.yaml
foo: 2
baz: baz
任何了解合并键的人都会知道如果 base.yaml 包含键 foo 和值 3 会发生什么，
也会明白：
<<: [!load base.yaml, !load config.yaml]
foo: 2
baz: baz
（因为我倾向于将“including”与 C 预处理器中的文本 include 联系起来，我认为 `!load' 可能是一个 更合适的标签，但这可能是个人喜好问题）。
要使合并键起作用，可能最简单的方法是继承 Constructor，因为合并是在标记解析之前完成的：
import sys
import ruamel.yaml
from ruamel.yaml.nodes import MappingNode, SequenceNode, ScalarNode
from ruamel.yaml.constructor import ConstructorError
from ruamel.yaml.compat import _F
from pathlib import Path
class MyConstructor(ruamel.yaml.constructor.SafeConstructor):
def flatten_mapping(self, node):
# type: (Any) -> Any
"""
This implements the merge key feature http://yaml.org/type/merge.html
by inserting keys from the merge dict/list of dicts if not yet
available in this node
"""
merge = [] # type: List[Any]
index = 0
while index < len(node.value):
key_node, value_node = node.value[index]
if key_node.tag == 'tag:yaml.org,2002:merge':
if merge: # double << key
if self.allow_duplicate_keys:
del node.value[index]
index += 1
continue
args = [
'while constructing a mapping',
node.start_mark,
'found duplicate key "{}"'.format(key_node.value),
key_node.start_mark,
"""
To suppress this check see:
http://yaml.readthedocs.io/en/latest/api.html#duplicate-keys
""",
"""\
Duplicate keys will become an error in future releases, and are errors
by default when using the new API.
""",
]
if self.allow_duplicate_keys is None:
warnings.warn(DuplicateKeyFutureWarning(*args))
else:
raise DuplicateKeyError(*args)
del node.value[index]
if isinstance(value_node, ScalarNode) and value_node.tag == '!load':
file_path = None
try:
if self.loader.reader.stream is not None:
file_path = Path(self.loader.reader.stream.name).parent / value_node.value
except AttributeError:
pass
if file_path is None:
file_path = Path(value_node.value)
# there is a bug in ruamel.yaml<=0.17.20 that prevents
# the use of a Path as argument to compose()
with file_path.open('rb') as fp:
merge.extend(ruamel.yaml.YAML().compose(fp).value)
elif isinstance(value_node, MappingNode):
self.flatten_mapping(value_node)
print('vn0', type(value_node.value), value_node.value)
merge.extend(value_node.value)
elif isinstance(value_node, SequenceNode):
submerge = []
for subnode in value_node.value:
if not isinstance(subnode, MappingNode):
raise ConstructorError(
'while constructing a mapping',
node.start_mark,
_F(
'expected a mapping for merging, but found {subnode_id!s}',
subnode_id=subnode.id,
),
subnode.start_mark,
)
self.flatten_mapping(subnode)
submerge.append(subnode.value)
submerge.reverse()
for value in submerge:
merge.extend(value)
else:
raise ConstructorError(
'while constructing a mapping',
node.start_mark,
_F(
'expected a mapping or list of mappings for merging, '
'but found {value_node_id!s}',
value_node_id=value_node.id,
),
value_node.start_mark,
)
elif key_node.tag == 'tag:yaml.org,2002:value':
key_node.tag = 'tag:yaml.org,2002:str'
index += 1
else:
index += 1
if bool(merge):
node.merge = merge # separate merge keys to be able to update without duplicate
node.value = merge + node.value
yaml = ruamel.yaml.YAML(typ='safe', pure=True)
yaml.default_flow_style = False
yaml.Constructor = MyConstructor
yaml_str = """\
<<: !load base.yaml
foo: 2
baz: baz
"""
data = yaml.load(yaml_str)
yaml.dump(data, sys.stdout)
print('---')
file_name = Path('test.yaml')
file_name.write_text("""\
<<: !load base.yaml
bar: 2
baz: baz
""")
data = yaml.load(file_name)
yaml.dump(data, sys.stdout)
这会打印：
bar:
- 2
- 3
baz: baz
foo: 2
---
bar: 2
baz: baz
foo: 1
备注：
- 不要以文本形式打开 YAML 文件。它们是二进制的 (UTF-8)，您应该这样加载它们 (
open(filename, 'rb'))。 - 如果您在问题中包含了一个完整的工作程序（或者至少包含了
IncludeLoader的文本，它 将有 可以用合并键提供一个完整的工作示例（或者为你找出它 由于某种原因不起作用） - 事实上，不清楚你的
yaml.load()是实例方法调用（import ruamel.yaml; yaml = ruamel.yaml.YAML()）还是函数调用（from ruamel import yaml）。您不应该使用后者，因为它已被弃用。
我推荐这两个步骤：
- 为包括其他文件 编写或plug-in一个自定义load-constructor
- 构造 YAML 以 合并 其他键（在同一文件中） 或 包括 其他文件
与 pyyaml.
如何合并 YAML 密钥（从同一文件中）
参见 YAML merge 语法 <<: 用于 键合并 :
---
- &OTHER { foo: 1, bar: [2, 3] }
# merge it in from above
<< : OTHER
# the base
foo: 1
bar:
- 2
- 3
如何包含 YAML 文件
YAML 标记语法没有 include-directive 或类似的语法。 但是每个 YAML-parser 实现都可以提供此功能。
例如，看到另一个answer of Josh这样做：
PyYAML allows you to attach custom constructors (such as
!include) to the YAML loader.
这个构造函数可以 plugged-in 由 pyyaml-include 做：
import yaml
from yamlinclude import YamlIncludeConstructor
YamlIncludeConstructor.add_to_loader_class(loader_class=yaml.FullLoader, base_dir='/your/conf/dir') # or specify another dir relatively or absolutely
# default is: include YAML files from current working directory
with open('base.yaml') as f:
data = yaml.load(f, Loader=yaml.FullLoader)
print(data)
到 include（不合并）第二个文件 some_file.yaml（位于同一目录）给出为：
foo: 1
bar:
- 2
- 3
在 base.yaml 添加：
!include some_file.yaml # includes the file on top-level (relative path!)
foo: 1
bar:
- 2
- 3
另请参阅：
- How can I include a YAML file inside another?
推荐的文件扩展名
来自维基百科，YAML：
The official recommended filename extension for YAML files has been
.yamlsince 2006.12
（来源于官方 YAML-FAQ：“YAML Ain't Markup Language”。2006 年 9 月 24 日。原始存档于 2006-09-24。）