Mirroring disk structures in nested dictionaries

[Curbie]

deanhystad,

Thank you, finally got to code that works.

from pprint import pprint def get_all_values(obj, level=0): # Not my function """Walk through a dictionary of dicts and lists.""" if type(obj) is dict: for key, value in obj.items(): if type(value) in [dict, list]: print(' ' * level, key, sep='') level = level + 1 get_all_values(value, level) level = level - 1 else: print(' ' * (level), key, ': ', value, sep='') elif type(obj) is list: for i, element in enumerate(obj): if type(element) in [dict, list]: print(' ' * level, i, sep='') level = level + 1 get_all_values(element, level) level = level - 1 else: print(' ' * (level), element, sep='') else: raise ValueError def add(old, new): # function by deanhystad - curbie comment """Add new dictionary to old.""" while True: key, value = next(iter(new.items())) if key in old: old = old[key] else: old[key] = value break new = value dskn = 0 # alpha micro up to 32mb disk number (16 bit logical disk) ufd = ['1,2', '1,2', '1,4', '1,4'] # list for user file directories file = ['BADBLK.SYS', 'AMOSL.DIR', 'AMOSL.INI', 'AMOS32.INI'] # file name blocks = [3, 42, 2, 4] # list for number of full blocks in file active = [500, 400, 300, 200] # list for number of bytes in last block of file link = [1600, 1500, 1400, 1300] # list for link to first block of file dsk = {} # create blank dictionary for i in range(0, 4): # loop through adding files uuu = ufd[i] fff = file[i] bbb = blocks[i] aaa = active[i] lll = link[i] add(dsk, {dskn: {uuu: {fff: {"blocks": bbb, "active": aaa, "link": lll}}}}) get_all_values(dsk)

But before writing this, make sure you need it. I would start this project by writing the code that loops through the entire disk (the part you are putting off). That code may reveal disks, dictionaries and files in an order that naturally lends itself to making a nested dictionary without much effort.

Done before I started this thread.

[1,2]	Link: 127	PW: | | [1,3]	Link: 1081	PW: | | [1,4]	Link: 2157	PW: | | plus 29 more UFDs ********************************************************* AAA .BAK Blocks: 1 Active: 2 Link: 2156 ABC .LIT Blocks: 19 Active: 60 Link: 2158 ABCLON.LIT Blocks: 29 Active: 373 Link: 2177 ABMAST.LIT Blocks: 17 Active: 370 Link: 2206 ABMON .CMD Blocks: 1 Active: 54 Link: 2223 ABREAD.LIT Blocks: 4 Active: 254 Link: 2224 ABRELI.EXP Blocks: 1 Active: 30 Link: 2228 ABRELI.LIT Blocks: 21 Active: 454 Link: 2229 ABRELI.OVR Blocks: 10 Active: 416 Link: 2250 ABRELI.RKT Blocks: 4 Active: 299 Link: 2260 ABRELI.RTB Blocks: 4 Active: 228 Link: 2264 ABRELI.SYS Blocks: 16 Active: 122 Link: 2268 ABRND .LIT Blocks: 5 Active: 20 Link: 2284 plus 1400 more full file specs distributed among the UFDs

Now on to studying your 'add' function to try to figure out where I goofed up.

[deanhystad]

Why do you do this:

for i in range(0, 4): # loop through adding files uuu = ufd[i] fff = file[i] bbb = blocks[i] aaa = active[i] lll = link[i] add(dsk, {dskn: {uuu: {fff: {"blocks": bbb, "active": aaa, "link": lll}}}})

instead of this:

for i in range(0, 4): # loop through adding files add(dsk, {dskn: {ufd[i]: {file[i]: {"blocks": blocks[i], "active": active[i], "link": link[i]}}}})

[Curbie]

Because, I find it easier to read and debug while learning a new language, when everything works as intended, I can compress for speed and fewer lines.

[Curbie]

Over the last 50 years I’ve learned maybe a dozen programming languages, but python nested dictionaries is the first programming language concept that has frustrated me, the concept is simple enough, but working with them is frustrating, deanhystad posted an “add” function which functioned perfectly for everything but my understanding of working with them.

Now, I need to push the program I used deanhystad’s “add” function for, and start to chart the porting of my Alpha Micro disassembler to python because of the speed advantages of modern computers over a 8mhz 68000. Which brings me back to properly understanding nested dictionaries.

I went back to scratch just two dictionaries one for the logical disk name (‘dsk0’), and the second for the directories on that logical disk (‘dsk0’: {‘1,2’: 1}). The is typically about 25 directories on a logical disk, but could be many more.

Currently I’m building the nested directories by first starting one logical disk, then adding all directories on that logical disk, then all file names and their attributes for the first directory, before repeating for the next directories. Lastly, checking for another logical disk and repeating if found, halting if not.

Don’t know where I’m goofing up, my screwed up brain throws fits and kills my focus any time I try to code something with code I can’t visualize in my head.
[/python]

fs = {'dsk0': {}} # device name paired with empty dictionary fs['dsk0'] = {'1,2': {}} # add 1,2 fs['dsk0'] = {'1,4': {}} # add 1,4 fs['dsk0'] = {'1,6': {}} # add 1,6 print(fs) # print file system dictionaries

Output:
{'dsk0': {'1,6': {}}}

It seems apparent that my attempt to add an element is just changing the same element.

How do I add a (directory) dictionary nested a to logical disk directory?

[deanhystad]

You keep changing the value for fs['dsk0']

Do this instead

fs = {"dsk0": {}} # device name paired with empty dictionary fs["dsk0"]["1,2"] = {} fs["dsk0"]["1,4"] = {} fs["dsk0"]["1,6"] = {} print(fs)

Output:
{'dsk0': {'1,2': {}, '1,4': {}, '1,6': {}}}

[Curbie]

Thanks deanhystad,

Your output pointed me to my issue, now everything works correctly on two nested dictionaries, after I play with this some more, I should be able to nest two more dictionaries for files and file attributes. After a little more tweaking, I was able to load the nested dictionary from variables:

dnam = 'dsk0' # variable for storage device name (dsk0 only) ufd = ['1,2', '1,4', '1,6'] # list for user file directories (for dsk0 only) fs = {'dsk0': {}} # device name paired with empty dictionary for x in ufd: # loop through directories fs[dnam][x] = {} # add directory to dsk0 logical disk 'dsk0' print(fs) # print directory progression print(fs) # print finished file system dictionaries

The finial output seems the same as yours:

Output:
{'dsk0': {'1,2': {}}} {'dsk0': {'1,2': {}, '1,4': {}}} {'dsk0': {'1,2': {}, '1,4': {}, '1,6': {}}} {'dsk0': {'1,2': {}, '1,4': {}, '1,6': {}}}

[deanhystad]

This may interest you. In particular the __setitem__ part that builds a directory structure while adding files.

class File: """Represents a file in a file system.""" def __init__(self, content, name='', folder=None): self.content = content self.name = name self.folder = None if folder: folder.add(self) def move(self, folder, name=None): """Move to new location.""" if self.folder: self.folder.remove(self) if name: self.name = name folder.add(self, self.name) def path(self): """Return path as list of folders.""" path = [self] folder = self.folder while folder: path.insert(0, folder) folder = folder.folder return path def path_str(self): """Return path as str.""" return '/'.join(map(str, self.path())) def __str__(self): """Return pretty str.""" return self.name def __repr__(self): """Return descriptive str.""" return f"<{self.__class__.__name__} {self.name} in {self.folder}>" def __lt__(self, other): """For sorting.""" return str(self) < str(other) class Folder(File): """A special file who's content is a list of files and folders.""" def __init__(self, name='', folder=None): super().__init__({}, name, folder) def add(self, file, name=None): """Add file to folder.""" if file.folder: file.folder.remove(file) if name is not None: file.name = name file.folder = self self.content[file.name] = file def remove(self, file): """Remove file from folder.""" if file.name in self.content: self.content.pop(file.name) file.folder = None def __getitem__(self, path): """Get file/folder using relative path.""" def get(folder, part): """Return folder[part].""" if part == '..': return folder.folder return folder.content[part] file = self for part in path.split('/'): file = get(file, part) return file def __setitem__(self, path, file): """Add file to folder using relative path. Builds path if required.""" def get(folder, part): """Return folder[part]. Create folder if not found.""" if part == '..': return folder.folder elif part in folder.content: return folder.content[part] return Folder(part, folder) folder = self parts = path.split('/') for part in parts[:-1]: folder = get(folder, part) folder.add(file, parts[-1]) def __iter__(self): """Iterate through file names.""" return iter(self.content) def walk(self): """Walk through the folder and subfolder returning files.""" for file in self.content.values(): if isinstance(file, Folder): for subfile in file.walk(): yield subfile else: yield file root = Folder("") root["A/B/C/file1"] = File(1) root["A/B/file2"] = File(2) root["A/B/file3"] = File(3) root["D/file4"] = File(4) a = root["A"] b = a["B"] c = b["C"] d = root["D"] print("root:", *root.content) print("/A:", *a.content) print("/A/B:", *b.content) print("/A/B/C:", *c.content) print("/D:", *d.content) print("/D[../A/B/file3]:", d["../A/B/file3"]) for file in root.walk(): print(file.path_str(), "content =", file.content)

Output:
root: A D /A: B /A/B: C file2 file3 /A/B/C: file1 /D: file4 /D[../A/B/file3]: file3 /A/B/C/file1 content = 1 /A/B/file2 content = 2 /A/B/file3 content = 3 /D/file4 content = 4