Os módulos podem ter propriedades da mesma forma que os objetos?

Com propriedades python, posso torná-lo tal que

obj.y 

chama uma função em vez de apenas retornar um valor.

Existe uma maneira de fazer isso com módulos? Eu tenho um caso onde eu quero

module.y 

para chamar uma função, em vez de apenas retornar o valor armazenado lá.

Apenas instâncias de classes de novo estilo podem ter propriedades. Você pode fazer o Python acreditar que tal instância é um módulo armazenando-o em sys.modules[thename] = theinstance. Portanto, por exemplo, o arquivo do módulo m.py pode 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()

Eu faria isso para herdar adequadamente todos os atributos de um módulo e ser identificado corretamente 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

E então você pode inserir isso em sys.modules:

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

Como o PEP 562 foi implementado em Python> = 3.7, agora podemos fazer isso

arquivo: 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'

Observe que se você omitir o raise AttributeErrorna __getattr__função, isso significa que a função termina com return None, então o module.nosuchobterá um valor de None.

Com base na resposta 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 o sublinhado inicial), em the_module.py:

@module_property
def _thing():
    return 'hello'

Então:

import the_module

print(the_module.thing)  # prints 'hello'

O sublinhado inicial é necessário para diferenciar a função de propriedade da função original. Não consegui pensar em uma maneira de reatribuir o identificador, pois durante o tempo de execução do decorador, ele ainda não foi atribuído.

Observe que os IDEs não saberão que a propriedade existe e exibirão ondulações vermelhas.

Um caso de uso típico é: enriquecer um (enorme) módulo existente com alguns (poucos) atributos dinâmicos - sem transformar todo o material do módulo em um layout de classe. Infelizmente, um patch de classe de módulo mais simples como sys.modules[__name__].__class__ = MyPropertyModulefalha com TypeError: __class__ assignment: only for heap types. Portanto, a criação do módulo precisa ser reconectada.

Essa abordagem faz isso sem ganchos de importação Python, apenas por ter algum prólogo no topo do código do 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 dynvalirá produzir uma cópia congelada, é claro - correspondendo adynval = someobject.dynval

Uma resposta curta: use proxy_tools

O proxy_toolspacote tenta fornecer @module_propertyfuncionalidade.

É instalado com

pip install proxy_tools

Usando uma ligeira modificação do exemplo de @Marin, the_module.pycolocamos

from proxy_tools import module_property

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

Agora a partir de outro script, posso fazer

import the_module

print(the_module.thing)
# . hello

Comportamento inesperado

Esta solução possui algumas ressalvas. Ou seja, nãothe_module.thing é uma string ! É um proxy_tools.Proxyobjeto cujos métodos especiais foram substituídos para que imite uma string. Aqui estão alguns testes básicos que ilustram o ponto:

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, a função original é armazenada em the_module.thing._Proxy__local:

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

Pensamentos adicionais

Honestamente, estou perplexo sobre por que os módulos não têm essa funcionalidade incorporada. Acho que o ponto crucial da questão é que the_moduleé uma instância da types.ModuleTypeclasse. Definir uma "propriedade de módulo" equivale a definir uma propriedade em uma instância dessa classe, em vez da types.ModuleTypeprópria classe. Para mais detalhes, veja esta resposta .

Na verdade, podemos implementar propriedades da types.ModuleTypeseguinte maneira, embora os resultados não sejam bons. Não podemos modificar diretamente os tipos integrados, mas podemos amaldiçoá- los:

# 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__}'))

Isso nos dá uma propriedade que existe em todos os módulos. É um pouco difícil de manejar, pois quebramos o comportamento da configuração em todos os módulos:

import sys

print(sys.thing2)
# hi from sys

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