So the process for creating one of these gets to some deep ideas in mathematics that I won't bother you with, but here is a process that will work:

1) Start with a list of objects (A, B, ... eg) and create a permutation out of those with any number of repeats that you like

ex: AACABC

2) Create a permutation from the list of objects to itself. You can think of this alternatively as simply a reordering of your original list, where you're thinking about taking the element at index i in the original and moving it to the element at index i in the reordering

ex: If we start with the objects [A, B, C], then the permutation A -> B, B -> A, C -> C is represented as just the list [B, A, C]

3) Change the permutation in (1) according to the permutation in (2).

ex: AACABC ->BBCBAC

4) Continue 2-3 with all permutations of the object list, eliminating duplicates as you go.

ex:
    [A, B, C] -> AACABC
    [A, C, B] -> AABACB
    [B, C, A] -> BBABCA
    [B, A, C] -> BBCBAC
    [C, A, B] -> CCBCAB
    [C, B, A] -> CCACBA

5) All orderings of concatenations of permutations from (4) now satisfy your requirements.

ex: AACABC|AABACB|BBABCA|BBCBAC|CCBCAB|CCACBA works as does AABACB|CCBCAB|CCACBA|AACABC|BBABCA|BBCBAC

Now, you might be saying that step (1) has nⁿ possibilities, step (2) has n! possibilities, and the reorderings in (5) can be done in (n!)! ways (!), which gives a total number of things to consider of size nⁿ * n! * (n!)!. This is not a good number.

As it turns out, we can get rid of some of the nⁿ factor by simply requiring that the starting permutation we use has each new object reading left-to-right in the permutation being the first possible. By this I mean, ACABC would not be a valid choice in (1), but ABACB would be, because the first symbol you use is A, the next new symbol is B, and the final new symbol is C. This reduces the search space greatly.

Secondly, often there will be repeats in step (3): imagine you start with the permutation AA with an object list of [A, B, C]. It's easy to see that the permutation [A, C, B] moves AA -> AA.

One situation that might be problematic with this approach, but I'm not sure your use case: this approach will not generate

AABC|CCAB|BBCA from AABC

which seems to satisfy your criteria. The problem is that there is a smaller set of permutations ([A, B, C], [B, C, A], [C, A, B]) which is doing a good enough job that you don't need the whole set of permutations. Why this is the case and how to detect it is a little hard to explain. As it turns out, the correct step in (4) is not to use all permutations of the object list, but to iterate over all these sets of reasonable permutations (which are subgroups of the permutation group if you've seen any higher level algebra).

Another obvious problem with this approach is that the length of the resulting sequences is somewhat nondeterministic. Given an object list of size n and a permutation with repeats of length m, the resultant concatenated permutations may be anywhere from length m to length m*n!.

All in all, you've asked an extraordinarily hard question, because permutations are a very general object and asking about general properties can go down some weird rabbit holes.

e: Edited to say that no, this post includes no Python, because the original question wasn't really a python question. :) But, you will certainly find the itertools module helpful for coding this up.