In addition to needing to inherit from object, properties only work on instances.

a = A()
a.db.doSomething("blah")

To make a property work on the class, you can define a metaclass. (A class is an instance of a metaclass, so properties defined on the metaclass work on the class, just as properties defined on a class work on an instance of that class.)

Your indentation is goofed, and you've mixed tabs and spaces. Run the script with python -tt to verify.

You have extra underscores in your constructor, so it is not being called. Use two on either side: __init__.

You are not creating an instance, but instead referencing the class Goblin itself as indicated by the error:

AttributeError: type object 'Goblin' has no attribute 'color'

Change your line to Azog = Goblin()

I know it's a bit too late but I was facing the same AttributeError as yours. Removing double underscore from the beggining of the function I wanted to test helped me.

When using Depends(), you just pass the name of the dependency function within the brackets (i.e., don't call it directly, just pass it as a parameter to Depends()). As described in the documentation:

Let's first focus on the dependency.

It is just a function that can take all the same parameters that a path operation function can take.

And it has the same shape and structure that all your path operation functions have.

You can think of it as a path operation function without the "decorator" (without the @app.get("/some-path")).

And it can return anything you want.

Thus, any other parameters that your dependency function takes, you simply need to declare them in that function and not passing them through Depends(). Same applies to the Request object. FastAPI will analyze the parameters for the dependency, and process them in the same way as the parameters for a path operation function (also known as endpoint), including sub-dependencies.

Hence, your endpoint should look like this:

@app.get("/")
async def home(user: Annotated[User, Depends(authenticate_request)]):
    pass

and your authenticate_request dependency function should be as follows:

def authenticate_request(request: Request) -> User:
    pass

Additional Information 1

Instead of a "callable" function, one could also use a Python class instead as a dependency, as Python classes are also callable.

One not only can they use a "callable" dependency class, but also a "callable" instance of that dependency class, which would allow them to initially pass fixed content when creating the instance of the class, as well as pass additional parameters and sub-dependencies when the endpoint is called.

The __init__ method in the example below is used to declare the parameters of the instance that we can use to "parameterize" the dependency (the fixed content). FastAPI won't ever touch or care about __init__, it is used directly in the code when creating the instance of the class.

The __call__ method, on the other hand, is what FastAPI will use to check for additional parameters and sub-dependencies, and this is what will be called to pass a value to the parameter in your endpoint, when it will later be called.

Hence, in the example below, fixed_content is the attribute used to "parameterize" the dependency, while q is the additional query parameter to pass a value for, when a client is calling the endpoint.

Example

class FixedContentQueryChecker:
    def __init__(self, fixed_content: str):
        self.fixed_content = fixed_content

    def __call__(self, q: str = ""):
        if q:
            return self.fixed_content in q
        return False


checker = FixedContentQueryChecker("bar")


@app.get("/query-checker/")
async def read_query_check(fixed_content_included: bool = Depends(checker)):
    return {"fixed_content_in_query": fixed_content_included}

A context manager in dependencies could be used as well.

Additional Information 2

One should also be aware that, as described here:

You can't use Depends in your own functions, it has to be in FastAPI functions, mainly routes. You can, however, use Depends in your own functions when that function is also a dependency, so could can have a chain of functions.

For example, a route uses Depends to resolve a get_current_user, which also uses Depends to resolve get_db, and the whole chain will be resolved. But, if you then call get_current_user without using Depends, it won't be able to resolve get_db.

What I do is get the DB session from the route and then pass it down through every layer and function. I believe this is also better design.

Hence, FastAPI does not resolve Depends at random locations in the code, but only as part of an existing Depends hierarchy from the endpoint/route function or other Dependencies.

@cached_property is designed for immutable values. You cannot expect that this decorator will mimic all features from standard property. In python doc you can find: "The mechanics of cached_property() are somewhat different from property(). A regular property blocks attribute writes unless a setter is defined. In contrast, a cached_property allows writes."

Change the method like this:

def get_deductible_total(self):
    return (self.amount - self.reward.not_taxable) 

BTW usually there's really no point in separating properties and methods, you can do calculations inside the properties as well. You could just have

@property
def deductible_total(self):
    return (self.amount - self.not_taxable) 

But some reasons to have them separated:
1) Properties do not raise errors, so if you call it somewhere else where you need the exceptions, then it makes sense to separate them.
2) If for some reason you need a method (or a function, basically a callable) that returns the result, then you also need to separate them. Probably not the case and can be combatted using lambdas.
Just FYI.

Take a very close look at the error message: what does it say? It is telling you precisely what the problem is. It's even telling you the line number.

AttributeError: 'NoneType' object has no attribute 'get'

Notice where it says 'NoneType'? That means that some variable is None even though you think it is something else. And obviously, None doesn't have a method named get. So, you have to ask yourself, why it is None?

You don't show it in your question, but it's likely that the error is happening on the ae variable (and also on the be and ce variables). So the question is, why are they None?

The reason they are None is that you are setting them like this:

ae = Entry(master).grid(row=0, column=1)

In python, when you do x=a().b(), x gets the value of b(). Thus, you are setting ae to the value of the grid(...) statement, and the grid statement always returns None.

The solution is to separate your widget creation from layout, which is generally a good practice even if you don't need to save references to the GUI widgets:

ae = Entry(...)
be = Entry(...)
ce = Entry(...)
...
ae.grid(...)
be.grid(...)
ce.grid(...)

• The summary_output in DES class, will be defined in the createFrame method.
• You first instatiated from the DES class in the Set.set_summary() method and then called the set_summary_text() method, which it uses the summary_output. That's not correct, since the summary_output has not been defined, yet.
• You should first, call the createFrame() method to define the summary_output attribute and then call the set_summary_text() to use summary_output.

Do something like this, in the Set class:

class Set:
    def __init__ (self, summary):
        self.summary = summary
        
    def set_summary(self):
        global root
        print(self.summary)
        s = DES(self.summary)   
        s.createFrame(root)                     
        s.set_summary_text()

Or do whatever you think it's best for you, but you should define the summary_output first, and then print or use it.

No, autospeccing cannot mock out attributes set in the __init__ method of the original class (or in any other method). It can only mock out static attributes, everything that can be found on the class.

Otherwise, the mock would have to create an instance of the class you tried to replace with a mock in the first place, which is not a good idea (think classes that create a lot of real resources when instantiated).

The recursive nature of an auto-specced mock is then limited to those static attributes; if foo is a class attribute, accessing Foo().foo will return an auto-specced mock for that attribute. If you have a class Spam whose eggs attribute is an object of type Ham, then the mock of Spam.eggs will be an auto-specced mock of the Ham class.

The documentation you read explicitly covers this:

A more serious problem is that it is common for instance attributes to be created in the __init__ method and not to exist on the class at all. autospec can’t know about any dynamically created attributes and restricts the api to visible attributes.

You should just set the missing attributes yourself:

@patch('foo.Foo', autospec=Foo)
def test_patched(self, mock_Foo):
    mock_Foo.return_value.foo = 'foo'
    Bar().bar()

or create a subclass of your Foo class for testing purposes that adds the attribute as a class attribute:

class TestFoo(foo.Foo):
    foo = 'foo'  # class attribute

@patch('foo.Foo', autospec=TestFoo)
def test_patched(self, mock_Foo):
    Bar().bar()