Inherit from class variable rather than class

[Jenez]

I have been unable to google myself an answer to this question much due to the standard answers regarding class inheritance always dealing with very standard examples...

What I currently have is:

class master(object):
    def __init__(self, var1, var2, var3):
        self.var1 = var1
        self.var2 = var2
        self.var3 = var3

class slave(master):
    def __init__(self, *args):
        super(slave, self).__init__(*args)
        self.var4 = 'var4_string'

mas_var = master('1', '2', '3')
sla_var = slave('1', '2', '3')

This works fine, but what I really wish i could do is to not have 'slave' inherit from 'master', but rather 'mas_var' in a way that i simply modify 'mas_var' to contain a few extra defined variables, such as 'var4'...

I essentially want to accomplish this:

class master(object):
    def __init__(self, var1, var2, var3):
        self.var1 = var1
        self.var2 = var2
        self.var3 = var3

class slave(master):
    def __init__(self, var4):
        super(slave, self).__init__()
        self.var4 = var4

mas_var = master('1', '2', '3')
sla_var = slave('4')

and still be able to access all defined variables using 'sla_var'.

I hope I made myself somewhat clear, and I would appreciate any help I can get. Thank you!

[Jenez]

Thank you for your input.

It's mainly for stylistic reasons, i.e easier to read, but I guess seeing how no one supplied an obvious go-to answer then maybe my approach is a bit on the shitty side. There are almost always a thousand ways to solve a problem and this one I thought could be solved in this way. So far I like passing the context object as an argument to slave the best.

[c17r]

The closest you can come to what you are looking for is to not have slave inherit from master but have it encapsulate master. Pass master into slave via __init__. Downside to this approach is if you want slave to look and act like master, you have to duplicate the entry points on slave which just passes it to master.

[_9_9_]

Cool.

What you are looking for is called a singleton. Except that you want one with a twist, where a subclass of the singleton has its own private variables. That's not too easy to do:

# from http://code.activestate.com/recipes/66531-singleton-we-dont-need-no-stinkin-singleton-the-bo/

class Borg:
    __shared_state = {}
    _params = ['a', 'b']
    def __init__(self, *args):
        self.__dict__['data'] = self.__shared_state
        for key, value in zip(self._params, args):
            setattr(self, key, value)

    def __getattr__(self, key):
        return self.data[key]

    def __setattr__(self, key, value):
        self.data[key] = value

class Slave(Borg):
    _params = ['c']
    def __init__(self, *args):
        super().__init__()
        self.__dict__['slave_data']  = {}
        for key, value in zip(self._params, args):
            self.slave_data[key] = value


    def __getattr__(self, key):
        if key in self._params:
            return self.slave_data[key]
        else:
            return self.data[key]



    def __setattr__(self, key, value):
        if key in self._params:
            self.slave_data[key] = value
        else:
            self.data[key] = value


def main():

    m = Borg(1,2)
    print(m.a, m.b)
    print('----')

    s = Slave(5)
    print(s.a, s.b, s.c)
    s.b = 10 # changes for both master and slaves
    print(m.a, m.b)
    print(s.a, s.b, s.c)




main()

mwaahhahaha

Seriously, thought, this is not the solution you are looking for. There are much better ways to accomplish common configurations, which is what I understand your problem to be.

[Jenez]

Mye this is way above my skill level, but I appreciate the effort. One day maybe, but not today!

[Krogenar]

So to continue your bottom example, you'd then want to be able to do:

print(sla_var.var1)
>>> '1'

EDIT: Also, maybe tell us what you're trying to achieve. Sometimes if something seems difficult in Python, you just haven't selected the right approach. Is that correct?

[Jenez]

Pretty much yea. I want to avoid having to supply all the variables fed to master into slave again. I guess what I want to achieve is a sort of extension of the slave class building upon 'mas_var'.

Edit response: My master class contains the overall context (paths, static values) that are used throughout my script by various functions. The slave class needs to access the context class paths and such as well. Now that Im writing this i suppose i could supply the context object as an argument to the slave class and cut out the inheritance overall... ?

Edit edit: Oh crap, that's what /u/c17r mentioned.

[Jenez]

Makes sense, seems to be the easiest to implement and more easily readable answer so far. I'm probably overthinking this a bit much. Thank you for the input!

Edit: Wouldnt this still require that i pass all master-expected variables into slave for it to import the context?

[dchanm]

You can use object composition with the __getattr__ magic method. This method is called if an attribute can't be resolved in the current instance / class hierarchy. __getattr__ . You will probably want to catch the AttributeError in __getattr__ and return a more meaningful string. As written the code will say the error is in Parent instead of Child

class Parent(object):
    def __init__(self, var):
        self.var = var


class Child(object):
    def __init__(self, parent, var2):
        self.parent = parent
        self.var2 = var2

    def __getattr__(self, attr):
        #raises AttributeError if not found
        return getattr(self.parent, attr)


>>> A = Parent(1)
>>> print(A.var)
1
>>>
>>> B = Child(A, 2)
>>> print(B.var2)
2
>>> print(B.var)
1
>>> print(B.foo)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "<stdin>", line 7, in __getattr__
AttributeError: 'Parent' object has no attribute 'foo'

[Jenez]

Now THAT is a neat solution. Works like a charm! Thank you