¿Pueden los módulos tener propiedades de la misma manera que los objetos?

Con las propiedades de Python, puedo hacer que

obj.y 

llama a una función en lugar de simplemente devolver un valor.

¿Hay alguna forma de hacer esto con módulos? Tengo un caso donde quiero

module.y 

para llamar a una función, en lugar de simplemente devolver el valor almacenado allí.

Solo las instancias de clases de estilo nuevo pueden tener propiedades. Puede hacer que Python crea que una instancia de este tipo es un módulo guardándolo sys.modules[thename] = theinstance. Entonces, por ejemplo, su archivo de módulo m.py podría ser:

import sys

class _M(object):
    def __init__(self):
        self.c = 0
    def afunction(self):
        self.c += 1
        return self.c
    y = property(afunction)

sys.modules[__name__] = _M()

Haría esto para heredar correctamente todos los atributos de un módulo y ser identificado correctamente por isinstance ()

import types

class MyModule(types.ModuleType):
    @property
    def y(self):
        return 5


>>> a=MyModule("test")
>>> a
<module 'test' (built-in)>
>>> a.y
5

Y luego puede insertar esto en sys.modules:

sys.modules[__name__] = MyModule(__name__)  # remember to instantiate the class

Como PEP 562 se ha implementado en Python> = 3.7, ahora podemos hacer esto

archivo: module.py

def __getattr__(name):
    if name == 'y':
        return 3
    raise AttributeError(f"module '{__name__}' has no attribute '{name}'")

other = 4

uso:

>>> import module
>>> module.y
3
>>> module.other
4
>>> module.nosuch
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "module.py", line 4, in __getattr__
    raise AttributeError(f"module '{__name__}' has no attribute '{name}'")
AttributeError: module 'module' has no attribute 'nosuch'

Tenga en cuenta que si omite raise AttributeErroren la __getattr__función, significa que la función termina con return None, entonces module.nosuchobtendrá un valor de None.

Basado en la respuesta de John Lin :

def module_property(func):
    """Decorator to turn module functions into properties.
    Function names must be prefixed with an underscore."""
    module = sys.modules[func.__module__]

    def base_getattr(name):
        raise AttributeError(
            f"module '{module.__name__}' has no attribute '{name}'")

    old_getattr = getattr(module, '__getattr__', base_getattr)

    def new_getattr(name):
        if f'_{name}' == func.__name__:
            return func()
        else:
            return old_getattr(name)

    module.__getattr__ = new_getattr
    return func

Uso (observe el subrayado inicial), en the_module.py:

@module_property
def _thing():
    return 'hello'

Luego:

import the_module

print(the_module.thing)  # prints 'hello'

El guión bajo inicial es necesario para diferenciar la función con propiedad de la función original. No pude pensar en una forma de reasignar el identificador, ya que durante el tiempo de ejecución del decorador, aún no se ha asignado.

Tenga en cuenta que los IDE no sabrán que la propiedad existe y mostrarán ondas rojas.

Un caso de uso típico es: enriquecer un módulo (enorme) existente con algunos (pocos) atributos dinámicos, sin convertir todo el material del módulo en un diseño de clase. Desafortunadamente, un parche de clase de módulo más simple como sys.modules[__name__].__class__ = MyPropertyModulefalla TypeError: __class__ assignment: only for heap types. Por tanto, es necesario volver a cablear la creación de módulos.

Este enfoque lo hace sin los ganchos de importación de Python, solo con tener un prólogo encima del código del módulo:

# propertymodule.py
""" Module property example """

if '__orgmod__' not in globals():

    # constant prolog for having module properties / supports reload()

    print "PropertyModule stub execution", __name__
    import sys, types
    class PropertyModule(types.ModuleType):
        def __str__(self):
            return "<PropertyModule %r from %r>" % (self.__name__, self.__file__)
    modnew = PropertyModule(__name__, __doc__)
    modnew.__modclass__ = PropertyModule        
    modnew.__file__ = __file__
    modnew.__orgmod__ = sys.modules[__name__]
    sys.modules[__name__] = modnew
    exec sys._getframe().f_code in modnew.__dict__

else:

    # normal module code (usually vast) ..

    print "regular module execution"
    a = 7

    def get_dynval(module):
        return "property function returns %s in module %r" % (a * 4, module.__name__)    
    __modclass__.dynval = property(get_dynval)

Uso:

>>> import propertymodule
PropertyModule stub execution propertymodule
regular module execution
>>> propertymodule.dynval
"property function returns 28 in module 'propertymodule'"
>>> reload(propertymodule)   # AFTER EDITS
regular module execution
<module 'propertymodule' from 'propertymodule.pyc'>
>>> propertymodule.dynval
"property function returns 36 in module 'propertymodule'"

Nota: Algo como from propertymodule import dynvalproducirá una copia congelada, por supuesto, correspondiente adynval = someobject.dynval

Una respuesta corta: usa proxy_tools

El proxy_toolspaquete intenta proporcionar @module_propertyfuncionalidad.

Se instala con

pip install proxy_tools

Utilizando una ligera modificación del ejemplo de @ Marein, the_module.pyponemos

from proxy_tools import module_property

@module_property
def thing():
    print(". ", end='')  # Prints ". " on each invocation
    return 'hello'

Ahora de otro guión, puedo hacer

import the_module

print(the_module.thing)
# . hello

Comportamiento inesperado

Esta solución no está exenta de salvedades. Es decir, ¡ nothe_module.thing es una cadena ! Es un proxy_tools.Proxyobjeto cuyos métodos especiales se han anulado para que imite una cadena. Aquí hay algunas pruebas básicas que ilustran el punto:

res = the_module.thing
# [No output!!! Evaluation doesn't occur yet.]

print(type(res))
# <class 'proxy_tools.Proxy'>

print(isinstance(res, str))
# False

print(res)
# . hello

print(res + " there")
# . hello there

print(isinstance(res + "", str))
# . True

print(res.split('e'))
# . ['h', 'llo']

Internamente, la función original se almacena en the_module.thing._Proxy__local:

print(res._Proxy__local)
# <function thing at 0x7f729c3bf680>

Pensamientos adicionales

Honestamente, estoy desconcertado acerca de por qué los módulos no tienen esta funcionalidad incorporada. Creo que el quid del asunto es que the_modulees una instancia de la types.ModuleTypeclase. Establecer una "propiedad de módulo" equivale a establecer una propiedad en una instancia de esta clase, en lugar de en la types.ModuleTypeclase misma. Para obtener más detalles, consulte esta respuesta .

De hecho, podemos implementar propiedades de la types.ModuleTypesiguiente manera, aunque los resultados no son excelentes. No podemos modificar directamente los tipos integrados, pero podemos maldecirlos :

# python -m pip install forbiddenfruit
from forbiddenfruit import curse
from types import ModuleType
# curse has the same signature as setattr.
curse(ModuleType, "thing2", property(lambda module: f'hi from {module.__name__}'))

Esto nos da una propiedad que existe en todos los módulos. Es un poco difícil de manejar, ya que rompemos el comportamiento de configuración en todos los módulos:

import sys

print(sys.thing2)
# hi from sys

sys.thing2 = 5
# AttributeError: can't set attribute