Sorting Collections Alphabetically in the Outliner

Question

I have numerous objects categories that I used to organize in Groups through a script in Blender 2.79.

I'm now trying to switch to blender 2.8 and use collections, but in the outliner the only listing order that I can get is by their creation. There is an option "sort alphabetically" but it only works for objects. In Blender 2.79 Groups were listed in alphabetical order, I don't understand why this has been changed.

Anyway, does anyone have an idea on how to circumvent this problem? Would it be possible with a script? There is no way I can switch to Blender 2.8 if I don't fix this issue! Thank you very much.

Federico

Answer 1

Once for each collection.

Just as I was about to answer this yesterday, my internet ran out, fortunately there is a bit of a point of difference.

To do this once for all collections, would add the root scene collections to bpy.data.collections and then sort the immediate children of each.

To sort all collections in blend in one fell swoop.

import bpy

collections = bpy.data.collections[:]
collections.extend(scene.collection for scene in bpy.data.scenes)
for col in collections:
    for c in sorted(col.children, key=lambda c: c.name):
        col.children.unlink(c)
        col.children.link(c)

Similarly to sort just a specific collection root, context.collection in example below

import bpy

context = bpy.context

def all_colls(c):
    def walk(col):
        yield col
        for c in col.children:
            yield from walk(c)
    return set(walk(c))

assert(context.collection) # poll cannot be None.

for col in all_colls(context.collection):
    for c in sorted(col.children, key=lambda c: c.name.lower()):
        col.children.unlink(c)
        col.children.link(c)

once again ensuring we only sort the immediate children of each collection once.

Answer 2

Fully recursive and optionally case-sensitive:

import bpy

def sort_collection(collection, case = False):

  if collection.children is None: return

  children = sorted (
    collection.children, 
    key = lambda c: c.name if case else c.name.lower()
  )

  for child in children:  
    collection.children.unlink(child)
    collection.children.link(child)
    sort_collection(child)

# case_sensitive sort, (default is False)
case_sensitive = True

for scene in bpy.data.scenes:
    sort_collection(scene.collection, case_sensitive)

Answer 3

How about something along these lines?

import bpy

scn = bpy.context.scene
cols = scn.collection.children

sorted_cols = sorted (cols, key = lambda c: c.name.lower())

for col in sorted_cols:  
    cols.unlink(col)
    cols.link(col)

There may be problems with it.. I haven't covered all the bases, and you may want to do it recursively, etc..?

Answer 4

This does not seem to be possible at all just yet. There is discussions about this issue in various places, for instance here in the bug tracker. Using Python I also have not seen a way of doing this just yet. The sorting simply relates to the time at which a collection has been linked to the scene, and cannot really be changed.

The underlying issue seems to be that at the time of writing this, the relevant Python methods to sort are not implemented for collections. In Python, you'll need to implement at least code for the hidden __lt__ (less than), __gt__ (greather than), maybe also the __eq__ (is equal to) functions. Those functions are called when you do comparisons like A > B or A == B, see this for further reference. Furthermore, for sorting, they are the base for the comparison itself. When you sort someting complex like a collection object, which has many attributes, Python needs to be told what makes one collection "bigger" or "smaller" than the other. Obviously you want the name, but Python-wise you could also aim at an index, a hash, a postal code, or whatever. That's why those methods exist, in them you tell Python based on what > or < operate.

Now when you test this in Python, you can try these three examples. I am retrieving collection lists in various places and ask Python to sort them using the sorted() function:

sorted(bpy.data.collections)

Traceback (most recent call last):
  File "<blender_console>", line 1, in <module>
  TypeError: '<' not supported between instances of 'Collection' and 'Collection'`

The error thrown indicated that the __lt__ method has no code behind.

same of course with the keys() attribute:

sorted(bpy.data.collections.values())

Traceback (most recent call last):
  File "<blender_console>", line 1, in <module>
  TypeError: '<' not supported between instances of 'Collection' and 'Collection'

We can also test this for the LayerCollection type, which is what you see in reality in the outliner:

sorted(bpy.context.view_layer.active_layer_collection.children)

Traceback (most recent call last):
  File "<blender_console>", line 1, in <module>
  TypeError: '<' not supported between instances of 'LayerCollection' and 'LayerCollection'

The error in all cases remains the same. So what I'm aiming at with the explanation here is that sorting simply isn't implemented yet, and you can't really force it to happen from the Python side. You would probably need to unlink all collections from the scene first and relink them again in a defined order to enforce a sorted result. But since Collections can have nesting and multiple parents, this can become quite tricky.