I think this is related to how pickle works: https://docs.python.org/3/library/pickle.html#pickling-class-instances

By default, pickle will retrieve the class and the attributes of an instance via introspection.

Pickle cannot introspect the generated code from Python. Maybe try defining __getnewargs_ex__ or __getnewargs__?

This seems to work. Currently I can't return () but I if there are class arguments then the following works:

# pickling_kers.py
class Person:
    def __init__(self, x : int):
        self.x = x

    def __getnewargs__(self):
        return (self.x,)

import pickle
import os
from pickling_kers import Person

person = Person(2)

with open(os.path.join(os.getcwd(), "person.bin"), 'wb') as f:
    pickle.dump(person, f, pickle.HIGHEST_PROTOCOL)

Thanks @EmilyBourne - that helps! However, another problem seems to be that the pyccelized class does not have a __dict__, which hinders the restoring of the object via introspection. For instance:

import pickle
import os
from pickling_kers import Person

person = Person(3)
print(f"{person.x = }")
try:
    print(f"{person.__dict__ = }")
except:
    print(f"{person} has no __dict__")

with open(os.path.join(os.getcwd(), "person.bin"), 'wb') as f:
    pickle.dump(person, f, pickle.HIGHEST_PROTOCOL)
    
with open(os.path.join(os.getcwd(), "person.bin"), 'rb') as f:
    person_reloaded: Person = pickle.load(f)
    
print(f"{person_reloaded.x = }")
print(f"{person_reloaded.__dict__ = }")

yields

person.x = 3
<pickling_kers.Person object at 0x75b3d1a4cc00> has no __dict__
person_reloaded.x = 129415187020624
Traceback (most recent call last):
  File "/home/IPP-AD/spossann/git_repos/struphy/pickling.py", line 19, in <module>
    print(f"{person_reloaded.__dict__ = }")
             ^^^^^^^^^^^^^^^^^^^^^^^^
AttributeError: 'pickling_kers.Person' object has no attribute '__dict__'. Did you mean: '__dir__'?

I tried to add __dict__ to the class:

# pickling_kers.py
class Person:
    def __init__(self, x : int):
        self.x = x

    def __getnewargs__(self):
        return (self.x,)
    
    @property
    def __dict__(self):
        dct = dict(x=self.x)
        return dct

but it doesn't seem to compile for me. I am not really sure how to use dicts though with pyccel.

However, another problem seems to be that the pyccelized class does not have a __dict__, which hinders the restoring of the object via introspection.

This is expected for a class found in an external library. It is not be possible to use __dict__ here. This is to do with how __dict__ works and how Pyccel interfaces with the C class.

In Python, each object normally has a __dict__, which is just a dictionary mapping attribute names to their values. When you access obj.attr, Python first looks up attr in this dictionary (unless descriptors, __getattr__, or properties are involved). This makes __dict__ useful for introspection, because pickle can just copy it to serialise an object. Then to recreate the class it sets this internal dictionary and relies on this look-up order to ensure that Python will find the expected objects.

However, __dict__ is a purely Python-side mechanism. It doesn’t invoke getters, setters, or property methods; it only reflects the raw attribute store. For class members exposed via a C API, attributes are not saved as raw Python objects. Instead they are accessed via custom getter/setter functions which ensure the value in the underlying C class is used. Exposing a __dict__ would therefore modify the values seen on the Python side, but not their values inside the C class. That’s why pickle cannot rely on __dict__ for classes translated to C: the mapping between attributes and underlying data is lost.

Classes without a __dict__ are fairly common in code that has been modified for performance. E.g. in Pyccel we use __slots__ which means we don't have a __dict__ for our Python-only classes.

__getnewargs__ which outputs the arguments that should be passed to the constructor in order to create an identical instance of the class is the standard way to handle this. Pickle caches the output of __getnewargs__ and then passes these cached values to the constructor when it unpickles.

Python based example

If we look at this with the example:

# pickling_kers.py
class Person:
    def __init__(self, x : int):
        self.x = x

    def print_x(self):
        print(self.x)

is effectively translated to:

# pickling_kers.py
class Person:
    def __init__(self, x : int):
        self._c_x = x

    @property
    def x(self):
        self._c_x

    @x.setter
    def x(self, x : int):
        self._c_x = x

    def print_x(self):
        print(self._c_x)

where self._c_x is a C object of which Python has no knowledge. And recreating via pickle would be equivalent to calling p.__dict__.update(x=cached_x_value) where p is the instance of Person being built.
As we can see this doesn't affect the behaviour of Person in the way you would like it to:

>>> p = Person(5)
>>> p.__dict__
{'_x': 5}
>>> p.x # Calls the getter
5
>>> p.__dict__.update(x=3)
>>> p.__dict__
{'_x': 5, 'x': 3}
>>> p.x # Calls the getter
5
>>> p.x = 6 # Calls the setter
>>> p.__dict__
{'_x': 6, 'x': 3}
>>> p.x # Calls the getter
6