In order to extend a function's behavior, wrappers enclose it within another function. Its functionality is available in Python. Make a function call inside a wrapper function inside function b, passing as an argument a function assumed to be function 'a' inside another function assumed to be function 'b'. So the possibility is that we can reuse the code.
Syntax:
@wrapper
def function(n):
statements(s)
This is also similar to
def function(n):
statement(s)
function = wrapper(function)
def button_conform(self,):
amount = []
for recs in self:
for rec in recs.line_ids:
amount.append(rec.amount)
if sum(amount) > self.petty_limit:
self.limit = True
self.write({'state': 'requested', }
)
def partner_name():
partner = self.env['res.partner'].search([])
print(partner)
product = self.env['product.template'].search([])
print(product)
return partner_name()
def users(*logins):
""" Decorate a method to execute it once for each given user. """
@decorator
def wrapper(func, *args, **kwargs):
self = args[0]
old_uid = self.uid
try:
Users = self.env['res.users'].with_context(active_test=False)
user_id = {
user.login: user.id
for user in Users.search([('login', 'in', list(logins))])
}
for login in logins:
with self.subTest(login=login):
self.uid = user_id[login]
func(*args, **kwargs)
self.env.cache.invalidate()
finally:
self.uid = old_uid
return wrapper
Wrapper Class in Python
The way to specify the management code of functions and classes is by Decorators.
The callable object is taken from the decorators themself as a form. And that process callable objects. A Class Decorator act similarly to function decorators, but the difference is the end of a class statement; they are run to rebind a class name to a callable. Similarly, when they are later created, a layer of wrapper logic manages instances just after they are created or inserted.
We can able to use directly class objects in a class decorator to manage instead of instance calls–by using nearly the same syntax and very similar coding patterns to increase/modify a class with new methods. And class decorators are strongly related to function decorators, but somewhere logic differs.
Syntax:
Syntactically, class decorators appear just before class statements.
@decorator
class Class_Name:
...
inst = Class_Name(50)
This part of the code is equivalent to
class Class_Name:
...
Class_Name = decorator(Class_Name)
inst = Class_Name(50);
# decorator accepts a class as
# a parameter
def decorator(cls):
class Wrapper:
def __init__(self, x):
self.wrap = cls(x)
def get_name(self):
# fetches the name attribute
return self.wrap.name
return Wrapper
@decorator
class C:
def __init__(self, y):
self.name = y
# its equivalent to saying
# C = decorator(C)
x = C("test")
print(x.get_name())
That’s how we can wrap the functions in python.