Try these two classes, both having a cry method, one as a classmethod and another as a staticmethod with self passed on

class Cat:

    def __init__(self):
        self.sound = "meow"

    def cry(self):
        print(self.sound)

x = Cat()
x.cry()
meow

and with another class

class Dog:
    def __init__(self):
        self.sound = "ruff-ruff"

    @staticmethod
    def cry(self):
        print(self.sound)

x = Dog()
x.cry()
TypeError: cry() missing 1 required positional argument: 'self'

and we can see the @staticmethod decorator basically removed the passed in self

Python classes are created at runtime, after evaluating the contents of the class declaration. The class is evaluated by assigned all declared variables and functions to a special dictionary and using that dictionary to call type.__new__ (see customizing class creation).

So,

class A(B):
    c = 1

is equivalent to:

A = type.__new__("A", (B,), {"c": 1})

When you annotate a method with @staticmethod, there is some special magic that happens AFTER the class is created with type.__new__. Inside class declaration scope, the @staticmethod function is just an instance of a staticmethod object, which you can't call. The decorator probably should just be declared above the class definition in the same module OR in a separate "decorate" module (depends on how many decorators you have). In general decorators should be declared outside of a class. One notable exception is the property class (see properties). In your case having the decorator inside a class declaration might make sense if you had something like a color class:

class Color(object):

    def ___init__(self, color):
        self.color = color

     def ensure_same_color(f):
         ...

black = Color("black")

class TFord(object):
    def __init__(self, color):
        self.color = color

    @black.ensure_same_color
    def get():
        return 'Here is your shiny new T-Ford'

Python's static methods are intended for methods that are part of a class, and can be called as either a class method or an instance method: both Class.the_method() and self.the_method() would work. When the static method is called, it is not given an implicit first argument:

class Example:
  def instance_method_example(self, arguments):
    ...

  @classmethod
  def class_method_example(cls, arguments):
    ...

  @staticmethod
  def static_method_example(arguments):
    ...

If you merely want to create a helper function that is used within your class, do not use @staticmethod. Define a free function outside of the class. For example:

class Example:
  def some_method(self, argument):
    return _helper(argument, self.x)

def _helper(a, b):
  ...

The background of static methods in Python is the following: when you access an attribute of an object x.attribute or getattr(x, 'attribute'), then this name is looked up in the instance dict or the class dict. If an object is found in the class dict, it is checked whether that object is a “descriptor”: an object that describes how this attribute behaves, not an object that would be directly returned. Descriptors have dunder-methods like __get__, __set__, and __del__ that are invoked depending on whether the descriptor is accessed, assigned to, or deleted with the del operator.

Functions – the things you declare with def – are descriptors. By default, the __get__ descriptor binds the function to the instance argument (typically called self) and returns the bound function, so that it can be invoked as a method. But the various decorators change this behaviour:

• a @classmethod def binds to the class object, not the instance
• a @staticmethod def does not bind to any object and just returns the underlying function directly
• a @property invokes the underlying function to retrieve a value

These differences are (partially) visible when looking at the repr() of the bound methods. With the first Example class:

• instance_method_example
  • with class: Example.instance_method_example
    is <function Example.instance_method_example at 0x7f1dfdd6fd30>,
    the unbound function
  • with instance: <function Example.instance_method_example at 0x7f1dfdd6fd30>
    is <bound method Example.instance_method_example of <__main__.Example object at 0x7f1dfdddcb80>>,
    a method bound to the instance
• class_method_example
  • with class: Example.class_method_example
    is <bound method Example.class_method_example of <class '__main__.Example'>>,
    a method bound to the class
  • with instance: Example().class_method_example
    is <bound method Example.class_method_example of <class '__main__.Example'>>,
    also a method bound to the class
• static_method_example
  • with class: Example.static_method_example
    is <function Example.static_method_example at 0x7f1dfdd6fe50>,
    the unbound function
  • with instance: Example().static_method_example
    is <function Example.static_method_example at 0x7f1dfdd6fe50>,
    also the unbound function

As a table: