Les modules peuvent-ils avoir des propriétés de la même manière que les objets?

Avec les propriétés python, je peux faire en sorte que

obj.y 

appelle une fonction plutôt que de simplement renvoyer une valeur.

Existe-t-il un moyen de faire cela avec des modules? J'ai un cas où je veux

module.y 

pour appeler une fonction, plutôt que de simplement renvoyer la valeur qui y est stockée.

Seules les instances de classes de nouveau style peuvent avoir des propriétés. Vous pouvez faire croire à Python qu'une telle instance est un module en le cachant sys.modules[thename] = theinstance. Ainsi, par exemple, votre fichier de module m.py pourrait être:

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()

Je ferais cela pour hériter correctement de tous les attributs d'un module, et être correctement identifié par isinstance ()

import types

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


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

Et puis vous pouvez insérer ceci dans sys.modules:

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

Comme PEP 562 a été implémenté en Python> = 3.7, nous pouvons maintenant le faire

fichier: module.py

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

other = 4

usage:

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

Notez que si vous omettez le raise AttributeErrordans la __getattr__fonction, cela signifie que la fonction se termine par return None, alors le module.nosuchobtiendra une valeur de None.

Basé sur la réponse 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

Utilisation (notez le trait de soulignement principal), dans the_module.py:

@module_property
def _thing():
    return 'hello'

Ensuite:

import the_module

print(the_module.thing)  # prints 'hello'

Le trait de soulignement de début est nécessaire pour différencier la fonction de propriété de la fonction d'origine. Je ne pouvais pas penser à un moyen de réaffecter l'identifiant, car pendant le temps de l'exécution du décorateur, il n'a pas encore été attribué.

Notez que les IDE ne sauront pas que la propriété existe et afficheront des ondulations rouges.

Un cas d'utilisation typique est: enrichir un (énorme) module existant avec quelques (quelques) attributs dynamiques - sans transformer tous les éléments du module en une disposition de classe. Malheureusement, un correctif de classe de module le plus simple comme sys.modules[__name__].__class__ = MyPropertyModuleéchoue avecTypeError: __class__ assignment: only for heap types . La création du module doit donc être recâblée.

Cette approche le fait sans les hooks d'importation Python, simplement en ayant un prologue au-dessus du code du module:

# 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)

Usage:

>>> 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'"

Remarque: quelque chose comme from propertymodule import dynvalproduira une copie figée bien sûr - correspondant àdynval = someobject.dynval

Une réponse courte: utiliser proxy_tools

Le proxy_toolspackage tente de fournir@module_property fonctionnalités.

Il s'installe avec

pip install proxy_tools

En utilisant une légère modification de l'exemple de @ Marein, the_module.pynous mettons

from proxy_tools import module_property

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

Maintenant à partir d'un autre script, je peux faire

import the_module

print(the_module.thing)
# . hello

Comportement inattendu

Cette solution n'est pas sans réserves. A savoir, the_module.thingn'est pas une chaîne ! C'est un proxy_tools.Proxyobjet dont les méthodes spéciales ont été surchargées pour imiter une chaîne. Voici quelques tests de base qui illustrent ce point:

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']

En interne, la fonction d'origine est stockée dans the_module.thing._Proxy__local:

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

Réflexions supplémentaires

Honnêtement, je ne sais pas pourquoi les modules n'ont pas cette fonctionnalité intégrée. Je pense que le nœud du problème est qu'il the_modules'agit d'une instance de la types.ModuleTypeclasse. Définir une "propriété de module" revient à définir une propriété sur une instance de cette classe, plutôt que sur la types.ModuleTypeclasse elle-même. Pour plus de détails, consultez cette réponse .

Nous pouvons réellement implémenter des propriétés types.ModuleTypecomme suit, bien que les résultats ne soient pas excellents. Nous ne pouvons pas modifier directement les types intégrés, mais nous pouvons les maudire :

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

Cela nous donne une propriété qui existe sur tous les modules. C'est un peu difficile à manier, car nous cassons le comportement des paramètres dans tous les modules:

import sys

print(sys.thing2)
# hi from sys

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