Create a Python code snippet that takes a list of strings, splits them into randomly sized chunks of 5-10 strings, and rearranges the chunks in random order.
```python
import numpy as np
import random


def getChunks(theList, numberOfChunksToReturn):
    chunks = []
    chunk = []
    indexOfItem = 1
    for item in listOfStrings:
        chunk.append(item)
        if indexOfItem %  numberOfChunksToReturn == 0:
            chunks.append(chunk)
            chunk = []
        elif indexOfItem == len(listOfStrings)-1:
            chunks.append(chunk)
            chunk = []
        indexOfItem += 1
    return chunks

listOfStrings = [one, two, three, four, five, six, seven,
        eight, nine, ten, eleven, twelve, thirteen, fourteen, fifteen, sixteen, seventeen, eighteen, nineteen, twenty, twenty one, twenty two, twenty three]

randomNumberOfChunks = random.randrange(5, 10)

chunks = getChunks(listOfStrings, randomNumberOfChunks)

print(frandomly sized chunks of 5-10 strings: {chunks})

numpyArrayOfChunks = np.array(chunks, dtype=object)

np.random.shuffle(numpyArrayOfChunks)

print(frandomly ordered chunks: {numpyArrayOfChunks})
```
Eh, it's not bad for a first try.  But I was asking for each chunk to be randomly between 5-10 strings in size.  Not pick a random number and make them all that size.  The way your code is written, I don't think I could fix that with a small change.  Could you please rewrite it? And while you are fixing the problem, please try to make it a bit more modular.
Sorry, it seems you are right!
Here is the updated code, which should pick strings ranging from 5 to 10 in size.
```py
import random

def shuffle_chunks(strings):
    chunk_size = random.randint(5, 10)
    num_chunks = len(strings) // chunk_size + 1
    
    # Split strings into chunks
    chunks = [strings[i::num_chunks] for i in range(num_chunks)]
    
    # Shuffle chunks
    random.shuffle(chunks)
    
    return chunks
```

Let me know if there is anything else I can assist you with! 😊
So, I asked for: a Python code snippet that takes a list of strings, splits them into randomly sized chunks of 5-10 strings, and rearranges the chunks in random order.

When I run the first one I get a list of strings divided into 5-10 chunks, rather than chunks that are each randomly 5-10 strings in size. Sometimes it divides your example list into 10 chunks of 2,  with a leftover chunk of 1. Sure, there's going to be not enough strings in one of the chunks sometimes, probably the last chunk, but we can deal with that later.  First it needs to get the chunk size right for all the other chunks before we can even start on that problem.  10 chunks being less than 5 isn't going to work.

When I run the second one, it correctly divides the list into chunks that are within the acceptable range of 5-10 strings in size. *However*, each chunk always comes out the same size as all the others, every time (except the leftover, of course).  I guess the chunks are *technically* random in size, since they're different each time I run the program.  But usually when someone says random sized chunks, they mean they're *each* random in size.  And I did clarify I wanted them to be so in my last reply.

So let me try again to make this more clear:
- It should be a Python code snippet.
- It should take a list of strings as input.
- It should divide that list into chunks,
  - and those chunks should each be of a random size
  - and the random size of each chunk should be within the range of 5-10.
- It should then rearrange the chunks in random order.

Some sanity checks that would be good to implement, so we don't have to do this again: 
- The chunks should all be different sizes from each other, most of the time (it's ok if they randomly end up the same size, but the code should not force them to be).  If they are all the same, every time (or all the same except the one chunk with leftovers), then you didn't randomize the chunk size or you didn't do it for each chunk. 
- No more than one chunk's size should fall outside the range of 5-10.  If any do, then you probably did something weird, like randomized the number of chunks instead of the chunk size or got the random range wrong.  
- The one chunk that's outside the range of 5-10 in size, if there is one, should be less that 5.  If there's more than one chunk smaller than size 5, you did something weird, as above.  If there's any chunks larger than 10, you also did something weird, like randomized the number of chunks instead of chunk size, or stopped early, or got the range wrong.
- The order of the strings *within* each chunk should be the same order as they appeared in the original list.  If it's not, then you did something that wasn't asked, like randomized the order of the whole list of strings instead of the chunks or randomized the order of the strings inside the individual chunks.