Private method without underscores and interfaces in Python

I am a fan of the engineering design, including class members access modifiers and interfaces, but Python does not have them from the box. I have created own ones. The reference to the library on the Github is presented at the end of the article.

Class members access modifiers

They restrict access to the object’s methods and parent class methods from the child class in case of inheritance. When you call the method under the private access modifier, you get the corresponding error message. You cannot use details of the realization (as you shouldn’t get access to your car’s engine) of the class or change its data (e.g. counting variables), you can only use public functionality.

A private method can be only called inside the particular class, a protectedmethod inside the particular class and by its child classes.

How declare private and protected methods in Python

In Python, «privacy» depends on «consenting adults» levels of agreement. A single leading underscore means you’re not supposed to get access to it from the outside. Two leading underscores carry the message even more seriously. But, in the end, it still depends on social convention and consensus.

class Car:
	

	    def _start_engine(self):
	        return "Engine's sound."
	

	    def run(self):
	        return self._start_engine()
	

	

	if __name__ == '__main__':
	    car = Car()
	

	    assert "Engine's sound." == car.run()
	    assert "Engine's sound." == car._start_engine()

The following cons are there:

Imaging method **_start_engine **modifies any class variables or save any state. If you call this method, it could break the class behavior.
If you need to call protected method anyway, you should really spend the time to research — «will I break something in my another code by accessing it?».
In most cases, you use the class methods from libraries. A class provides public functionality which relies on private methods. Private methods could be changed (refactored, divided by separated code, etc.), without changing the public functionality. Author of the library still offers the promised functionality, but what about you?
Imagine your teammate wrote the class with public and private functionality. Another teammate uses a private method outside the class. If you refactor this class, you should pay attention on the class and the code which uses its private functionality. Instead of one place you get two.
And you should track your team members do not access private and protected methods on code review. And spend time for it.

How you declare protected methods using the library

from accessify import protected
	

	

	class Car:
	

	    @protected
	    def start_engine(self):
	        return "Engine's sound."
	

	    def run(self):
	        return self.start_engine()
	

	

	if __name__ == '__main__':
	    car = Car()
	

	    assert "Engine's sound." == car.run()
	

	    car.start_engine()

When you call the method **start_engine, **you get an exception — method is inaccessible due to its protection level.

Traceback (most recent call last):
	  File "examples/access/private.py", line 24, in <module>
	    car.start_engine()
	  File "/Library/Frameworks/Python.framework/Versions/3.7/lib/python3.7/site-packages/accessify/main.py", line 92, in private_wrapper
	    class_name=instance_class.__name__, method_name=method.__name__,
	accessify.errors.InaccessibleDueToItsProtectionLevelException: Car.start_engine() is 
	  inaccessible due to its protection level

So, using the library:

You do not use ugly underscores.
Instead, you have a native Python way — decorators.
Move responsibility of checking the accessing to the methods from human to machine.

How does it work

Decorators **private **and protected are the top placed decorators. They are executed before the method is executed.

Using built-in Python library called inspect, decorator fetches the current frame—inspect.currentframe(). Current frame, as an object, has the following attributes: a namespace and a reference to the previous frame (a frame that calls current frame).

Super simple illustration

Then decorator use **inspect.currentframe().f_back **to know if the frame that called the current frame is located in the class body. Looking for attribute self in the namespace. If it is presented there, the decorator was called from the body of the class. If it isn’t presented, inaccessible due to its protection level exception is raised.

Interfaces

Interface—it is a set of the methods signatures (name, incoming arguments). Interfaces could be implemented by classes. If a class implements an interface, a class is required to implement its methods signatures completely. It allows to declaring high-level requirements for application without a detailed description of the implementation. Below the interface of human is presented—human eats food and goes somewhere.

class HumanInterface:
	

	    @staticmethod
	    def eat(food, *args, allergy=None, **kwargs):
	        pass
	        
	    def walk(self, destination):
	        pass

How you declare interfaces using the library

Methods

If a class implements an interface, a class is required to implement allinterface’s** methods**. In the example below, interface «HumanInterface» contains the method «eat», class «Human» implements the interface, but does not implement the method «eat».

from accessify import implements
	

	

	class HumanInterface:
	

	    @staticmethod
	    def eat(food, *args, allergy=None, **kwargs):
	        pass
	

	

	if __name__ == '__main__':
	

	    @implements(HumanInterface)
	    class Human:
	

	        pass