python tree répertoires noms uniques, algorithmes arbre

Question

Je travaille avec un système terrible qui a mis en œuvre la structure de l'arborescence de répertoires et l'importation de soutien de cette structure d'une "manière étrange", car importer support uniquement le format child;parent. contraintes d'importation:
- éléments enfants doivent avoir nom unique
- si l'élément parent est dupliqué, l'enfant sont importées sous le premier parent trouva

ASSUMER ayant une structure suivante de répertoires à créer

root 
|-- A 
| |-- aa 
| | |-- cc 
| | `-- dd 
| `-- bb 
|  `-- ee 
`-- B 
    |-- aa 
    | |-- cc 
    | `-- dd 
    `-- bb 
     `-- FF 

Comment importer par défaut importer, qui ne fonctionne pas ou produire une mauvaise représentation:

child;parent 
root 
A;root 
aa;A 
cc;aa 
dd;aa 
bb;A 
ee;bb 
B;root 
aa;B <-- duplicated child item does not work 
cc;aa <-- duplicated entry - system saves it under A instead of under B 
dd;aa <-- duplicated entry - system saves it under A instead of under B 
bb;B 
FF;bb <-- system saves it under A instead of under B 

Wrong r ePresentation

root 
|-- A 
| |-- aa 
| | |-- cc 
| | `-- dd 
| `-- bb 
|  |-- FF 
|  `-- ee 
`-- B 
    `-- aa 
     |-- cc 
     `-- dd 

Pour résoudre ce problème, j'ai décidé de renommer chaque dossier avec chaîne unique =id + modifications supplémentaires (nom plus court, etc. pour répondre aux exigences du système) et importé dans un système, puis retiré =id via la base de données.
alors des paires d'importation ressemble à:

child;parent 
root; 
A==1;root=0 
aa=2;A=1 
cc=3;aa=2 
dd=4;aa=2 
bb=5;A=1 
ee=7;bb=3 
B=8;root=0 
aa=9;B=8 
cc=10;aa=9 
dd=11;aa=9 
bb=12;B=8 
FF=13;bb=12 

Et la structure est comme on le souhaite

root=0 
|-- A=1 
| |-- aa=2 
| | |-- cc=3 
| | `-- dd=4 
| `-- bb=5 
|  `-- ee=7 
`-- B=8 
    |-- aa=9 
    | |-- cc=10 
    | `-- dd=11 
    `-- bb=12 
     `-- FF=13 

Cependant, je dois travailler avec le besoin de travailler avec la structure d'origine sans le renommer.
J'ai eu l'idée que je pouvais garder la structure juste en mémoire en utilisant la structure des données arborescentes, mais je suis resté coincé dans la mise en œuvre.

Je voulais utiliser os.walk('root') et treelib mais j'ai besoin d'aide pour l'implémenter.

Tous les conseils sont très appréciés. Merci

Answer 1

Je trouve la manière comment avoir des références pour les répertoires originaux et rebaptisés

J'ai utilisé le treelib parce que chaque node peut contenir tag, identifier, data, et treelib.Tree étendu par la méthode create_from_path.
pour ce chemin: root/A/bb/cc/dd

ensuite Fractionner le chemin donné root/A/bb/cc/dd en portions et visiter chaque nœud + mise à jour si elle existe déjà: utilisant ce modèle:
treelib.Node(tag=unique_name, identifier=full_path, data=base_name)

root ->Node(root=1, root, root)
root/A ->Node(A=2, root/A, A)
root/A/bb ->Node(bb=3, root/A/bb, bb)
root/A/bb/cc ->Node(cc=4, root/A/bb/cc, cc)
root/A/bb/cc/dd ->Node(dd=5, root/A/bb/cc/dd, dd)

Je pouvais traverser à travers l'arbre et construire des chemins souhaités comme: root=1/A=2/bb=3/cc=4/dd=5

Answer 2

Donc le problème ici est que dans votre système tous les noms des répertoires semblent être dans la même portée. Ce n'est pas résolu sans renommer les dossiers. Cependant, au lieu de simplement indexer chaque dossier, mon approche serait d'encoder la structure parente dans le nom. Pour votre exemple votre code ressemblerait à quelque chose comme ceci:

child;parent 
root 
root/A;root 
root/A/aa;root/A 
root/A/aa/cc;root/A/aa 
... 
root/B;root 
root/B/aa;root/B <-- not duplicated anymore. 
... 

Cependant, il pourrait y avoir des problèmes avec cette approche puisque les noms de répertoires peuvent devenir très long. Quel accès avez-vous au système, pouvez-vous le modifier? Si je vous comprends bien, il est utilisé pour créer une structure de dossiers? Ensuite, il semble que le système ne supporte pas d'avoir des enfants dans des répertoires différents avec le même nom. Mon approche présentée est facile si vous utilisez bash pour générer le fichier d'importation (à partir d'une structure de répertoire déjà existante), puisque la commande pwd vous donne le chemin absolu vers un répertoire.

Si vous avez accès à modifier le système une solution serait d'avoir un dict dans chaque nœud de dossier (pour éviter les collisions de noms) et ayant le fichier d'importation suivant:

child;parent 
root 
A;root 
aa;root/A 
cc;root/A/aa 
... 
B;root 
aa;root/B 
... 

si vous venez de la nom de l'enfant, puis le chemin explicite dans le parent.Ensuite, vous pouvez simplement parcourir le chemin parent à partir de la racine pour trouver le nœud parent.