__getattr__ pada modul

Bagaimana mengimplementasikan yang setara dengan a __getattr__di kelas, di modul?

Contoh

Saat memanggil fungsi yang tidak ada dalam atribut modul yang didefinisikan secara statis, saya ingin membuat instance kelas dalam modul itu, dan memanggil metode di atasnya dengan nama yang sama seperti yang gagal dalam pencarian atribut pada modul.

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

Pemberian yang mana:

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

Beberapa waktu lalu, Guido mendeklarasikan bahwa semua pencarian metode khusus pada kelas gaya baru melewati __getattr__dan__getattribute__ . Metode Dunder sebelumnya bekerja pada modul - Anda dapat, misalnya, menggunakan modul sebagai pengelola konteks hanya dengan mendefinisikan __enter__dan __exit__, sebelum trik tersebut rusak .

Baru-baru ini beberapa fitur historis telah kembali, modul __getattr__di antaranya, dan peretasan yang ada (modul yang menggantikan dirinya dengan kelas pada sys.modulessaat impor) seharusnya tidak lagi diperlukan.

Di Python 3.7+, Anda cukup menggunakan satu cara yang jelas. Untuk menyesuaikan akses atribut pada modul, tentukan __getattr__fungsi pada tingkat modul yang harus menerima satu argumen (nama atribut), dan mengembalikan nilai yang dihitung atau meningkatkan AttributeError:

# my_module.py

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

Ini juga akan memungkinkan kait ke impor "dari", yaitu Anda dapat mengembalikan objek yang dibuat secara dinamis untuk pernyataan seperti from my_module import whatever.

Pada catatan terkait, bersama dengan getattr modul, Anda juga dapat menentukan __dir__fungsi di tingkat modul untuk merespons dir(my_module). Lihat PEP 562 untuk detailnya.

Ada dua masalah dasar yang Anda hadapi di sini:

1. __xxx__ metode hanya dicari di kelas
2. TypeError: can't set attributes of built-in/extension type 'module'

(1) berarti solusi apa pun juga harus melacak modul mana yang sedang diperiksa, jika tidak, setiap modul akan memiliki perilaku substitusi-instance; dan (2) berarti bahwa (1) bahkan tidak mungkin ... setidaknya tidak secara langsung.

Untungnya, sys.modules tidak pilih-pilih tentang apa yang ada di sana sehingga pembungkus akan berfungsi, tetapi hanya untuk akses modul (yaitu import somemodule; somemodule.salutation('world'); untuk akses modul yang sama Anda harus mencabut metode dari kelas substitusi dan menambahkannya ke globals()eiher dengan metode kustom di kelas (saya suka menggunakan .export()) atau dengan fungsi umum (seperti yang sudah terdaftar sebagai jawaban). Satu hal yang perlu diingat: jika pembungkus selalu membuat instance baru, dan solusi global tidak, Anda berakhir dengan perilaku yang agak berbeda. Oh, dan Anda tidak dapat menggunakan keduanya pada saat yang sama - itu salah satu.

Memperbarui

Dari Guido van Rossum :

Sebenarnya ada peretasan yang kadang-kadang digunakan dan direkomendasikan: modul dapat mendefinisikan kelas dengan fungsionalitas yang diinginkan, dan kemudian pada akhirnya, mengganti dirinya sendiri di sys.modules dengan instance kelas itu (atau dengan kelas, jika Anda bersikeras , tapi itu umumnya kurang berguna). Misalnya:

# module foo.py

import sys

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

sys.modules[__name__] = Foo()

Ini berfungsi karena mesin impor secara aktif mengaktifkan peretasan ini, dan sebagai langkah terakhirnya menarik modul aktual dari sys.modules, setelah memuatnya. (Ini bukan kebetulan. Peretasan sudah lama diusulkan dan kami memutuskan bahwa kami cukup menyukainya untuk mendukungnya di mesin impor.)

Jadi cara yang mapan untuk mencapai apa yang Anda inginkan adalah dengan membuat satu kelas dalam modul Anda, dan sebagai tindakan terakhir modul ganti sys.modules[__name__]dengan instance kelas Anda - dan sekarang Anda dapat bermain dengan __getattr__/ __setattr__/ __getattribute__sesuai kebutuhan.

Catatan 1 : Jika Anda menggunakan fungsionalitas ini, apa pun yang ada di modul, seperti global, fungsi lain, dll., Akan hilang saat sys.modulestugas dibuat - jadi pastikan semua yang diperlukan ada di dalam kelas pengganti.

Catatan 2 : Untuk mendukung from module import *Anda harus __all__didefinisikan di kelas; sebagai contoh:

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

Bergantung pada versi Python Anda, mungkin ada nama lain untuk dihilangkan __all__. The set()dapat dihilangkan jika Python 2 kompatibilitas tidak diperlukan.

Ini adalah hack, tetapi Anda dapat membungkus modul dengan kelas:

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__])

Kami biasanya tidak melakukannya seperti itu.

Yang kami lakukan adalah ini.

class A(object):
....

# The implicit global instance
a= A()

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

Mengapa? Sehingga contoh global implisit terlihat.

Misalnya, lihat randommodul, yang membuat instance global implisit untuk sedikit menyederhanakan kasus penggunaan di mana Anda menginginkan generator nomor acak "sederhana".

Mirip dengan apa yang @ Håvard S usulkan, dalam kasus di mana saya perlu menerapkan beberapa sihir pada modul (seperti __getattr__), saya akan mendefinisikan kelas baru yang mewarisi types.ModuleTypedan memasukkannya sys.modules(mungkin mengganti modul tempat kebiasaan saya ModuleTypedidefinisikan).

Lihat __init__.pyfile utama Werkzeug untuk implementasi yang cukup kuat dari ini.

Ini hackish, tapi ...

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

Ini bekerja dengan mengulang semua objek di namespace global. Jika item tersebut adalah kelas, item tersebut diulangi atas atribut kelas. Jika atribut dapat dipanggil, ia menambahkannya ke namespace global sebagai fungsi.

Ini mengabaikan semua atribut yang berisi "__".

Saya tidak akan menggunakan ini dalam kode produksi, tetapi ini akan membantu Anda memulai.

Inilah kontribusi saya yang sederhana - sedikit hiasan dari jawaban @ Håvard S yang berperingkat tinggi, tetapi sedikit lebih eksplisit (jadi mungkin dapat diterima oleh @ S. Lott, meskipun mungkin tidak cukup baik untuk 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")

Buat file modul Anda yang memiliki kelas Anda. Impor modul. Jalankan getattrpada modul yang baru saja Anda impor. Anda dapat melakukan impor dinamis menggunakan__import__ dan menarik modul dari sys.modules.

Ini modul Anda some_module.py:

class Foo(object):
    pass

class Bar(object):
    pass

Dan di modul lain:

import some_module

Foo = getattr(some_module, 'Foo')

Melakukan ini secara dinamis:

import sys

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