Dynamisch erstellte Methode und Dekorateur, bekam die Fehlermeldung 'functools.teilweise' Objekt hat kein Attribut '__module__'

Ich auch gestolpert, ich war wirklich überrascht, für mich das Problem war, dass teilweise Objekte fehlen bestimmte Attribute, die speziell __module__ und __name__

Sein, dass wraps standardmäßig verwendet functools.WRAPPER_ASSIGNMENTS zum aktualisieren von Attributen, die standardmäßig auf ('__module__', '__name__', '__doc__') in python 2.7.6 trotzdem gibt es ein paar Wege, damit umzugehen ...

Update nur Attribute ...

import functools
import itertools

def wraps_safely(obj, attr_names=functools.WRAPPER_ASSIGNMENTS):
    return wraps(obj, assigned=itertools.ifilter(functools.partial(hasattr, obj), attr_names))

>>> def foo():
...     """ Ubiquitous foo function ...."""
... 
>>> functools.wraps(partial(foo))(foo)()
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "/System/Library/Frameworks/Python.framework/Versions/2.7/lib/python2.7/functools.py", line 33, in update_wrapper
setattr(wrapper, attr, getattr(wrapped, attr))
AttributeError: 'functools.partial' object has no attribute '__module__'
>>> wraps_safely(partial(foo))(foo)()
>>> 

Wir uns hier einfach herauszufiltern, all das sind attribute, die nicht vorhanden ist.

Ein anderer Ansatz wäre, zu streng Angebot mit teilweise nur Objekte, Sie könnte klappen wraps mit singledispatch und erstellen gewickelt, teilweise Objekte, deren Attribute genommen werden würde von der tiefsten func Attribut.

Etwas entlang der Linien:

import functools

def wraps_partial(wrapper, *args, **kwargs):
    """ Creates a callable object whose attributes will be set from the partials nested func attribute ..."""
    wrapper = wrapper.func
    while isinstance(wrapper, functools.partial):
        wrapper = wrapper.func
    return functools.wraps(wrapper, *args, **kwargs)

def foo():
    """ Foo function.
    :return: None """
    pass

>>> wraps_partial(partial(partial(foo)))(lambda : None).__doc__
' Foo Function, returns None '
>>> wraps_partial(partial(partial(foo)))(lambda : None).__name__
'foo'
>>> wraps_partial(partial(partial(foo)))(lambda : None)()
>>> pfoo = partial(partial(foo))
>>> @wraps_partial(pfoo)
... def not_foo():
...     """ Not Foo function ... """
... 
>>> not_foo.__doc__
' Foo Function, returns None '
>>> not_foo.__name__
'foo'
>>>

Diese ist etwas besser, weil jetzt können wir die ursprünglichen Funktionen docs, die vor vorgegeben, die eine teilweise Objekte doc string.

Diese können modifiziert werden, um nur suchen, wenn das aktuelle teilobjekt nicht bereits über die set-Attribut, das sollte etwas schneller beim Schachteln vielen teilobjekten ...

UPDATE

Scheint es, dass python(CPython) 3 (mindestens 3.4.3) nicht dieses Problem haben, da ich nicht weiß, noch sollte ich übernehmen alle Versionen von python 3 oder anderen Implementierungen wie Jython auch gemeinsam dieses Problem hier ist ein anderes Zukunft bereit Ansatz

from functools import wraps, partial, WRAPPER_ASSIGNMENTS

try:
    wraps(partial(wraps))(wraps)
except AttributeError:
    @wraps(wraps)
    def wraps(obj, attr_names=WRAPPER_ASSIGNMENTS, wraps=wraps):
        return wraps(obj, assigned=(name for name in attr_names if hasattr(obj, name))) 

ein paar Dinge zu beachten:

• definieren wir eine neue wraps Funktion nur, wenn wir uns nicht wickeln teilweise, bei zukünftigen Versionen von python2 oder andere Versionen dieses Problem lösen.
• wir verwenden die original wraps kopieren der Dokumente und andere Informationen, die
• die wir nicht benutzen ifilter da es entfernt wurde, in Python ist3, ich habe timeit mit und ohne ifilter aber die Ergebnisse, wo nicht eindeutig, zumindest in python (CPython) 2.7.6, der Unterschied war marginal, am besten so oder so...

Falls es der Fall, dass es durch ein Problem mit "Wickel" in functools, es gibt nichts hindert Sie schreiben Ihre eigenen teilweise nicht nennen-Packungen. Nach der python-Dokumentation, dies ist eine gültige Implementierung der partial:

def partial(func, *args, **keywords):
    def newfunc(*fargs, **fkeywords):
        newkeywords = keywords.copy()
        newkeywords.update(fkeywords)
        return func(*(args + fargs), **newkeywords)
    newfunc.func = func
    newfunc.args = args
    newfunc.keywords = keywords
    return newfunc

In unserem Fall habe ich dies Problem gelöst, indem bilden von Unterklassen functools.teilweise:

class WrappablePartial(functools.partial):

    @property
    def __module__(self):
        return self.func.__module__

    @property
    def __name__(self):
        return "functools.partial({}, *{}, **{})".format(
            self.func.__name__,
            self.args,
            self.keywords
        )

    @property
    def __doc__(self):
        return self.func.__doc__

NB Sie könnten auch Gebrauch machen von __getattr__ Umleitung Abfragen, aber ich dachte, das war eigentlich weniger gelesen (und macht es schwer irgendwelche nützlichen meta-Daten als mit __name__)

Dieses Problem wird behoben, da der Python 2.7.11 (nicht sicher, welche spezifische Version es gefixt wurde). Sie tun kann functools.wraps auf eine functools.partial Objekt in 2.7.11.