The `python-interface` library provides a Pythonic way to define and enforce interfaces. It helps in creating clear contracts for classes, ensuring that implementations adhere to a specified structure. Currently at version 1.6.1, the library has a moderate release cadence, with updates addressing bugs, adding minor features like subinterfaces, and improving internal tooling.
Install & Compatibility
Where this runs
tested against v1.6.1 · pip install
no network on importno background threads
Install × environment matrix
Each cell = how many times install + import succeeded across repeated harness runs. Partial = flaky.
glibc = Debian/Ubuntu slim · musl = Alpine Linux
muslpy 3.10–3.920 runs
installs and imports cleanly · install 0.0s · import 0.025s · 19.5MB
glibcpy 3.10–3.920 runs
installs and imports cleanly · install 2.5s · import 0.020s · 20MB
17MB installed
● package 17MB
Code
Verified usage
Verified import paths — ran on the pinned version, not inferred.
from interface import Interface
from interface import abstractmethod
from interface import implements
This quickstart demonstrates how to define an interface using `Interface` and `abstractmethod`, and how to implement it using `implements`. It also shows the error raised for incomplete implementations and highlights the subinterface feature introduced in version 1.6.0.
from interface import Interface, abstractmethod, implements
class MyInterface(Interface):
"""An example interface.
Requires a 'required_method' with specific arguments.
"""
@abstractmethod
def required_method(self, required_argument: str) -> bool:
"""This method must be implemented by any class implementing MyInterface."""
pass
class MyImplementation(implements(MyInterface)):
"""A class correctly implementing MyInterface."""
def required_method(self, required_argument: str) -> bool:
if isinstance(required_argument, str) and len(required_argument) > 0:
return True
return False
# Attempting to instantiate a class that doesn't implement all methods will raise an error
class IncompleteImplementation(implements(MyInterface)):
pass
try:
print("Attempting to instantiate IncompleteImplementation...")
IncompleteImplementation()
except TypeError as e:
print(f"Error as expected for incomplete implementation: {e}")
# Demonstrate successful implementation
impl = MyImplementation()
print(f"MyImplementation.required_method('test'): {impl.required_method('test')}")
print(f"MyImplementation.required_method(''): {impl.required_method('')}")
# New in 1.6.0: Interface Subclassing
class ExtendedInterface(MyInterface):
"""An interface extending MyInterface with an additional method."""
@abstractmethod
def another_required_method(self) -> int:
pass
class ExtendedImplementation(implements(ExtendedInterface)):
"""A class correctly implementing ExtendedInterface."""
def required_method(self, required_argument: str) -> bool:
return True
def another_required_method(self) -> int:
return 42
extended_impl = ExtendedImplementation()
print(f"ExtendedImplementation.another_required_method(): {extended_impl.another_required_method()}")
Upgrade
Version history
Breaking-change detection hasn't run for this library yet.
Audit
Security & dependencies
CVE tracking and dependency tree are planned for a later release.