Bagaimana cara memotong definisi fungsi python dengan dekorator?

Saya ingin tahu apakah mungkin untuk mengontrol definisi fungsi Python berdasarkan pengaturan global (misalnya OS). Contoh:

@linux
def my_callback(*args, **kwargs):
    print("Doing something @ Linux")
    return

@windows
def my_callback(*args, **kwargs):
    print("Doing something @ Windows")
    return

Kemudian, jika seseorang menggunakan Linux, definisi pertama my_callbackakan digunakan dan yang kedua akan diabaikan.

Ini bukan tentang menentukan OS, ini tentang definisi fungsi / dekorator.

Jika tujuannya adalah untuk memiliki efek yang sama dalam kode Anda yang memiliki #ifdef WINDOWS / #endif .. inilah cara untuk melakukannya (Saya menggunakan mac btw).

Kasus Sederhana, Tanpa Rantai

>>> def _ifdef_decorator_impl(plat, func, frame):
...     if platform.system() == plat:
...         return func
...     elif func.__name__ in frame.f_locals:
...         return frame.f_locals[func.__name__]
...     else:
...         def _not_implemented(*args, **kwargs):
...             raise NotImplementedError(
...                 f"Function {func.__name__} is not defined "
...                 f"for platform {platform.system()}.")
...         return _not_implemented
...             
...
>>> def windows(func):
...     return _ifdef_decorator_impl('Windows', func, sys._getframe().f_back)
...     
>>> def macos(func):
...     return _ifdef_decorator_impl('Darwin', func, sys._getframe().f_back)

Jadi dengan implementasi ini Anda mendapatkan sintaks yang sama dengan yang Anda miliki dalam pertanyaan Anda.

>>> @macos
... def zulu():
...     print("world")
...     
>>> @windows
... def zulu():
...     print("hello")
...     
>>> zulu()
world
>>> 

Apa yang dilakukan kode di atas, pada dasarnya, adalah menugaskan zulu ke zulu jika platform cocok. Jika platform tidak cocok, itu akan mengembalikan zulu jika sudah ditentukan sebelumnya. Jika tidak ditentukan, ia mengembalikan fungsi placeholder yang menimbulkan pengecualian.

Penghias secara konsep mudah untuk mencari tahu jika Anda ingat itu

@mydecorator
def foo():
    pass

analog dengan:

foo = mydecorator(foo)

Berikut ini implementasi menggunakan dekorator berparameter:

>>> def ifdef(plat):
...     frame = sys._getframe().f_back
...     def _ifdef(func):
...         return _ifdef_decorator_impl(plat, func, frame)
...     return _ifdef
...     
>>> @ifdef('Darwin')
... def ice9():
...     print("nonsense")

Dekorator berparameter analog dengan foo = mydecorator(param)(foo).

Saya sudah memperbarui sedikit jawabannya. Menanggapi komentar, saya telah memperluas cakupan aslinya untuk memasukkan aplikasi ke metode kelas dan untuk mencakup fungsi yang didefinisikan dalam modul lain. Dalam pembaruan terakhir ini, saya dapat mengurangi kompleksitas yang terlibat dalam menentukan apakah suatu fungsi telah ditentukan.

[Sedikit pembaruan di sini ... Saya tidak bisa menghentikannya - ini merupakan latihan yang menyenangkan] Saya telah melakukan beberapa pengujian lagi, dan ternyata ini berfungsi secara umum pada kartu panggil - bukan hanya fungsi biasa; Anda juga bisa mendekorasi deklarasi kelas apakah dapat dipanggil atau tidak. Dan itu mendukung fungsi fungsi dalam, jadi hal-hal seperti ini dimungkinkan (walaupun mungkin bukan gaya yang baik - ini hanya kode uji):

>>> @macos
... class CallableClass:
...     
...     @macos
...     def __call__(self):
...         print("CallableClass.__call__() invoked.")
...     
...     @macos
...     def func_with_inner(self):
...         print("Defining inner function.")
...         
...         @macos
...         def inner():
...             print("Inner function defined for Darwin called.")
...             
...         @windows
...         def inner():
...             print("Inner function for Windows called.")
...         
...         inner()
...         
...     @macos
...     class InnerClass:
...         
...         @macos
...         def inner_class_function(self):
...             print("Called inner_class_function() Mac.")
...             
...         @windows
...         def inner_class_function(self):
...             print("Called inner_class_function() for windows.")

Di atas menunjukkan mekanisme dasar dekorator, cara mengakses ruang lingkup pemanggil, dan bagaimana menyederhanakan banyak dekorator yang memiliki perilaku serupa dengan memiliki fungsi internal yang berisi algoritma umum yang ditentukan.

Dukungan Chaining

Untuk mendukung rantai dekorator ini menunjukkan apakah suatu fungsi berlaku untuk lebih dari satu platform, dekorator dapat diimplementasikan seperti:

>>> class IfDefDecoratorPlaceholder:
...     def __init__(self, func):
...         self.__name__ = func.__name__
...         self._func    = func
...         
...     def __call__(self, *args, **kwargs):
...         raise NotImplementedError(
...             f"Function {self._func.__name__} is not defined for "
...             f"platform {platform.system()}.")
...
>>> def _ifdef_decorator_impl(plat, func, frame):
...     if platform.system() == plat:
...         if type(func) == IfDefDecoratorPlaceholder:
...             func = func._func
...         frame.f_locals[func.__name__] = func
...         return func
...     elif func.__name__ in frame.f_locals:
...         return frame.f_locals[func.__name__]
...     elif type(func) == IfDefDecoratorPlaceholder:
...         return func
...     else:
...         return IfDefDecoratorPlaceholder(func)
...
>>> def linux(func):
...     return _ifdef_decorator_impl('Linux', func, sys._getframe().f_back)

Dengan begitu Anda mendukung rantai:

>>> @macos
... @linux
... def foo():
...     print("works!")
...     
>>> foo()
works!

Meskipun @decoratorsintaks terlihat bagus, Anda mendapatkan perilaku yang sama persis seperti yang diinginkan dengan sederhana if.

linux = platform.system() == "Linux"
windows = platform.system() == "Windows"
macos = platform.system() == "Darwin"

if linux:
    def my_callback(*args, **kwargs):
        print("Doing something @ Linux")
        return

if windows:
    def my_callback(*args, **kwargs):
        print("Doing something @ Windows")
        return

Jika diperlukan, ini juga memungkinkan untuk dengan mudah menegakkan bahwa beberapa kasus cocok.

if linux:
    def my_callback(*args, **kwargs):
        print("Doing something @ Linux")
        return

elif windows:
    def my_callback(*args, **kwargs):
        print("Doing something @ Windows")
        return

else:
     raise NotImplementedError("This platform is not supported")

Di bawah ini adalah salah satu implementasi yang mungkin untuk mekanik ini. Seperti disebutkan dalam komentar, mungkin lebih baik untuk mengimplementasikan antarmuka "master dispatcher", seperti yang terlihat di functools.singledispatch, untuk melacak keadaan yang terkait dengan beberapa definisi kelebihan beban. Harapan saya adalah implementasi ini setidaknya akan menawarkan beberapa wawasan tentang masalah yang mungkin harus Anda hadapi ketika mengembangkan fungsi ini untuk basis kode yang lebih besar.

Saya hanya menguji bahwa implementasi di bawah ini berfungsi sebagaimana ditentukan pada sistem Linux, jadi saya tidak dapat menjamin bahwa solusi ini memungkinkan terciptanya fungsi khusus platform. Tolong jangan gunakan kode ini dalam pengaturan produksi tanpa mengujinya sendiri terlebih dahulu.

import platform
from functools import wraps
from typing import Callable, Optional


def implement_for_os(os_name: str):
    """
    Produce a decorator that defines a provided function only if the
    platform returned by `platform.system` matches the given `os_name`.
    Otherwise, replace the function with one that raises `NotImplementedError`.
    """
    def decorator(previous_definition: Optional[Callable]):
        def _decorator(func: Callable):
            if previous_definition and hasattr(previous_definition, '_implemented_for_os'):
                # This function was already implemented for this platform. Leave it unchanged.
                return previous_definition
            elif platform.system() == os_name:
                # The current function is the correct impementation for this platform.
                # Mark it as such, and return it unchanged.
                func._implemented_for_os = True
                return func
            else:
                # This function has not yet been implemented for the current platform
                @wraps(func)
                def _not_implemented(*args, **kwargs):
                    raise NotImplementedError(
                        f"The function {func.__name__} is not defined"
                        f" for the platform {platform.system()}"
                    )

                return _not_implemented
        return _decorator

    return decorator


implement_linux = implement_for_os('Linux')

implement_windows = implement_for_os('Windows')

Untuk menggunakan dekorator ini, kita harus bekerja melalui dua tingkat tipuan. Pertama, kita harus menentukan platform apa yang kita ingin dekorator merespons. Ini dilakukan oleh garis implement_linux = implement_for_os('Linux')dan mitra Window-nya di atas. Selanjutnya, kita perlu menyampaikan definisi fungsi yang kelebihan beban. Langkah ini harus dilakukan di situs definisi, seperti yang ditunjukkan di bawah ini.

Untuk mendefinisikan fungsi khusus platform, Anda sekarang dapat menulis yang berikut:

@implement_linux(None)
def some_function():
    ...

@implement_windows(some_function)
def some_function():
   ...

implement_other_platform = implement_for_os('OtherPlatform')

@implement_other_platform(some_function)
def some_function():
   ...

Panggilan untuk some_function()akan dikirim secara tepat ke definisi spesifik platform yang disediakan.

Secara pribadi, saya tidak akan menyarankan menggunakan teknik ini dalam kode produksi. Menurut pendapat saya, lebih baik eksplisit tentang perilaku yang bergantung pada platform di setiap lokasi di mana perbedaan ini terjadi.

Saya menulis kode sebelum membaca jawaban lain. Setelah saya menyelesaikan kode saya, saya menemukan kode @ Todd adalah jawaban terbaik. Pokoknya saya memposting jawaban saya karena saya merasa senang ketika saya sedang memecahkan masalah ini. Saya belajar hal-hal baru berkat pertanyaan yang bagus ini. Kelemahan dari kode saya adalah bahwa ada overhead untuk mengambil kamus setiap kali fungsi dipanggil.

from collections import defaultdict
import inspect
import os


class PlatformFunction(object):
    mod_funcs = defaultdict(dict)

    @classmethod
    def get_function(cls, mod, func_name):
        return cls.mod_funcs[mod][func_name]

    @classmethod
    def set_function(cls, mod, func_name, func):
        cls.mod_funcs[mod][func_name] = func


def linux(func):
    frame_info = inspect.stack()[1]
    mod = inspect.getmodule(frame_info.frame)
    if os.environ['OS'] == 'linux':
        PlatformFunction.set_function(mod, func.__name__, func)

    def call(*args, **kwargs):
        return PlatformFunction.get_function(mod, func.__name__)(*args,
                                                                 **kwargs)

    return call


def windows(func):
    frame_info = inspect.stack()[1]
    mod = inspect.getmodule(frame_info.frame)
    if os.environ['OS'] == 'windows':
        PlatformFunction.set_function(mod, func.__name__, func)

    def call(*args, **kwargs):
        return PlatformFunction.get_function(mod, func.__name__)(*args,
                                                                 **kwargs)

    return call


@linux
def myfunc(a, b):
    print('linux', a, b)


@windows
def myfunc(a, b):
    print('windows', a, b)


if __name__ == '__main__':
    myfunc(1, 2)

Solusi bersih adalah dengan membuat fungsi registri khusus yang dikirim sys.platform. Ini sangat mirip dengan functools.singledispatch. Kode sumber fungsi ini menyediakan titik awal yang baik untuk mengimplementasikan versi khusus:

import functools
import sys
import types


def os_dispatch(func):
    registry = {}

    def dispatch(platform):
        try:
            return registry[platform]
        except KeyError:
            return registry[None]

    def register(platform, func=None):
        if func is None:
            if isinstance(platform, str):
                return lambda f: register(platform, f)
            platform, func = platform.__name__, platform  # it is a function
        registry[platform] = func
        return func

    def wrapper(*args, **kw):
        return dispatch(sys.platform)(*args, **kw)

    registry[None] = func
    wrapper.register = register
    wrapper.dispatch = dispatch
    wrapper.registry = types.MappingProxyType(registry)
    functools.update_wrapper(wrapper, func)
    return wrapper

Sekarang dapat digunakan mirip dengan singledispatch:

@os_dispatch  # fallback in case OS is not supported
def my_callback():
    print('OS not supported')

@my_callback.register('linux')
def _():
    print('Doing something @ Linux')

@my_callback.register('windows')
def _():
    print('Doing something @ Windows')

my_callback()  # dispatches on sys.platform

Registrasi juga berfungsi langsung pada nama fungsi:

@os_dispatch
def my_callback():
    print('OS not supported')

@my_callback.register
def linux():
    print('Doing something @ Linux')

@my_callback.register
def windows():
    print('Doing something @ Windows')