¿Qué distingue a `__getattribute__` de **Python** de `__getattr__` durante la resolución de atributos, y qué patrón de delegación es obligatorio para evitar la recursión infinita al implementar el primero?

Respuesta a la pregunta

Historia de la pregunta

En el modelo de datos de Python, el acceso a atributos sigue un protocolo estricto donde __getattribute__ se define en la clase base object y sirve como el principal interceptor para cada búsqueda de atributos. Este método se invoca incondicionalmente para todos los accesos a atributos, existentes o no, convirtiéndose en la primera línea de defensa en la cadena de resolución. En contraste, __getattr__ es un gancho opcional que el intérprete llama solo cuando la búsqueda normal a través del diccionario de la instancia y la jerarquía de clases no logra localizar el nombre solicitado.

El problema

Cuando una subclase anula __getattribute__ para personalizar el comportamiento, como el registro o el control de acceso, cualquier acceso directo a atributos dentro del cuerpo del método—como self.attr o self.__dict__—dispara el mismo método anulado de forma recursiva. Esto crea un bucle infinito porque el mecanismo de búsqueda ha sido secuestrado sin un caso base para detener la recursión, agotando eventualmente la pila de llamadas y generando un RecursionError.

La solución

Para implementar __getattribute__ de forma segura, debes delegar a la implementación base usando super().__getattribute__(name) o object.__getattribute__(self, name). Esto elude la lógica anulada y realiza la recuperación real del atributo desde el diccionario de la instancia o la jerarquía de clases sin volver a entrar en el método personalizado. El patrón asegura que puedas envolver, validar o transformar el resultado mientras mantienes la integridad del modelo de objeto y evitas bucles infinitos.

Ejemplo de código

class SafeProxy:
    def __init__(self, wrapped):
        # Debe usar super() aquí para evitar recursión durante la inicialización
        super().__setattr__('_wrapped', wrapped)
    
    def __getattribute__(self, name):
        # Registrar el acceso antes de la recuperación
        print(f"Accediendo: {name}")
        # Delegar al objeto para evitar recursión infinita
        return super().__getattribute__(name)

Situación de la vida

Escenario

Un equipo de desarrollo necesita implementar un registro de auditoría para un modelo de ORM heredado donde cada acceso a campo debe registrarse por razones de cumplimiento sin modificar las clases de modelo originales. Requieren una solución que intercepte lecturas de manera transparente para evitar romper la lógica empresarial existente en cientos de módulos.

Descripción del problema

El sistema requiere interceptar atributos tanto existentes como faltantes para registrar marcas de tiempo y acciones del usuario. Simplemente subclasificar y agregar registro a métodos individuales es inviable debido al gran número de campos dinámicos. La solución debe ser transparente al código existente y no puede alterar la interfaz pública de los modelos.

Solución 1: Parchear los métodos del modelo

Este enfoque implica reemplazar dinámicamente métodos en la clase en tiempo de ejecución para inyectar llamadas de registro, apuntando a comportamientos específicos sin alterar las definiciones originales. Permite una aplicación condicional basada en la configuración y evita complicaciones de herencia. Sin embargo, no logra interceptar el acceso directo a descriptores de datos o valores simples, requiere mantenimiento para cada nuevo método y se rompe cuando cambian los detalles de la implementación interna.

Solución 2: Usar __getattr__ para registro

Implementar __getattr__ para registrar el acceso a atributos faltantes solo proporciona un mecanismo de respaldo simple. Es seguro contra problemas de recursión y fácil de implementar con un mínimo de código adicional. Lamentablemente, solo se activa para atributos no encontrados en la instancia o clase, perdiendo la mayoría de los accesos a campos existentes, lo que derrota el requisito de auditoría para un registro completo.

Solución 3: Clase proxy con __getattribute__

Crear una clase envoltura que implemente __getattribute__ intercepete todas las lecturas de atributos antes de delegar al objeto ORM envuelto, capturando cada acceso de manera uniforme. Esto mantiene la transparencia a través de la composición y permite el pre- y post-procesamiento sin tocar el código heredado. La desventaja es el requisito de un manejo cuidadoso de la recursión y un ligero overhead de rendimiento debido a la llamada adicional de método en cada acceso a atributo.

Solución elegida

El equipo seleccionó el enfoque proxy con __getattribute__ porque las regulaciones de cumplimiento exigían capturar cada lectura de atributo, incluidos los campos de datos simples que los métodos nunca tocan. El patrón proxy proporcionó capacidades de interceptación completas mientras mantenía la encapsulación, permitiendo que el ORM heredado permaneciera intacto y ajeno a la capa de auditoría. Esta elección sacrificó un rendimiento mínimo para una cobertura exhaustiva y la integridad de la auditoría.

Resultado

La implementación registró con éxito más de 50,000 accesos a atributos por hora en producción sin un solo error de recursión o modificación en la base de código heredada. El patrón de delegación utilizando super() aseguró un funcionamiento estable, y el proxy podría ser desactivado en entornos de prueba simplemente eliminando la instancia del envoltorio, demostrando la flexibilidad del enfoque.

Lo que los candidatos a menudo pasan por alto

¿Por qué acceder a self.__dict__ dentro de __getattribute__ desencadena una recursión infinita?

Cuando escribes self.__dict__ dentro de un método __getattribute__ anulado, Python debe buscar el atributo llamado __dict__ en la instancia. Esta búsqueda invoca tu método __getattribute__ personalizado nuevamente, que intenta acceder a self.__dict__ otra vez, creando un ciclo interminable. Para romper este bucle, debes usar object.__getattribute__(self, '__dict__'), que elude tu anulación y recupera el diccionario directamente de la implementación base del objeto.

¿Cómo afecta __getattribute__ a los protocolos de descriptor de manera diferente a __getattr__?

__getattribute__ se sitúa al principio de la cadena de resolución de atributos, lo que significa que intercepta las búsquedas antes de que el protocolo de descriptor verifique los métodos __get__. Si tu implementación devuelve un valor sin delegar a super(), descriptores como property o descriptores de datos personalizados se omiten por completo. En contraste, __getattr__ solo se ejecuta después de que tanto el protocolo de descriptor como la búsqueda en el diccionario de la instancia han fallado, por lo que nunca intercepta descriptores que existen en la jerarquía de la clase.

¿Cuál es la consecuencia de generar AttributeError manualmente dentro de __getattribute__?

A diferencia del acceso estándar a atributos donde un AttributeError podría activar __getattr__ como una solución de respaldo, Python trata a __getattribute__ como la fuente autorizada. Si tu implementación personalizada genera AttributeError, el intérprete propaga la excepción de inmediato sin intentar llamar a __getattr__. Esto significa que no puedes confiar en que __getattr__ maneje atributos faltantes si tu gancho principal falla; en cambio, debes manejar claves faltantes dentro de __getattribute__ o asegurarte de delegar a la implementación principal que genera la excepción correctamente.