I want to do a monkey patch only partially safely in Python

What is monkey patch?

Monkey patches extend or modify dynamic language (eg Smalltalk, JavaScript, Objective-C, Ruby, Perl, Python, Groovy, etc.) code at runtime without modifying the original source code. How to do it.

[Wiki reference](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)

Subject

Round is no longer rounded in Python 3

print round(2.5) # => 3.0

print(round(2.5)) # => 2

It seems that the round function is treated as a floating point number from python3. So that you can use this by rounding !!

Rounding code

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

Reference URL

↓ ↓ I want to write like this ↓ ↓

sample.py

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

Generate setting.py

1. For the time being, monkey patch

setting.py

import builtins #Built-in functions are in builtins
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

• When the target function is called in the custom function, it loops infinitely.
• => You can call it with the alias function by setting from builtins import round as alias outside the cuntom function. (Because the function is made into an object by as. In module, as is passed by reference)
• If round = custom_round, round is already an object, so it will not be a monkey patch.

sample.py

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

I thought it was a success because it was displayed

sample.py

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

sample2.py

print(round(2.5)) #=> 3.0

• When the target function is executed in another file, the custom function is called.
• => If the target function is used in an external module such as library, it may result in destructive behavior.

=> Not safe !!!!?

2. Hook the caller's namespace from the stack trace

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]
        #Because import lib may be used for fetching and importing the caller.
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 may be included in the import trace. (Confirm when having a hierarchy)
• In builtins (built-in function), it is stored in namespace without going through module.
• In module, replace the last line with the following code.
• Overwrite the namespace module with the module that replaces only the target function.

Last line replacement.py

# ${module} :Target module, ${function} :Target function
replacing = imp.load_module('temp', *imp.find_module(${module}))
setattr(replacing, '${function}', ${custom function})
frame.f_locals[${module}] = replacing

I wonder if the File was separated ... The setting process is not performed in sample2 ...

sample.py

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

sample2.py

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

=> The module imported once is retained in sys.modules, and in the second import, it is referenced from sys.module and the code is not called.

3. Replace builtins.import directly and call the monkey patch function at the time of import.

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]
        #Because import lib may be used for fetching and importing the caller.
    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

• Call the monkey patch function by hooking import.
• In python3, there is an import hooks mechanism such as meta path and path hooks, These are not called in the modules stored in sys.modules.
• In order to add the import hook in the first import, the first monkey pathc function is The call is listed at the top level.

Summary

Finally, I was able to implement a monkey patch only with the module where the import setting is written.