Je veux faire un patch monkey seulement en partie en toute sécurité avec Python

Qu'est-ce que Monkey Patch?

Les patchs Monkey étendent ou modifient le code de langage dynamique (par exemple Smalltalk, JavaScript, Objective-C, Ruby, Perl, Python, Groovy, etc.) au moment de l'exécution sans modifier le code source d'origine. Comment faire.

[Voir wiki](https://ja.wikipedia.org/wiki/%E3%83%A2%E3%83%B3%E3%82%AD%E3%83%BC%E3%83%91%E3% 83% 83% E3% 83% 81)

Matière

Le rond n'est plus arrondi en Python 3

print round(2.5) # => 3.0

print(round(2.5)) # => 2

Il semble que la fonction round soit traitée comme une virgule flottante depuis python3. Pour que vous puissiez l'utiliser en arrondissant !!

Code d'arrondi

def custom_round(x, d=0):
    import math
    p = 10 ** d
    return float(math.floor((x * p) + math.copysign(0.5, x)))/p
print(custom_round(2.5)) #=> 3.0

URL de référence

↓ ↓ Je veux écrire comme ça ↓ ↓

sample.py

import setting
print(round(2.5)) #=> 3.0

Générer setting.py

1. Monkey patch pour le moment

setting.py

import builtins #Les fonctions intégrées sont intégrées
def custom_round(x, d=0):
    import math
    p = 10 ** d
    return float(math.floor((x * p) + math.copysign(0.5, x)))/p
builtins.round = custom_round # monkey patch

• Lorsque la fonction cible est appelée dans la fonction personnalisée, elle boucle indéfiniment.
• => Vous pouvez l'appeler avec la fonction alias en définissant à partir de l'importation intégrée round comme alias en dehors de la fonction cuntom. (Parce que la fonction est transformée en objet par as. Dans le module, tel que passé par référence)
• Si round = custom_round, round est déjà un objet, donc ce ne sera pas un patch de singe.

sample.py

import setting
print(round(2.5)) #=> 3.0

J'ai pensé que c'était un succès car il était affiché

sample.py

import setting
print(round(2.5)) #=> 3.0
import sample2

sample2.py

print(round(2.5)) #=> 3.0

• Lorsque la fonction cible est exécutée dans un autre fichier, la fonction personnalisée est appelée.
• => Si la fonction cible est utilisée dans un module externe tel qu'une bibliothèque, cela peut entraîner un comportement destructeur.

=> Pas sûr !!!!?

2. Accrochez l'espace de nom de l'appelant à partir de la trace de pile

python

import inspect, imp
import builtins
def custom_round(x, d=0):
    import math
    p = 10 ** d
    return float(math.floor((x * p) + math.copysign(0.5, x)))/p

frame = [frame for (frame, filename, _, _, _,_) in 
             inspect.getouterframes(inspect.currentframe())[1:] 
                 if not 'importlib' in filename and not __file__ in filename][0]
        #Parce qu'il y a des cas où importlib est utilisé pour obtenir l'appelant et importer.
frame.f_locals['round'] = custom_round

sample.py

import setting
print(round(2.5)) #=> 3.0
import sample2

sample2.py

print(round(2.5)) #=> 2

• Importlib peut être inclus dans la trace d'importation. (Confirmer lorsque vous avez une hiérarchie)
• Dans les builtins, il est stocké dans l'espace de noms sans passer par le module.
• Dans le module, remplacez la dernière ligne par le code ci-dessous.
• Remplacez le module d'espace de noms par le module qui remplace uniquement la fonction cible.

Remplacement de la dernière ligne.py

# ${module} :Module cible, ${function} :Fonction cible
replacing = imp.load_module('temp', *imp.find_module(${module}))
setattr(replacing, '${function}', ${fonction personnalisée})
frame.f_locals[${module}] = replacing

Je me demande si le fichier a été séparé ... Le processus de paramétrage n'est pas effectué dans sample2 ...

sample.py

import setting
print(round(2.5)) #=> 3.0
import sample2

sample2.py

import setting
print(round(2.5)) #=> 2

=> Le module importé une fois est conservé dans sys.modules, et dans la seconde importation, il est référencé à partir de sys.module et le code n'est pas appelé.

3. Remplacez directement builtins.import et appelez la fonction monkey patch au moment de l'importation.

setting.py

import inspect, imp
import builtins
def custom_round(x, d=0):
    import math
    p = 10 ** d
    return float(math.floor((x * p) + math.copysign(0.5, x)))/p

def hooking():
    frame = [frame for (frame, filename, _, _, _,_) in 
             inspect.getouterframes(inspect.currentframe())[1:] 
                 if not 'importlib' in filename and not __file__ in filename][0]
        #Parce qu'il y a des cas où importlib est utilisé pour obtenir l'appelant et importer.
    frame.f_locals['round'] = custom_round

class Importer(object):
    old_import = __import__
    def new_import(self, *args, **kwargs):
        if args[0] == __name__: hooking() 
        return self.old_import(*args, **kwargs)

hooking()
import builtins
builtins.__import__ = Importer().new_import

sample.py

import setting
print(round(2.5)) #=> 3.0
import sample2

sample2.py

import setting
print(round(2.5)) #=> 3.0

• Appelez la fonction de patch de singe en accrochant l'importation.
• En python3, il existe un mécanisme d'importation de hooks tel que le meta path et le path hooks, Ceux-ci ne sont pas appelés dans les modules stockés dans sys.modules.
• Afin d'ajouter le hook d'importation dans la première importation, la première fonction de chemin de singe est L'appel est répertorié au niveau supérieur.

Résumé

Enfin, j'ai pu implémenter un patch monkey uniquement avec le module où le paramètre d'importation est écrit.