Is there a way to make reshaping arrays shorter and cleaner?
You took a curved path to where you want to go :)

It seems you are ill at ease at building flat lists and take long routes at building nested ones then unpacking them. But you can replace :

    omegas_ext = []
    for element in omegas:
        item = [x for x in element if x is not None]
        omegas_ext.append(item)
# [...]
    for element in omegas_ext:
        for item in element:
            omegas_unpacked.append(item)


By:

    omegas_ext = []
    for element in omegas:
        item = [x for x in element if x is not None]
        omegas_ext.extend(item)


Second, this if else is unecessary. [value] * 1 is equivalent to [value].

        if len(omegas_ext[idx])&gt;1:
            value = delays[idx]
            item_to_add = [value]*(len(omegas_ext[idx]))
            delays_exp.append(item_to_add)
        elif len(omegas_ext[idx]) == 1:
            value = delays[idx]
            delays_exp.append([value])


Can be replaced by:

    if len(omegas_ext[idx])&gt;=1:
        delays_exp.append([delays[idx]]*(len(omegas_ext[idx])))


Again you unpack this later on. So you could extend and this would also make it unecessary to have this check for an element (since extending with an empty list is a no-op)

    delays_exp.extend([delays[idx]*len(omegas_ext[idx]))
    # itertools.chain no longer needed


Finally, you missed the fact you can build the two lists in a single for, by using zip. This would save you the need to use an index to recompute the length of the omegas_ext items.

Here would be the function :

def spp_method(omegas, delays):
    delays = delays[delays != np.array(None)]
    omegas_ext = []
    delays_exp = []
    for delay, element in zip(delays, omegas):
        item = [x for x in element if x is not None]
        omegas_ext.extend(item)
        delays_exp.extend(len(item) * [delay])
    return np.array(delays_exp), np.array(omegas_ext)


Code returns the same output.