properties.copy() with an Instance Property

[lheagy]

When a HasProperties instance is copied, if it has a properties.Instance it looks like the class is being assigned based on the instance_class rather than the __class__ (https://github.com/lheagy/casingSimulations/blob/master/casingSimulations/mesh.py#L44) is being assigned rather than the

[fwkoch]

@lheagy - Sorry to be slow getting back here. The reason for this is because deserialize (which is used by copy) by default does not trust the input JSON, so it uses instance_class to reconstruct the class rather than the __class__ saved to the dictionary. You can override this behavior by passing kwarg trusted=True into deserialize or copy... So right away, this should work for you:

mesh2D = cylMeshGen.copy(trusted=True)

Now, I think trusted should default to True with copy... possibly that should be the case for deserialize as well.

[bsmithyman]

Hey @lheagy :)
Just had a quick offline chat with @fwkoch about this. I think we can change the default for the .copy(...) action without too much trouble. I think that should fix the issue you're seeing.

As he said, the default behaviour for the underlying .deserialize(...) is to be un-trusted; reasoning is that if you're deserializing JSON you get from someone, you only want to trust it (give it access to run code, essentially) if you do so explicitly. The .copy(...) case is the opposite; this is already in the memory space of your application, so there's no reason not to default to trusted, or at least the default should be different.

Should be a one-word change in the source to go with the new default, so most of the work will just be in keeping other stakeholders in the loop in case there's anything depending on the previous behaviour.

@lheagy: Is that good from your POV? Any other thoughts?

[fwkoch]

Thanks @bsmithyman

This is addressed here: #184

I have trouble seeing the use case for ever making an "untrusted" copy, so I don't expose it as an explicit kwarg to copy. But it can still be overridden if someone really wants.