__getattr__ sur un module

Comment implémenter l'équivalent d'un __getattr__sur une classe, sur un module?

Exemple

Lors de l'appel d'une fonction qui n'existe pas dans les attributs définis statiquement d'un module, je souhaite créer une instance d'une classe dans ce module et invoquer la méthode dessus avec le même nom que celui qui a échoué dans la recherche d'attributs sur le module.

class A(object):
    def salutation(self, accusative):
        print "hello", accusative

# note this function is intentionally on the module, and not the class above
def __getattr__(mod, name):
    return getattr(A(), name)

if __name__ == "__main__":
    # i hope here to have my __getattr__ function above invoked, since
    # salutation does not exist in the current namespace
    salutation("world")

Qui donne:

matt@stanley:~/Desktop$ python getattrmod.py 
Traceback (most recent call last):
  File "getattrmod.py", line 9, in <module>
    salutation("world")
NameError: name 'salutation' is not defined

Il y a quelque temps, Guido a déclaré que toutes les recherches de méthodes spéciales sur les classes de nouveau style contournaient __getattr__et__getattribute__ . Les méthodes Dunder avaient précédemment travaillé sur des modules - vous pouviez, par exemple, utiliser un module comme gestionnaire de contexte simplement en définissant __enter__et __exit__, avant que ces astuces ne se cassent .

Récemment, certaines fonctionnalités historiques ont fait leur retour, le module __getattr__parmi eux, et donc le hack existant (un module se remplaçant par une classe sys.modulesau moment de l'importation) ne devrait plus être nécessaire.

Dans Python 3.7+, vous utilisez simplement la seule manière évidente. Pour personnaliser l'accès aux attributs sur un module, définissez une __getattr__fonction au niveau du module qui doit accepter un argument (nom de l'attribut), et renvoyer la valeur calculée ou lever un AttributeError:

# my_module.py

def __getattr__(name: str) -> Any:
    ...

Cela permettra également de se connecter aux importations "from", c'est-à-dire que vous pouvez renvoyer des objets générés dynamiquement pour des instructions telles que from my_module import whatever.

Sur une note connexe, avec le module getattr, vous pouvez également définir une __dir__fonction au niveau du module à laquelle répondre dir(my_module). Voir PEP 562 pour plus de détails.

Il y a deux problèmes de base que vous rencontrez ici:

1. __xxx__ les méthodes ne sont recherchées que sur la classe
2. TypeError: can't set attributes of built-in/extension type 'module'

(1) signifie que toute solution devrait également garder une trace du module en cours d'examen, sinon chaque module aurait alors le comportement de substitution d'instance; et (2) signifie que (1) n'est même pas possible ... du moins pas directement.

Heureusement, sys.modules n'est pas pointilleux sur ce qui s'y passe, donc un wrapper fonctionnera, mais uniquement pour l'accès au module (c'est-à-dire import somemodule; somemodule.salutation('world'); pour l'accès au même module, vous devez à peu près extraire les méthodes de la classe de substitution et les ajouter à globals()eiher avec un méthode personnalisée sur la classe (j'aime utiliser .export()) ou avec une fonction générique (comme celles déjà répertoriées comme réponses). Une chose à garder à l'esprit: si le wrapper crée une nouvelle instance à chaque fois, et que la solution globale ne l'est pas, vous vous retrouvez avec un comportement subtilement différent Oh, et vous ne pouvez pas utiliser les deux en même temps - c'est l'un ou l'autre.

Mettre à jour

De Guido van Rossum :

Il y a en fait un hack qui est parfois utilisé et recommandé: un module peut définir une classe avec la fonctionnalité souhaitée, puis à la fin, se remplacer dans sys.modules par une instance de cette classe (ou par la classe, si vous insistez , mais c'est généralement moins utile). Par exemple:

# module foo.py

import sys

class Foo:
    def funct1(self, <args>): <code>
    def funct2(self, <args>): <code>

sys.modules[__name__] = Foo()

Cela fonctionne parce que la machine d'importation active activement ce hack et que sa dernière étape extrait le module réel de sys.modules, après l'avoir chargé. (Ce n'est pas un hasard. Le hack a été proposé il y a longtemps et nous avons décidé que nous aimions suffisamment pour le supporter dans la machinerie d'importation.)

Donc, la façon établie d'accomplir ce que vous voulez est de créer une seule classe dans votre module, et comme dernier acte du module, remplacez-la sys.modules[__name__]par une instance de votre classe - et maintenant vous pouvez jouer avec __getattr__/ __setattr__/ __getattribute__si nécessaire.

Remarque 1 : Si vous utilisez cette fonctionnalité, tout le reste du module, comme les globaux, les autres fonctions, etc., sera perdu lors de l' sys.modulesaffectation - assurez-vous donc que tout ce qui est nécessaire se trouve dans la classe de remplacement.

Note 2 : Pour soutenir, from module import *vous devez avoir __all__défini dans la classe; par exemple:

class Foo:
    def funct1(self, <args>): <code>
    def funct2(self, <args>): <code>
    __all__ = list(set(vars().keys()) - {'__module__', '__qualname__'})

Selon votre version de Python, il peut y avoir d'autres noms à omettre __all__. Le set()peut être omis si la compatibilité Python 2 n'est pas nécessaire.

C'est un hack, mais vous pouvez envelopper le module avec une classe:

class Wrapper(object):
  def __init__(self, wrapped):
    self.wrapped = wrapped
  def __getattr__(self, name):
    # Perform custom logic here
    try:
      return getattr(self.wrapped, name)
    except AttributeError:
      return 'default' # Some sensible default

sys.modules[__name__] = Wrapper(sys.modules[__name__])

Nous ne le faisons généralement pas de cette façon.

Voici ce que nous faisons.

class A(object):
....

# The implicit global instance
a= A()

def salutation( *arg, **kw ):
    a.salutation( *arg, **kw )

Pourquoi? Pour que l'instance globale implicite soit visible.

Pour des exemples, regardez le randommodule, qui crée une instance globale implicite pour simplifier légèrement les cas d'utilisation où vous voulez un générateur de nombres aléatoires "simple".

Semblable à ce que @ Håvard S a proposé, dans un cas où je devais implémenter un peu de magie sur un module (comme __getattr__), je définirais une nouvelle classe qui hérite types.ModuleTypeet la mettrait sys.modules(en remplaçant probablement le module où ma coutume a ModuleTypeété définie).

Voir le __init__.pyfichier principal de Werkzeug pour une implémentation assez robuste de ceci.

C'est hackish, mais ...

import types

class A(object):
    def salutation(self, accusative):
        print "hello", accusative

    def farewell(self, greeting, accusative):
         print greeting, accusative

def AddGlobalAttribute(classname, methodname):
    print "Adding " + classname + "." + methodname + "()"
    def genericFunction(*args):
        return globals()[classname]().__getattribute__(methodname)(*args)
    globals()[methodname] = genericFunction

# set up the global namespace

x = 0   # X and Y are here to add them implicitly to globals, so
y = 0   # globals does not change as we iterate over it.

toAdd = []

def isCallableMethod(classname, methodname):
    someclass = globals()[classname]()
    something = someclass.__getattribute__(methodname)
    return callable(something)


for x in globals():
    print "Looking at", x
    if isinstance(globals()[x], (types.ClassType, type)):
        print "Found Class:", x
        for y in dir(globals()[x]):
            if y.find("__") == -1: # hack to ignore default methods
                if isCallableMethod(x,y):
                    if y not in globals(): # don't override existing global names
                        toAdd.append((x,y))


for x in toAdd:
    AddGlobalAttribute(*x)


if __name__ == "__main__":
    salutation("world")
    farewell("goodbye", "world")

Cela fonctionne en itérant sur tous les objets de l'espace de noms global. Si l'élément est une classe, il itère sur les attributs de classe. Si l'attribut est appelable, il l'ajoute à l'espace de noms global en tant que fonction.

Il ignore tous les attributs qui contiennent "__".

Je n'utiliserais pas cela dans le code de production, mais cela devrait vous aider à démarrer.

Voici ma propre contribution humble - un léger embellissement de la réponse très appréciée de @ Håvard S, mais un peu plus explicite (donc cela pourrait être acceptable pour @ S.Lott, même si probablement pas assez bien pour l'OP):

import sys

class A(object):
    def salutation(self, accusative):
        print "hello", accusative

class Wrapper(object):
    def __init__(self, wrapped):
        self.wrapped = wrapped

    def __getattr__(self, name):
        try:
            return getattr(self.wrapped, name)
        except AttributeError:
            return getattr(A(), name)

_globals = sys.modules[__name__] = Wrapper(sys.modules[__name__])

if __name__ == "__main__":
    _globals.salutation("world")

Créez votre fichier de module contenant vos classes. Importez le module. Exécutez getattrsur le module que vous venez d'importer. Vous pouvez effectuer une importation dynamique en utilisant __import__et extraire le module de sys.modules.

Voici votre module some_module.py:

class Foo(object):
    pass

class Bar(object):
    pass

Et dans un autre module:

import some_module

Foo = getattr(some_module, 'Foo')

Faire cela dynamiquement:

import sys

__import__('some_module')
mod = sys.modules['some_module']
Foo = getattr(mod, 'Foo')