I’m going to propose something even simpler than using a decorator or template method or anything like that: def render_sidebar_template(tmpl_name, **kwargs): (var1, var2, var3) = generate_sidebar_data() return render_template(tmpl_name, var1=var1, var2=var2, var3=var3, **kwargs) Yup, just a function. That’s all you really need, isn’t it? See this Flask Snippet for inspiration. It’s essentially doing exactly the same … Read more
Metaclasses are indispensable if you want to have class objects (as opposed to instances of class objects) equipped with “special customized behavior”, since an object’s behavior depends on special methods on the type of the object, and a class object’s type is, exactly a synonym for, the metaclass. For example, if you want a class … Read more
You imported sqrt into your module, just apply the decorator there in your own global namespace: sqrt = print_args_decor(sqrt) This sets the name sqrt in your module namespace to the result of the decorator. There is no requirement that sqrt was originally defined in this module. It is up to the decorator to uses the … Read more
Use WhenInjectedInto: Bind<IRepository>().To<MoreAdvancedRespository>() .WhenInjectedInto<TrickyRepository>(); Bind<IRepository>().To<SomeSimpleRepository>() .WhenInjectedInto<MoreAdvancedRespository>(); See this blog post for more info.
Any arg that was passed positionally will be passed to *args. And any arg passed as a keyword will be passed to **kwargs. If you have positional args values and names then you can do: kwargs.update(dict(zip(myfunc.func_code.co_varnames, args))) to convert them all into keyword args.
While it’s not strictly possible to do, as rightly pointed out, you could always “fake” it by redefining the method on instantiation, like this: class YourClass(object): def __init__(self): self.foo = self._instance_foo @staticmethod def foo(): print “Static!” def _instance_foo(self): print “Instance!” which would produce the desired result: >>> YourClass.foo() Static! >>> your_instance = YourClass() >>> your_instance.foo() … Read more
The Streams in Java – subclasses of InputStream and OutputStream are perfect examples of the decorator pattern. As an example, writing a file to disk: File toWriteTo = new File(“C:\\temp\\tempFile.txt”); OutputStream outputStream = new FileOutputStream(toWriteTo); outputStream.write(“Sample text”.getBytes()); Then should you require some extra functionality regarding the writing to disk: File toWriteTo = new File(“C:\\temp\\tempFile.txt”); OutputStream … Read more
Here’s another approach that eliminates the problem with conflicts between names of aliased methods (NOTE my other solution using modules for decoration is a good alternative too as it also avoids conflicts): module Documenter def document(func_name) old_method = instance_method(func_name) define_method(func_name) do |*args| puts “about to call #{func_name}(#{args.join(‘, ‘)})” old_method.bind(self).call(*args) end end end The above code … Read more
I would say AOP (Aspect Oriented Programming) is NOT a pattern by itself (and thus not a type of decorator pattern from my POV)… its implementation can be done via one or more patterns (including the use of decorator pattern)… AOP is a programming paradigm IMHO – other paradigms are for example OOP, functional programming … Read more