{"__type": "EVENT_JOB_NEW", "__jobid": 123, "__time": 123213213, ...}
{"__type": "EVENT_JOB_ACCEPT", "__jobid": 123, "__time": 123214322, ...}
{"__type": "EVENT_JOB_START", "__jobid": 123, "__time": 123213346436, ...}
{"__type": "EVENT_JOB_DISPATCH", "__jobid": 123, "__time": 1232125332, ...}
{"__type": "EVENT_JOB_FINISH", "__jobid": 123, "__time": 1232135463, ...}

{"__type": "JOB_INFO_BLEH", "__jobid": 123, "__time": 123213213, ...}
{"__type": "JOB_INFO_BLUB", "__jobid": 123, "__time": 123214322, ...}

| Variable_name            | Value   |
+--------------------------+---------+
| character_set_client     | cp850   |
| character_set_connection | cp850   |
| character_set_database   | utf8mb4 |
| character_set_filesystem | binary  |
| character_set_results    | cp850   |
| character_set_server     | utf8mb4 |
| character_set_system     | utf8    |

+--------------------------+---------+
| Variable_name            | Value   |
+--------------------------+---------+
| character_set_client     | utf8    |
| character_set_connection | utf8    |
| character_set_database   | utf8mb4 |
| character_set_filesystem | binary  |
| character_set_results    | utf8    |
| character_set_server     | utf8mb4 |
| character_set_system     | utf8    |
+--------------------------+---------+

init-connect ='SET NAMES utf8'
character-set-server = utf8
collation-server = utf8_general_ci

[client]
default-character-set = utf8

[mysqldump]
default-character-set = utf8

[mysql]
default-character-set = utf8

class Param:
    def bleh(self):
        # How to get f of outermost class?
        pass 

class A:
    p = Param()

class B(A):
    f = 1

class C(A):
    f = 2

b = B()
b.p.bleh()

class Param:
    def __init__(self, *args, **kwargs):
        self._args = args
        self._kwargs = dict(kwargs)

        self.pos = args[0]
        self.arg = kwargs.pop('arg')

class MC(type):
    def __new__(cls, clsname, bases, attrs):
        new_attrs = {}
        new_fields = {}

        for field_name, field in attrs.items():
            if issubclass(type(field), Param):
                new_fields[field_name] = field
            else:
                new_attrs[field_name] = field

        for b in bases:
            for name, field in getattr(b, '_fields', {}).items():
                new_fields[name] = field.__class__(*field._args, **field._kwargs)
            
        newclass = super().__new__(cls, clsname, bases, new_attrs)
        
        setattr(newclass, '_fields', new_fields)

        newclass._init_fields()

        return newclass

class A(metaclass=MC):
    p1 = Param('pos1', arg='123')
    p2 = Param('pos2', arg='345')

    @classmethod
    def _init_fields(Cls):
        pass

    def __getattr__(self, name):
        if name in self._fields:
            return self._fields[name]

class B(A):
    f = 1

    @classmethod
    def _init_fields(Cls):
        Cls._fields['p1'].arg = Cls.f

class C(A):
    f = 2

    @classmethod
    def _init_fields(Cls):
        Cls._fields['p1'].arg = Cls.f

b = B()
c = C()
print(b.p1.arg)
print(c.p1.arg)

class ContextForwarder:
    # On the way down: Add call context
    def __getattribute__(self, name):
        if name == "_call_context":
            return object.__getattribute__(self, name)

        inner = object.__getattribute__(self, name)
        if isinstance(inner, ContextForwarder):
            inner._call_context = self
        return inner

    # On the way up: Search context if not resolvable locally
    def __getattr__(self, name):
        if name == "_call_context":
            raise AttributeError

        return getattr(self._call_context, name)


class Param(ContextForwarder):
    def bleh(self):
        print(self.y, self.f)
        try:
            print(self.g)
        except AttributeError:
            print("g raises an AttributeError")


class A(ContextForwarder):
    p = Param()
    y = "y"


class B(A):
    f = 1


class C(A):
    f = 2


class D(C):
    f = 3


class E(D):
    g = 4


class F(ContextForwarder):
    g = 5
    b = B()


b = B()
c = C()
d = D()
e = E()
f = F()
b.p.bleh()
c.p.bleh()
d.p.bleh()
e.p.bleh()
f.b.p.bleh()


--- Output:


y 1
g raises an AttributeError
y 2
g raises an AttributeError
y 3
g raises an AttributeError
y 3
4
y 1
5

class Context(ContextForwarder):
    def __init__(self, context=None):
        if context is not None:
            self.into = context


class FirstContext(Context):
    database = {
        'a': 'First A',
        'b': 'First B',
    }

    def output(self, string):
        print ('First:', string)


class SecondContext(Context):
    database = {
        'a': 'Second A',
        'b': 'Second B',
    }

    def output(self, string):
        print ('Second:', string)


class ClientCode(Context):
    def output_from_database(self):
        print('This is client code!')
        self.output(self.database['a'])
        self.output(self.database['b'])


client_code = ClientCode()
first_context = FirstContext(client_code)
second_context = SecondContext(client_code)


try:
    client_code.output_from_database()
except AttributeError:
    print('Cannot work, no dependencies injected!')


first_context.into
client_code.output_from_database()

second_context.into
client_code.output_from_database()


--- Output:
This is client code!
Cannot work, no dependencies injected!
This is client code!
First: First A
First: First B
This is client code!
Second: Second A
Second: Second B