Así que tengo dos archivos YAML, "A" y "B" y quiero que el contenido de A se inserte dentro de B, ya sea empalmado en la estructura de datos existente, como una matriz, o como un elemento secundario de un elemento, como el valor para una determinada clave hash.

¿Es esto posible en absoluto? ¿Cómo? Si no, ¿algún puntero a una referencia normativa?

No, YAML no incluye ningún tipo de declaración de "importación" o "inclusión".

Su pregunta no solicita una solución de Python, pero aquí hay una que usa PyYAML .

PyYAML le permite adjuntar constructores personalizados (como !include) al cargador YAML. He incluido un directorio raíz que se puede configurar para que esta solución admita referencias de archivo relativas y absolutas.

Solución basada en clase

Aquí hay una solución basada en clases, que evita la variable raíz global de mi respuesta original.

Vea este resumen para una solución Python 3 similar y más robusta que utiliza una metaclase para registrar el constructor personalizado.

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)

Un ejemplo:

foo.yaml

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

bar.yaml

- 3.6
- [1, 2, 3]

Ahora los archivos se pueden cargar usando:

>>> 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]]}

Si está utilizando la versión de Symfony de YAML , esto es posible, así:

imports:
    - { resource: sub-directory/file.yml }
    - { resource: sub-directory/another-file.yml }

Por lo que yo sé, las inclusiones no son directamente compatibles con YAML, tendrá que proporcionar un mecanismo usted mismo, sin embargo, esto generalmente es fácil de hacer.

He usado YAML como lenguaje de configuración en mis aplicaciones de Python, y en este caso a menudo defino una convención como esta:

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

Luego en mi código (python) hago:

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

El único inconveniente es que las variables en las inclusiones siempre anularán las variables en main, y no hay forma de cambiar esa precedencia cambiando dónde aparece la instrucción "include:" en el archivo main.yml.

En un punto ligeramente diferente, YAML no es compatible, ya que no está realmente diseñado tan exclusivamente como un marcado basado en archivos. ¿Qué significaría un include si lo recibiste en respuesta a una solicitud de AJAX?

Para usuarios de Python, puedes probar pyyaml-include .

Instalar en pc

pip install pyyaml-include

Uso

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)

Considere que tenemos tales archivos YAML :

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

• 1.yaml contenido de:

name: "1"

• 2.yaml contenido de:

name: "2"

Incluir archivos por nombre

• En el nivel superior:

  Si 0.yamlfue:

!include include.d/1.yaml

Nosotros recibiremos:

{"name": "1"}

• En mapeo:

  Si 0.yamlfue:

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

Nosotros recibiremos:

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

• En secuencia:

  Si 0.yamlfue:

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

Nosotros recibiremos:

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

ℹ Nota :

El nombre del archivo puede ser absoluto (como /usr/conf/1.5/Make.yml) o relativo (como ../../cfg/img.yml).

Incluir archivos por comodines

El nombre del archivo puede contener comodines de estilo shell. Los datos cargados de los archivos encontrados por comodines se establecerán en una secuencia.

Si 0.yamlfue:

files: !include include.d/*.yaml

Nosotros recibiremos:

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

ℹ Nota :

• Por ejemploPython>=3.5 , si el recursiveargumento de la etiqueta !include YAML es true, el patrón “**”coincidirá con cualquier archivo y cero o más directorios y subdirectorios.
• El uso del “**”patrón en grandes árboles de directorios puede consumir una cantidad excesiva de tiempo debido a la búsqueda recursiva.

Para habilitar el recursiveargumento, escribiremos la !includeetiqueta en Mappingo Sequencemodo:

• Argumentos en Sequencemodo:

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

• Argumentos en Mappingmodo:

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

Ampliando la respuesta de @ Josh_Bode, aquí está mi propia solución PyYAML, que tiene la ventaja de ser una subclase autónoma de yaml.Loader. No depende de ningún nivel global de yamlmódulo o de modificar el estado global del módulo.

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                                                      

Hago algunos ejemplos para su referencia.

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()

salida

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

Actualización 2

y puedes combinarlo así

# 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.

Desafortunadamente, YAML no proporciona esto en su estándar.

Pero si está utilizando Ruby, hay una gema que proporciona la funcionalidad que está solicitando al extender la biblioteca ruby ​​YAML: https://github.com/entwanderer/yaml_extend

Creo que la solución utilizada por @ maxy-B se ve muy bien. Sin embargo, no tuvo éxito para mí con inclusiones anidadas. Por ejemplo, si config_1.yaml incluye config_2.yaml, que incluye config_3.yaml, hubo un problema con el cargador. Sin embargo, si simplemente apunta la nueva clase de cargador a sí misma en la carga, ¡funciona! Específicamente, si reemplazamos la antigua función _include con la versión ligeramente modificada:

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

Después de reflexionar, estoy de acuerdo con los otros comentarios, que la carga anidada no es apropiada para yaml en general, ya que la secuencia de entrada puede no ser un archivo, ¡pero es muy útil!

El estándar YML no especifica una forma de hacer esto. Y este problema no se limita a YML. JSON tiene las mismas limitaciones.

Muchas aplicaciones que usan configuraciones basadas en YML o JSON se topan con este problema eventualmente. Y cuando eso sucede, inventan su propia convención. .

por ejemplo, para definiciones de API swagger:

$ref: 'file.yml'

Por ejemplo, para las configuraciones de composición de Docker:

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

Alternativamente, si desea dividir el contenido de un archivo yml en varios archivos, como un árbol de contenido, puede definir su propia convención de estructura de carpetas y usar un script de fusión (existente).

Tal vez esto pueda inspirarte, intenta alinearte con las convenciones de jbb:

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

- job: name: test-job-include-raw-1 builders: - shell: !include-raw: include-raw001-hello-world.sh

YAML 1.2 estándar no incluye de forma nativa esta función. Sin embargo, muchas implementaciones proporcionan alguna extensión para hacerlo.

Presento una forma de lograrlo con Java y snakeyaml:1.24(biblioteca Java para analizar / emitir archivos YAML) que permite crear una etiqueta YAML personalizada para lograr el siguiente objetivo (verá que lo estoy usando para cargar conjuntos de pruebas definidos en varios archivos YAML y que lo hice funcionar como una lista de incluye para un test:nodo de destino ):

# ... yaml prev stuff

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

# ... more yaml document

Aquí está el Java de una clase que permite procesar la !includeetiqueta. Los archivos se cargan desde classpath (directorio de recursos de 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));
                }
            }
        }

    }

}

Con Yglu , puede importar otros archivos como este:

A.yaml

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

B.yaml

bar: Hello

$ yglu A.yaml
foo:
  bar: Hello

Como $importes una función, también puede pasar una expresión como argumento:

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

Esto daría el mismo resultado que el anterior.

Descargo de responsabilidad: soy el autor de Yglu.

Con Symfony , su manejo de yaml le permitirá indirectamente anidar archivos yaml. El truco es hacer uso de la parametersopción. p.ej:

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%"

El resultado será el mismo que:

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

Probablemente no fue compatible cuando se hizo la pregunta, pero puede importar otro archivo YAML en uno:

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

Aunque no tengo ninguna referencia en línea, pero esto funciona para mí.