python-access-modifiers 1.2.0

Python decorators to specify accessible scopes and enhance access control of methods.

Installation

Built and tested on Python 3.12.
No requirements other than the module itself.

pip install python-access-modifiers

Introduction

python-access-modifiers is a lightweight Python package designed to enhance access control of methods within classes and modules.

Decorators

@private - Allows you to designate methods as "private", controlling the accessibility of the method based on the calling context.
@protected - Allows for the creation of "protected" methods, allowing access from only within the class where the method is defined, or within one of it's subclasses.

Example Usage

Creating a private method inside of a class

from python_access_modifiers import private

class MyClass():
    @private
    def my_private_method(self) -> None:
        print("This is a private method")

    def my_public_method(self) -> None:
        print("This is a public method")
        self.my_private_method()

my_class = MyClass()
my_class.my_public_method()

Output

No exception is raised because my_private_method is called from within MyClass, not from outside of the accessible scope.

This is a public method
This is a private method

Calling a private method outside of the accessible scope

from python_access_modifiers import private

class MyClass():
    @private
    def my_private_method(self) -> None:
        print("This is a private method")

    def my_public_method(self) -> None:
        print("This is a public method")
        self.my_private_method()

my_class = MyClass()
my_class.my_private_method()

Output

RuntimeError: Cannot invoke private method "MyClass.my_private_method" from within the scope of "__main__"

Creating classes that inherit private methods

from python_access_modifiers import private

class Base():
    @private
    def my_private_method(self):
        print("This is a private method")

    def my_public_method(self):
        print("This is a public method")
        self.my_private_method()

class Child(Base):
    ...

child = Child()
child.my_public_method()

Output

my_private_method is called from within the Base class, therefore no exception is raised.

This is a public method
This is a private method

However, if my_private_method was called directly from outside of the accessible scope of the Base class, a RuntimeError would be raised.

child = Child()
child.my_private_method()

Output

RuntimeError: Cannot invoke private method "Base.my_private_method" from within the scope of "__main__"

Creating a private method from inside of a module

my_module.py

from python_access_modifiers import private

@private
def my_private_method():
    print("This method is private to my_module")

main.py

from my_module import my_private_method

my_private_method()

Output

RuntimeError: Cannot invoke private method "my_module.my_private_method" from module "__main__"

Creating a protected method

from python_access_modifiers import protected

class MyBaseClass():
    @protected
    def my_protected_method(self):
        print("This method is protected inside of MyBaseClass")

    def call_protected_method(self):
        self.my_protected_method()

class MySubClass(MyBaseClass):
    def call_protected_method_from_subclass(self):
        self.my_protected_method()
        
subclass = MySubClass()

subclass.call_protected_method()
subclass.call_protected_method_from_subclass()

Output

If my_protected_method is called from within MyBaseClass or from within one of it's subclasses (i.e: MySubClass), the method gets called as normal.

This method is protected inside of MyBaseClass
This method is protected inside of MyBaseClass

However, if my_protected_method is called from outside of the base class and outside of the base class's subclasses, an exception will be raised.

subclass.my_protected_method()

Output

RuntimeError: Cannot invoke protected method "MyBaseClass.my_protected_method" from within the scope of "__main__"