Get variables of object necessary to recreate object with __init__

How do I get variables of object that are necessary to recreate object with __init__ python?

I have a class:

class example:
    def __init__(self, z, x=1):
        self.z = z
        self.x = x
        self.y = 0

    def change_y(self, y):
        self.y = y

    def calculate(self):
        return self.y*self.x*self.z

I want the variables required to recreate this class, in this case it is x and z. Using pickle.dumps() or vars() then json.dumps() gives the unnecessary y variable as well (I don't care about y because it isn't involved in creating the class, it is to me considered 'temporary').

Without changing the class in any way how can I get the variables defined(or could be defined, in the case of x) by the __init__ parameters.

Here is the testing code:

class Example:
    def __init__(self, z, x=1):
        self.z = z
        self.x = x
        self.y = 0

    def change_y(self, y):
        self.y = y

    def calculate(self):
        return self.y*self.x*self.z

e1 = Example(5)
e2 = Example(3, 2)

e1.change_y(4)
e2.change_y(1)

e1_data = magic_get_data(e1) # returns a dict with "var":value
e2_data = magic_get_data(e2)

e3 = magic_make_from_data(Example, e1_data) # e3.__dict__ == Example(5).__dict__ needs to be True
e4 = magic_make_from_data(Example, e2_data) # e4.__dict__ == Example(3, 2).__dict__ needs to be True 

print(e3.__dict__ == Example(5).__dict__)
print(e4.__dict__ == Example(3, 2).__dict__)

Should output:

True
True

If all parameters to the constructor are stored in attributes with the same name (ie: the x parameter is stored in self.x, just like in your example), then you can use the built-in inspect module to get the signature of the class' constructor. From there, you can get the value of all those attributes. Just like this:

def magic_get_data(obj):
    sig = [param[0] for param in inspect.signature(obj.__class__).parameters]
    return {param: obj.__dict__[param] for param in sig}


def magic_make_from_data(c, data):
    return c(**data)

Without changing the class, presumably because you don't own the code, you can patch the class' __init__ method with a wrapper that stores the arguments used to create an instance in a dict that maps the instance to the arguments:

class track_init:
    def __init__(self):
        self.args_of_instance = {}

    def __call__(self, cls):
        def __init__(this, *args, **kwargs):
            self.args_of_instance[this] = {'args': args, 'kwargs': kwargs}
            orig_init(this, *args, **kwargs)

        orig_init = cls.__init__
        cls.__init__ = __init__
        return cls

so that:

class Example:
    def __init__(self, z, x=1):
        self.z = z
        self.x = x
        self.y = 0

    def change_y(self, y):
        self.y = y

    def calculate(self):
        return self.y*self.x*self.z

track_examples = track_init()
Example = track_examples(Example)

magic_get_data = track_examples.args_of_instance.get
magic_make_from_data = lambda data: Example(*data['args'], **data['kwargs'])

e1 = Example(5)
e2 = Example(3, 2)

e1.change_y(4)
e2.change_y(1)

e1_data = magic_get_data(e1)
e2_data = magic_get_data(e2)

e3 = magic_make_from_data(e1_data)
e4 = magic_make_from_data(e2_data)

print(e3.__dict__ == Example(5).__dict__)
print(e4.__dict__ == Example(3, 2).__dict__)

would output:

True
True

Demo: https://replit.com/@blhsing/FormalHatefulAfkgaming

From what I've read of your comments and original question, I don't think your problem is solvable in the way you envision it. I gather that you want these constraints:

1. You want to extract data from an object, but without that object's class participation (e.g. by defining a serialize method of some sort)
   • "I want it to work for any class this method is used on"
   • Without an object's cooperation, all your really know about it is its instance variables, and the parameters to its initializer
2. You want to be able to instantiate a new object from that extracted data, but without the object's class participation (e.g. by defining a deserialize method of some sort)
   • Without an object's cooperation, all you can rely on is calling its __init__ method.
   • (Assigning to the objects __dict__ is possible, but super broken in the general case, because it circumvents the class's __init__

Your problem is simple/easy in cases like your class example, whose __init__ params correspond (mostly) 1-to-1 with the instance variables of its objects. Fundamentally, the issue is that objects aren't just grab-bags of instance variables. Ivars are (mostly) encapsulated implementation details, that exist only in the service of the public instance methods that make up the object's API. This is how they differ from normal ol' dicts.

Consider this example:

class CounterExample:
  def __init__(self, x):
    self.y = x

You can do all sorts of tricks to list the parameters of CounterExample's __init__ (to know it has an x parameter), and access an object's __dict__ ( to know it has a y ivar), and so on, but none of it fundamentally helps. There is no way your code could possibly know that the parameter x gets assigned to the ivar y.

The conclusion here is that you will always have edge cases, which require one of these compromises:

1. You read/write object's __dict__s, and bypass their __init__
   • This super-duper breaks classes that aren't dumb dict-like bags of values
2. You limit what kinds of objects you can support (e.g. only those whose initializer parameter names correspond 1:1 to instance variable names)
   • Even still, you'll see all kinds of bugs here. It's wrong to assume that a param x just end up only being used as self.x = x.
3. You require the class authors' cooperation, by giving them hooks that let them control how their objects are serialized/deserialized
   • In practice, this is what you see pretty much ever serialization library (e.g. pickle) does.