Chart: WIP getstate/setstate, no UniqueRepresentation

Author: Matthias Koeppe

src/sage/manifolds/chart.py

@@ -43,13 +43,15 @@
 from sage.rings.infinity import Infinity
 from sage.misc.latex import latex
 from sage.misc.decorators import options
+from sage.misc.cachefunc import cached_method
+from sage.misc.inherit_comparison import InheritComparisonClasscallMetaclass
 from sage.manifolds.chart_func import ChartFunctionRing
 from sage.manifolds.calculus_method import CalculusMethod
 from sage.symbolic.expression import Expression
 from sage.ext.fast_callable import fast_callable
 
 
-class Chart(UniqueRepresentation, SageObject):
+class Chart(SageObject, metaclass=InheritComparisonClasscallMetaclass):
     r"""
     Chart on a topological manifold.
 
@@ -288,8 +290,8 @@ def __classcall__(cls, domain, coordinates='',
         try:
             return domain._charts_by_coord[coord_string]
         except KeyError:
-            self = super().__classcall__(cls, domain, coordinates,
-                                         calc_method, **coordinate_options)
+            self = type.__call__(cls, domain, coordinates,
+                                 calc_method, **coordinate_options)
             domain._charts_by_coord[coord_string] = self
             return self
 
@@ -441,6 +443,50 @@ def _parse_coordinates(cls, domain, coordinates):
             period_list.append(period)
         return tuple(xx_list), dict(periods=tuple(period_list))
 
+    def __hash__(self):
+        try:
+            return self._hash
+        except AttributeError:
+            # Do not hash the domain because it owns self
+            # Do not hash sheafy attributes: _subcharts, _supercharts, _dom_restrict
+            self._hash = hash((self._domain._name, self._sindex,
+                               ## _calc_method is not hashable
+                               #self._calc_method,
+                               self._xx,
+                               tuple(self._periods.items()),
+                               repr(self._restrictions), # hash the string of the unhashable
+                               ))
+            return self._hash
+
+    def _non_sheafy_attributes(self):
+        for key, value in self.__dict__.items():
+            if key not in ('_subcharts', '_supercharts', '_dom_restrict',
+                           # also ignore these ones
+                           '_calc_method', 'simplify'):
+                yield key, value
+
+    def __eq__(self, other):
+        if self is other:
+            return True
+        if type(self) != type(other):
+            return False
+        if self._xx != other._xx:
+            return False
+        return dict(self._non_sheafy_attributes()) == dict(other._non_sheafy_attributes())
+
+    def __ne__(self, other):
+        return not (self == other)
+
+    def __setstate__(self, d):
+        self.__dict__.update(d)
+        # Following is shared with __init__; could also go in a __new__ method
+        self._subcharts = set([self])
+        self._supercharts = set([self])
+
+
+    def __getstate__(self):
+        return dict(self._non_sheafy_attributes())
+
     def _repr_(self):
         r"""
         String representation of the object.
@@ -1072,6 +1118,7 @@ def transition_map(self, other, transformations, intersection_name=None,
                 transformations = [transformations]
         return CoordChange(chart1, chart2, *transformations)
 
+    @cached_method(key=id)
     def function_ring(self):
         """
         Return the ring of coordinate functions on ``self``.

src/sage/manifolds/chart_func.py

@@ -36,7 +36,6 @@
 from sage.structure.element import AlgebraElement, ModuleElementWithMutability
 from sage.structure.parent import Parent
 from sage.structure.sage_object import SageObject
-from sage.structure.unique_representation import UniqueRepresentation
 from sage.categories.commutative_algebras import CommutativeAlgebras
 from sage.manifolds.utilities import ExpressionNice
 from sage.misc.cachefunc import cached_method
@@ -2641,7 +2640,7 @@ def collect_common_factors(self):
         self._del_derived()
         return self
 
-class ChartFunctionRing(Parent, UniqueRepresentation):
+class ChartFunctionRing(Parent):
     """
     Ring of all chart functions on a chart.
 

src/sage/manifolds/differentiable/chart.py

@@ -282,6 +282,22 @@ def __init__(self, domain, coordinates, calc_method=None, periods=None):
         self._frame = CoordFrame(self)
         self._coframe = self._frame._coframe
 
+    def __getstate__(self):
+        d = super().__getstate__().copy()
+        # These are keyed to self via UniqueRepresentation
+        try:
+            del d['_frame']
+        except KeyError:
+            pass
+        del d['_coframe']
+        return d
+
+    def __setstate__(self, d):
+        super().__setstate__(d)
+        # Reconstruct the coordinate frame associated to the chart:
+        self._frame = CoordFrame(self)
+        self._coframe = self._frame._coframe
+
     def transition_map(self, other, transformations, intersection_name=None,
                        restrictions1=None, restrictions2=None):
         r"""
@@ -1189,7 +1205,7 @@ def jacobian(self):
         """
         return self._jacobian  # has been computed in __init__
 
-    @cached_method
+    @cached_method(key=id, do_pickle=True)
     def jacobian_det(self):
         r"""
         Return the Jacobian determinant of ``self``.

src/sage/manifolds/scalarfield_algebra.py

@@ -39,7 +39,7 @@
 from sage.symbolic.ring import SR
 from sage.manifolds.scalarfield import ScalarField
 
-class ScalarFieldAlgebra(UniqueRepresentation, Parent):
+class ScalarFieldAlgebra(Parent):
     r"""
     Commutative algebra of scalar fields on a topological manifold.