comment référencer un YAML “définition” d'ailleurs dans le même fichier YAML?

Je ne pense pas que c'est possible. Vous pouvez réutiliser le "nœud", mais n'en font pas partie.

bill-to: &id001
    given  : Chris
    family : Dumars
ship-to: *id001

Ce qui est parfaitement valide YAML et les champs given et family sont réutilisés dans ship-to bloc. Vous pouvez réutiliser un scalaire nœud de la même manière, mais il n'y a aucun moyen que vous pouvez changer ce qui est à l'intérieur et d'ajouter que la dernière partie du trajet à partir de l'intérieur YAML.

Si la répétition vous dérange pas que je vous suggérons de faire votre demande de conscience de root de la propriété et de l'ajouter à chaque chemin que semble relative, pas absolue.

Une autre façon de voir cela est de simplement utiliser un autre champ.

paths:
  root_path: &root
     val: /path/to/root/
  patha: &a
    root_path: *root
    rel_path: a
  pathb: &b
    root_path: *root
    rel_path: b
  pathc: &c
    root_path: *root
    rel_path: c

J'ai créer une bibliothèque, disponible sur Packagist, qui exerce cette fonction:
https://packagist.org/packages/grasmash/yaml-expander

Exemple fichier YAML:

type: book
book:
  title: Dune
  author: Frank Herbert
  copyright: ${book.author} 1965
  protaganist: ${characters.0.name}
  media:
    - hardcover
characters:
  - name: Paul Atreides
    occupation: Kwisatz Haderach
    aliases:
      - Usul
      - Muad'Dib
      - The Preacher
  - name: Duncan Idaho
    occupation: Swordmaster
summary: ${book.title} by ${book.author}
product-name: ${${type}.title}

Exemple de logique:

//Parse a yaml string directly, expanding internal property references.
$yaml_string = file_get_contents("dune.yml");
$expanded = \Grasmash\YamlExpander\Expander::parse($yaml_string);
print_r($expanded);

Résultante de tableau:

array (
  'type' => 'book',
  'book' => 
  array (
    'title' => 'Dune',
    'author' => 'Frank Herbert',
    'copyright' => 'Frank Herbert 1965',
    'protaganist' => 'Paul Atreides',
    'media' => 
    array (
      0 => 'hardcover',
    ),
  ),
  'characters' => 
  array (
    0 => 
    array (
      'name' => 'Paul Atreides',
      'occupation' => 'Kwisatz Haderach',
      'aliases' => 
      array (
        0 => 'Usul',
        1 => 'Muad\'Dib',
        2 => 'The Preacher',
      ),
    ),
    1 => 
    array (
      'name' => 'Duncan Idaho',
      'occupation' => 'Swordmaster',
    ),
  ),
  'summary' => 'Dune by Frank Herbert',
);

Que votre exemple n'est pas valide est seulement parce que vous avez choisi d'un caractère réservé pour commencer votre scalaires avec. Si vous remplacez le * avec certains autres non-caractères réservés (j'ai tendance à utiliser des caractères non-ASCII pour ce qu'elles sont rarement utilisées dans le cadre de la spécification), vous vous retrouvez avec parfaitement légal YAML:

paths:
  root: /path/to/root/
  patha: ♦root♦ + a
  pathb: ♦root♦ + b
  pathc: ♦root♦ + c

Cela va charger dans la représentation standard pour les mappages dans la langue de votre analyseur utilise et n'a pas la baguette magique pour développer quoi que ce soit.

Pour ce faire utiliser localement un type d'objet par défaut comme dans l'exemple suivant programme en Python:

# coding: utf-8

from __future__ import print_function

import ruamel.yaml as yaml

class Paths:
    def __init__(self):
        self.d = {}

    def __repr__(self):
        return repr(self.d).replace('ordereddict', 'Paths')

    @staticmethod
    def __yaml_in__(loader, data):
        result = Paths()
        loader.construct_mapping(data, result.d)
        return result

    @staticmethod
    def __yaml_out__(dumper, self):
        return dumper.represent_mapping('!Paths', self.d)

    def __getitem__(self, key):
        res = self.d[key]
        return self.expand(res)

    def expand(self, res):
        try:
            before, rest = res.split(u'♦', 1)
            kw, rest = rest.split(u'♦ +', 1)
            rest = rest.lstrip() # strip any spaces after "+"
            # the lookup will throw the correct keyerror if kw is not found
            # recursive call expand() on the tail if there are multiple
            # parts to replace
            return before + self.d[kw] + self.expand(rest)
        except ValueError:
            return res

yaml_str = """\
paths: !Paths
  root: /path/to/root/
  patha: ♦root♦ + a
  pathb: ♦root♦ + b
  pathc: ♦root♦ + c
"""

loader = yaml.RoundTripLoader
loader.add_constructor('!Paths', Paths.__yaml_in__)

paths = yaml.load(yaml_str, Loader=yaml.RoundTripLoader)['paths']

for k in ['root', 'pathc']:
    print(u'{} -> {}'.format(k, paths[k]))

qui permet d'imprimer:

root -> /path/to/root/
pathc -> /path/to/root/c

L'expansion se fait à la volée et les poignées imbriqués les définitions, mais vous devez être prudent de ne pas invoquer une récursion infinie.

En spécifiant le dumper, vous pouvez vider le original YAML à partir des données chargées dans, en raison de la sur-the-fly expansion:

dumper = yaml.RoundTripDumper
dumper.add_representer(Paths, Paths.__yaml_out__)
print(yaml.dump(paths, Dumper=dumper, allow_unicode=True))

cela va changer la clé de mappage de la commande. Si c'est un problème que vous avez
pour faire self.d un CommentedMap (importé de ruamel.yaml.comments.py)