Mise à jour de fichier YAML par programmation

J'ai un Python dict qui vient de la lecture d'un fichier YAML avec l'habitude

yaml.load(stream)

J'aimerais mettre à jour le fichier YAML par programme donné un chemin pour être mis à jour comme d':

groupe1,option1,option11,valeur

et d'enregistrer le résultat dict à nouveau comme un fichier yaml. Je suis confronté au problème de la mise à jour d'un dicntionary, en tenant compte que le chemin est dynamique (disons un utilisateur est en mesure de saisir le chemin d'accès par le biais d'un simple CLI, je l'ai créé à l'aide de Cmd).

Des idées?

merci!

Mise à JOUR
Permettez-moi d'être plus précis sur la question: Le problème avec la mise à jour de la partie d'un dictionnaire où je ne sais pas à l'avance la structure. Je travaille sur un projet où toute la configuration est stockée sur les fichiers YAML, et je veux ajouter une CLI pour éviter d'avoir à éditer à la main. Cette un fichier YAML, chargé d'un dictionnaire (config-dict) à l'aide de PyYaml:

config:
 a-function: enable
 b-function: disable
 firewall:
  NET:
   A:
    uplink: enable
    downlink: enable
   B:
    uplink: enable
    downlink: enable
  subscriber-filter:
   cancellation-timer: 180
 service:
  copy:
   DS: enable
  remark:
   header-remark:
    DSC: enable
    remark-table:
 port:
  linkup-debounce: 300
  p0:
   mode: amode
  p1:
   mode: bmode
  p2:
   mode: amode
  p3:
   mode: bmode

J'ai créé la CLI avec Cmd, et ça fonctionne très bien même avec l'auto-complétion. L'utilisateur peut fournir une ligne comme:

config port p1 mode amode

Donc, j'ai besoin de modifier:

config-dict['config']['port']['p1']['mode'] et le mettre à "amode'. Ensuite, utilisez yaml.dump() pour créer le fichier de nouveau. Une autre ligne serait:

config a-function enable

Donc config-dict['config']['d'une fonction'] doit être réglé sur "activer".

Mon problème est lors de la mise à jour du dictionnaire. Si Python les valeurs passées en tant que référence serait facile: il suffit de parcourir le dict jusqu'à ce que la valeur est trouvée et l'enregistrer. Effectivement, c'est ce que je fais pour le Cmd de saisie semi-automatique. Mais je ne sais pas comment faire la mise à jour.

Espère que j'ai expliqué me suis mieux maintenant!

Merci d'avance.

Enregistrement de YAML est yaml.dump facile, mais vous vous demandez pour la conception de votre application. C'est trop difficile, de l'avis de la base, et, en fait, n'a pas beaucoup à faire avec YAML.
merci pour votre réponse. Vous avez raison, je suis en demandant plus à propos de Python que YAML lui-même. Il n'est pas sur le design, mais une question très précise: Comment mettre à jour un dictionnaire qui a une dynamique de la taille.
Euh, je ne vois pas un problème ici - vraiment simple serait d'analyser le chemin indiqué sur la cli, marcher à travers votre dictionnaire pour assurer le chemin est valide, changer la valeur de vidage. Où est le problème? Autre que cela - qu'avez-vous essayé, ce qui n'a pas de travail, de coller du code.
Double Possible de l'Accès python imbriquée des éléments dans le dictionnaire via une liste de touches

OriginalL'auteur Ignacio Verona | 2014-05-28

  1. 15

    En fait la solution suit simple formulation: charge - modifier - dump:

    Avant de jouer, assurez-vous d'avoir pyyaml installé:

    $ pip install pyyaml

    testyaml.py

    import yaml
fname = "data.yaml"

dct = {"Jan": {"score": 3, "city": "Karvina"}, "David": {"score": 33, "city": "Brno"}}

with open(fname, "w") as f:
    yaml.dump(dct, f)

with open(fname) as f:
    newdct = yaml.load(f)

print newdct
newdct["Pipi"] = {"score": 1000000, "city": "Stockholm"}

with open(fname, "w") as f:
    yaml.dump(newdct, f)

    Résultant data.yaml

    $ cat data.yaml
David: {city: Brno, score: 33}
Jan: {city: Karvina, score: 3}
Pipi: {city: Stockholm, score: 1000000}
    Merci @Janv. Le problème ici est que le chemin de mise à jour n'est pas fixe. J'ai peut-être updaing dict['A']['a1']['a11'] ou dict['A']['a2']['a21']['a221'], en fonction de l'entrée de l'utilisateur. Donc, je suis à essayer de comprendre comment faire une boucle à travers le dict basée sur une "clé" (quelque chose comme 'A,a1,a11' et mise à jour de la valeur.
    Pour modifier dict dynamique avec nombre de touches, voir stackoverflow.com/questions/17462011/...
    qui travaille pour l'insertion, mais quid de la mise à jour? Si python autorisé par référence ce sera facile, mais comme elle n'a pas c'est un peu difficile pour moi!

    OriginalL'auteur Jan Vlcinsky

  2. 0

    La mise à jour semble à l'endroit où pyyaml en deçà. Vous ne pouvez même pas utiliser yaml.charge sur un fichier qui a été ouvert dans (a)ppend mode sans exception. Maintenant, cela peut être un peu fastidieux pour des complexes de dictionnaires, mais si chaque élément représente un cas à part ou le document que vous pourrait le manipuler comme s'il s'agissait de tout autre fichier texte. 

    newinfo = {"Pipi": {"score": 100000, "city": "Stockholm"}}
with open(fname, "a") as f:
     sep = "\n" # For distinct documents use "\n...\n" as separator

     # Pay attention to where you put the separator. 
     # if the file exists and is in traditional format place at 
     # beginning of string. else place at the end.

     infostring = "{}".format(newinfo)
     f.write(infostring + sep)

    Alors que ce n'est pas nécessairement la valeur de la mise à jour, il ne permet pas pour le fichier de mise à jour. Vous pouvez aussi rechercher dans l'aide de json.dump sur le fichier. Je sais que c'est en YAML, mais les formats sont largement compatibles, sauf si vous utilisez python-objet en fonction de stockage en YAML.

    Pour un système d'exploitation agnostique approche pour le transport de personnage affectation n'oubliez pas d'utiliser le système d'exploitation.linesep.

    Meilleur de la chance. Espérons que cette aide.

    Vous avez un peu de redondance ici si vous appelez fermer à f après le gestionnaire de contexte de la fermeture. Pas sûr au sujet de l'appel de vidage, mais je pense que le gestionnaire de contexte prend soin de cela.
    Merci pour la capture. Honnêtement, flush() est juste à la force de l'habitude à ce stade. Et j'oublie toujours si/où il devrait y avoir une close(). Merci encore.

    OriginalL'auteur Dan Temkin

  3. 0

    Essayer cette méthode, je suis à l'aide de la mise à jour de données ou des fichiers json.

    def update_dictionary_recursively(dictionary, key, value, key_separator="."):
    """Update given    dictionnairewith the givencléandvaleur".

    if dictionary contains value as dict E.g. {key1:value1, key2:{key3, {key4:value4}}} and you have to
update key4 then `key` should be given as `key2.key3.key4`.

If dictionary contains value as list E.g. {key1:{key2:[{key3:valie3}, {key4:value4}]}} and you have to update
key4 then `key` should be given as `key1.key2[1].key4`.

:param dictionary: Dictionary that is to be updated.
:type dictionary: dict
:param key: Key with which the dictionary is to be updated.
:type key: str
:param value: The value which will be used to update the key in dictionary.
:type value: object
:param key_separator: Separator with which key is separated.
:type key_separator str
:return: Return updated dictionary.
:rtype: dict
"""
index = key.find(key_separator)
if index != -1:
    current_key = key[0:index]
    key = key[index + 1:]
    try:
        if '[' in current_key:
            key_index = current_key.split('[')
            current_key = key_index[0]
            list_index = int(key_index[1].strip(']'))
            dictionary[current_key][list_index] = update_dictionary_recursively(
                dictionary[current_key][list_index], key, value, key_separator)
        else:
            dictionary[current_key] = update_dictionary_recursively(dictionary[current_key],
                                                                                    key, value, key_separator)
    except (KeyError, IndexError):
        return dictionary
else:
    if '[' in key:
        key_index = key.split('[')
        list_index = int(key_index[1].strip(']'))
        if list_index > len(dictionary) - 1:
            return dictionary
        dictionary[list_index] = value
    else:
        if key not in dictionary:
            return dictionary
        dictionary[key] = value
return dictionary

    `

    OriginalL'auteur Jyoti Arora