Comment puis-je inclure un fichier YAML dans un autre?

Question

J'ai donc deux fichiers YAML, "A" et "B" et je veux que le contenu de A soit inséré dans B, soit épissé dans la structure de données existante, comme un tableau, soit comme enfant d'un élément, comme la valeur d'une certaine clé de hachage.

Est-ce possible? Comment? Si non, des pointeurs vers une référence normative?

Answer 1

Non, YAML n'inclut aucun type d'instruction "import" ou "include".

Answer 2

Ici, je l'ai utilisé mako

a.txt

cela fait partie haut de fichier un
<% include file = 'b.txt' />
ceci est la partie inférieure du fichier un

b.txt

ce fichier est b

test.py

from mako.template import Template 
from mako.lookup import TemplateLookup 
import os 

directory = os.path.dirname(os.path.abspath(__file__)) 
mylookup = TemplateLookup(directories=[directory]) 
mytemplate = Template(filename="a.txt", lookup=mylookup) 
finalsrc = mytemplate.render() 
# finalsrc can be treated as yaml or whatever you like 

$ python test.py
cela fait partie haut de fichier un
ce fichier est b
ceci est la partie inférieure du fichier un

Answer 3

comprend ne sont pas directement pris en charge dans yaml autant que je sache, vous devrez fournir un mécanisme vous-même cependant, c'est généralement facile à faire.

J'ai utilisé yaml comme langue de configuration dans mes applications de python, et dans ce cas définissent souvent un convension comme ceci:

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

Puis dans mon code (python) Je fais:

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

le seul inconvénient est que les variables includes toujours passer outre les variables principales, et il n'y a aucun moyen de changer cette priorité en changeant où « comprend: la déclaration apparaît dans le fichier main.yml

.

Sur un point légèrement différent, yaml ne supporte pas, car il n'est pas vraiment conçu aussi exclusivement comme un fichier basé sur le balisage. Que voudrait dire un moyen si vous l'avez dans une réponse à une requête ajax?

Answer 4

Votre question ne demande pas de solution Python, mais en voici une qui utilise PyYAML.

PyYAML vous permet de joindre des constructeurs personnalisés (tels que !include) au chargeur YAML. J'ai inclus un répertoire racine qui peut être défini pour que cette solution prenne en charge les références de fichiers relatives et absolues.

Solution

Class-Based Voici une solution de classe, qui évite la variable globale racine de ma réponse originale.

Voir cette gist pour une solution Python 3 similaire, plus robuste qui utilise une métaclasse pour enregistrer le constructeur personnalisé.

import yaml 
import os.path 

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 exemple:

foo.yaml

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

bar.yaml

- 3.6 
- [1, 2, 3] 

Maintenant, les fichiers peuvent être chargés à l'aide:

>>> 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 5

expansion sur @ la réponse de Josh_Bode, voici ma propre solution PyYAML, qui a l'avantage d'être une sous-classe autonome de yaml.Loader. Il ne dépend pas des globals au niveau du module, ni de la modification de l'état global du module 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 6

Probablement il n'a pas été pris en charge lorsque la question a été posée, mais vous pouvez importer un autre fichier YAML en un seul:

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

Bien que je n'ai aucune référence en ligne, mais cela fonctionne pour moi.

Answer 7

Si vous utilisez Symfony's version of YAML, cela est possible, comme ceci:

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

Answer 8

Malheureusement YAML ne fournit pas dans sa norme.

Mais si vous utilisez Ruby, il y a un petit bijou offrant la fonctionnalité que vous demandez par l'extension de la bibliothèque YAML rubis: https://github.com/entwanderer/yaml_extend

Answer 9

Avec Symfony, sa gestion de YAML indirectement vous permettre de nid fichiers yaml. L'astuce consiste à utiliser l'option parameters. par exemple:

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

Le résultat sera le même que:

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

Answer 10

Je pense que la solution utilisée par @ maxy-B est super. Cependant, il n'a pas réussi pour moi avec des inclusions imbriquées. Par exemple, si config_1.yaml inclut config_2.yaml, ce qui inclut config_3.yaml, il y a eu un problème avec le chargeur. Cependant, si vous pointez simplement la nouvelle classe loader sur elle-même, cela fonctionne!Plus précisément, si l'on remplace l'ancienne fonction _include avec la version très légèrement modifiée:

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 

Après réflexion, je suis d'accord avec les autres commentaires, que le chargement imbriqué ne convient pas à yaml en général que le flux d'entrée ne peut pas être fichier, mais c'est très utile!