human
Give me a the Python program you requested given the following:
I found an interesting problem on https://www.codewars.com/kata/5f24315eff32c4002efcfc6a:
_yet another easy kata!_

_Bored of usual python katas? me too;_


## Overview

     As you have guessed from the title of the kata you are going to implement a class that supports ***function overloading***. You might be thinking python doesn't support that thing... Of course python doesn't support that! So you have to implement that missing functionality.

     To achieve that You have to implement the `Meta` class which will be the metaclass of `Overload` class (see sample tests) and class that use `Meta` should work as usual at other things.


## The Goal

```python
    
class Overload(metaclass=Meta):
    
    CLS_VAR = 42
    
    def __init__(self):
        self.a = 1
        self.no = 'This is "No parameter" function.'
        self.single = 'This is "Single parameter" function'
        self.two = 'This is "Two parameter" function'
        self.three = 'This is "Three parameter" function'

    def foo(self):
        return self.no

    def foo(self, x):
        return self.single + ':' + str(x)

    def foo(self, x, y):
        return self.two + ':' + str(x) + ',' + str(y)

    def foo(self, x, y, z):
        return self.three + ':' + str(x) + ',' + str(y) + ',' + str(z)
    
    def extra(self):
        return 'This is extra method.'
            
  

  obj = Overload()

  Overload.foo=lambda self,a,b,c,d: 'from outside!'

  obj.foo()            # 'This is "No parameter" function.'
  obj.foo(1, 2)        # 'This is "Two parameter" function:1,2'
  obj.foo(1, 2, 3)     # 'This is "Three parameter" function:1,2,3'
  obj.foo(1, 2, 3, 4)  # 'from outside!'
```


## Specifications
   
   * The Overload base class will always be the same as above. It will be regenerated different times in the tests, for testing purpose.
   * All the other methods will be added and tested **after instanciation** the class like shown in the example above (***Focus on this point.
you will need this***).
   * Only instance methods will be tested, no static or class level methods.
   * There is no testing for either `*varargs`...

I tried it in Python, but could not do it. Can you solve it?
assistant
#Here is the Python program you requested.

from collections import defaultdict
def setter(prep, k, v, sup):
    if callable(v):
        def wrap(*args):
            a = prep.d[k][len(args)]
            if isinstance(a, int): raise AttributeError()
            return a(*args)
        prep.d[k][v.__code__.co_argcount] = v
        v = wrap
    sup(k, v)
    
class Prep(dict):
    def __init__(self): self.d = defaultdict(lambda: defaultdict(int))
    def __setitem__(self,k,v): setter(self, k, v, super().__setitem__)

class Meta(type):
    @classmethod
    def __prepare__(cls, *args, **kwargs): return Prep()
    
    def __new__(metacls, name, bases, prep, **kwargs):
        prep['_Meta__DCT'] = prep
        return super().__new__(metacls, name, bases, prep, **kwargs)
    
    def __setattr__(self, k, v): setter(self.__DCT, k, v, super().__setattr__)