Extending bp's answer, I wanted to show you what he meant by immutable types.

First, this is okay:

>>> class TestB():
...     def __init__(self, attr=1):
...         self.attr = attr
...     
>>> a = TestB()
>>> b = TestB()
>>> a.attr = 2
>>> a.attr
2
>>> b.attr
1

However, this only works for immutable (unchangable) types. If the default value was mutable (meaning it can be replaced), this would happen instead:

>>> class Test():
...     def __init__(self, attr=[]):
...         self.attr = attr
...     
>>> a = Test()
>>> b = Test()
>>> a.attr.append(1)
>>> a.attr
[1]
>>> b.attr
[1]
>>> 

Note that both a and b have a shared attribute. This is often unwanted.

This is the Pythonic way of defining default values for instance variables, when the type is mutable:

>>> class TestC():
...     def __init__(self, attr=None):
...         if attr is None:
...             attr = []
...         self.attr = attr
...     
>>> a = TestC()
>>> b = TestC()
>>> a.attr.append(1)
>>> a.attr
[1]
>>> b.attr
[]

The reason my first snippet of code works is because, with immutable types, Python creates a new instance of it whenever you want one. If you needed to add 1 to 1, Python makes a new 2 for you, because the old 1 cannot be changed. The reason is mostly for hashing, I believe.

Don't use class attributes for that, that's not what they are there for. Use default arguments:

def __init__(self, name='Undefined', number=-1):
    self.name = name
    self.number = number

If any of the arguments are mutable, then you need to use the usual idiom:

def __init__(self, foo=None):
    self.foo = [] if foo is None else foo

There is a whole bunch of ways to solve this problem, but if you have python 3.7 installed (or have 3.6 and install the backport), dataclasses might be a good fit for a nice solution.

First of all, it lets you define the default values in a readable and compact manner, and also allows all the mutation operations you need:

>>> from dataclasses import dataclass
>>> @dataclass
... class Plots:
...     a: int = 1
...     b: int = 2
...     c: int = 3
...     
>>> p = Plots()        # create a Plot with only default values
>>> p
Plots(a=1, b=2, c=3)
>>> p.a = -1           # update something in this Plot instance
>>> p
Plots(a=-1, b=2, c=3)

You also get the option to define default factories instead of default values for free with the dataclass field definition. It might not be a problem yet, but it avoids the mutable default value gotcha, which every python programmer runs into sooner or later.

Last but not least, writing a reset function is quite easy given an existing dataclass, because it keeps track of all the default values already in its __dataclass_fields__ attribute:

>>> from dataclasses import dataclass, MISSING
>>> @dataclass
... class Plots:
...     a: int = 1
...     b: int = 2
...     c: int = 3
... 
...     def reset(self):
...         for name, field in self.__dataclass_fields__.items():
...             if field.default != MISSING:
...                 setattr(self, name, field.default)
...             else:
...                 setattr(self, name, field.default_factory())
...
>>> p = Plots(a=-1)     # create a Plot with some non-default values  
>>> p
Plots(a=-1, b=2, c=3)
>>> p.reset()           # calling reset on it restores the pre-defined defaults
>>> p
Plots(a=1, b=2, c=3)

So now you can write some function do_stuff(...) that updates the fields in a Plot instance, and as long as you execute reset() the changes won't persist.

This code might not mean what you want it to mean:

class RateResponse(BaseModel):

    def __init__(self, 
        provider=Provider()
    ):
        ...

This code is saying that when this class is declared you want to make an instance of Provider which will be the default value for the provider parameter.

You may have meant that the default argument should be a new instance of Provider for each client that makes an instance of RateResponse.

You can use the Mutable Default Argument pattern to get the latter:

class RateResponse(BaseModel):

    def __init__(self, provider=None):
        if provider is None:
            provider = Provider()
        ...

However, if you really do want a single instance when the client wants the default you could add a single instance below the Provider definition:

class Provider(ObjectListModel):
    ...
Singleton_Provider = Provider()

Then the RateResponse class could still use the current pattern, but instead perform this assignment inside the if:

        if provider is None:
            provider = Singleton_Provider

At the time that the assignment is performed, the Singleton_Provider will have been created.

Your understanding is wrong. self is itself a parameter to that function definition, so there's no way it can be in scope at that point. It's only in scope within the function itself.

The answer is simply to default the argument to None, and then check for that inside the method:

def doSomething(self, a=None):
    if a is None:
        a = self.z
    self.z = 3
    self.b = a

Some minor comments on the code:

1. Class definition should be separated from the line with import by two spaces.

2. My personal preference is to have key-value pairs in dictionaries separated with a space after colon as shown in PEP 8:

   defaults = {'A': None, 'B': 0, 'C': 0}
   

3. Comparing to None should be done by is instead of ==:

   required = [key for key, value in defaults.items() if value is None]
   

   Note that I also removed redundant brackets around key, value. There are several other lines where brackets are not needed around them.

4. PEP 8 also discourages aligning several lines with assignments by =, so instead of, for example:

   results        = None
   keys, values   = zip(*setup.items())
   

   it should be

   results = None
   keys, values = zip(*setup.items())
   

5. There is no need to specify object in class O(object), class O will work fine.

6. Here:

   for key, value in kwargs.items():
       if key in setup:
           setup[key] = kwargs[key]  # user specified overrides default
   

   you don't use value, but you could:

   for key, value in kwargs.items():
       if key in setup:
           setup[key] = value
   

7. Here:

   keys, values = zip(*setup.items())

   you don't need values as you overwrite them later. So, I'd just remove this line altogether.

8. set((1,)) can be replaced with {1}, and set.difference can be replaced with just -. BTW, I like how you combined two conditions from my previous review in one!

9. Don't forget to use np.can_cast instead of checking the dtypes against np.int64. The current version failed for me until I changed it.

10. [array.astype(float) for array in arrays] can be written as list(map(np.float64, arrays)) but both versions are fine.

11. The overall design looks quite unusual to me. If it would be me, I'd separate validating data from the container that will keep it. In other words, I'd not keep it in one class. BTW, if a class has just two methods and one of them is __init__ then it shouldn't be a class. Another thing you could try is pydantic library. Never had a chance to try it myself though, but with this problem of data validation I'd give it a shot.