[Python] Python Protocols and Instantiated Theories: Exploring unusual possibilities

After answering this question, I was experimenting with a somewhat unconventional approach using Python protocols to enforce type constraints within what I'm calling "instantiated theories." The idea is to define a protocol that describes the required interface for a set of objects, and then use this protocol to validate objects created as part of a specific, runtime-defined "theory" or context.

My goal is to understand the specific behavior and limitations of Python's protocol system in this context.

For example:

from typing import Protocol, runtime_checkable
import uuid

@runtime_checkable
class TheoryObject(Protocol):
id: uuid.UUID
def validate(self) -> bool: ...

class ConcreteObject:
def __init__(self, id: uuid.UUID):
self.id = id

def validate(self) -> bool:
return True

class Theory:
def __init__(self):
self.objects = []

def create_object(self) -> TheoryObject:
new_object = ConcreteObject(uuid.uuid4())
assert isinstance(new_object, TheoryObject) # This always returns true
self.objects.append(new_object)
return new_object

theory = Theory()
obj = theory.create_object()
print(isinstance(obj, TheoryObject)) # Prints True


In this scenario, the isinstance check and the assert passes as expected. However, is it possible to leverage protocol checks more thoroughly within the Theory class, specifically to ensure that all objects added to self.objects conform to the TheoryObject protocol not just at the point of object creation but during the whole lifecycle? I'm particularly interested in scenarios where objects might be modified after creation in ways that could violate the protocol (e.g., deleting a required attribute).

See my solution in the answers. Please provide alternative approaches if you want to add your own solutions.

Continue reading...