create a class instance in python where its base class is specified dynamically by a parameter

This thing would be cleaner if you could just use multiple inheritance, and your configuring parameters as Mixin classes -to the point no special metaclass or action at class creation time would be needed.

And, of course, if one won't need neither an issubclass check nor to have subclasses of DynamicDerive, a factory function, that would take in the bases, keep a registry as a cache, and just instantiate the new object would also not require any special code.

But, if you need the parametric bases to be higher up in the MRO than "DerivedClass", as you are asking for, then, the way to customize the instance class at class-instantiation time, is to override the __call__ method of the metaclass. (This is what Python run, type.__call__, that will ultimately call the class' __new__ and __init__ methods).

This thing worked here for what I tried - see if it suits you:

import threading

class M(type):
    registry = {} 
    recursing = threading.local()
    recursing.check = False
    mlock = threading.Lock()

    def __call__(cls, *args, **kw):
        mcls = cls.__class__
        if mcls.recursing.check:
            return super().__call__(*args, **kw)
        spec = args[0]
        base = spec.kls


        if (cls, base) not in mcls.registry:
            mcls.registry[cls, base] = type(
                cls.__name__,
                (cls, base) + cls.__bases__[1:],
                {}
            )
        real_cls = mcls.registry[cls, base]

        with mcls.mlock:
            mcls.recursing.check = True
            instance = real_cls.__class__.__call__(real_cls, *args, **kw)
            mcls.recursing.check = False
        return instance 

I imported this, and run this snippet in a Python session:

In [54]: class DynamicDerive(metaclass=M): 
...:     def __init__(self, spec): 
...:         super().__init__(spec) 
...:          
...:  
...: class Base1: 
...:    def __init__(self, uniform_params): 
...:        print("at base 1") 
...:  
...: class Base2: 
...:    def __init__(self, uniform_params): 
...:        print("at base 2") 
...:  
...:  
...: SomeSpec = type("SomeSpec", (), {}) 
...:  
...: spec1 = SomeSpec() 
...: spec1.kls = Base1 
...:  
...: spec2 = SomeSpec() 
...: spec2.kls = Base2 
...:  
...: a1 = DynamicDerive(spec1) 
...: a2 = DynamicDerive(spec2) 


at base 1
at base 2

In [55]: isinstance(a1, DynamicDerive)                                                                                             
Out[55]: True

In [56]: isinstance(a2, DynamicDerive)                                                                                             
Out[56]: True

In [57]: class D2(DynamicDerive): pass                                                                                             

In [58]: b1 = D2(spec1)                                                                                                            
at base 1

In [59]: b1.__class__.__mro__                                                                                                      
Out[59]: (__main__.D2, __main__.D2, __main__.DynamicDerive, __main__.Base1, object)

One thing you might be able to do is to make either a method or a static class that creates the necessary class dynamically and returns an instance of it:

def DynamicDerive(dynamicspec, uniform_params):
    superclass = dynamicspec.kls
    class DynamicDerive(superclass):
        def __init__(self, uniform_params):
            print(superclass)
            superclass.__init__(self, uniform_params)
        pass
    return DynamicDerive(uniform_params)

This works because the interior code of a function isn't evaluated until it's called, so you can determine the base class of DynamicDerive dynamically, and then do whatever modifications you need to its definition. The downside of this is it's significantly slower, as you have to actually go through the trouble of redefining the class every time. But here's an example of this in action:

>>> x = DynamicDerive(spec1, None)
<class '__main__.Base1'>
>>> y = DynamicDerive(spec2, None)
<class '__main__.Base2'>
>>> z = DynamicDerive(spec1, None)
<class '__main__.Base1'>
>>> x.__class__ == y.__class__
False
>>> x.__class__ == z.__class__
False
>>> str(x.__class__) == str(y.__class__)
True
>>> x.__class__
<class '__main__.DynamicDerive.<locals>.DynamicDerive'>

If you wanted to be really ambitious you could maybe change the __class__ variable in the new class's __init__ (after all, you have the superclass right there if you want it).

Before implementing this properly, you'll want to think very carefully about exactly what use cases it's supposed to cover, and whether you can do that in a less hacky - and more explicit - way. Having a bunch of classes that look identical but are not is very confusing to maintain, and could lead to very easy-to-make coding errors.

It would probably be better practice to define separate classes in every individual case where they're necessary, and tailor them to the appropriate use case. Python is duck typed (if it looks like a duck and quacks like a duck, then we may as well assume it's a duck), so anything besides the code that's instantiating a class shouldn't actually care about its type, only about what it can do.