Ticket #10467: 10467attribute_lookup.patch

sage/structure/element.pyx

@@ -186 +186 @@
 from types import MethodType
 
 from sage.categories.category   import Category
-from sage.structure.parent      cimport Parent
-from sage.structure.parent      import is_extension_type
+from sage.structure.parent      cimport Parent, raise_attribute_error
+from sage.structure.parent      import is_extension_type, getattr_from_other_class
 from sage.misc.lazy_format      import LazyFormat
 
 # This classes uses element.pxd.  To add data members, you
@@ -272 +272 @@
         and ``cat.element_class``, in that order, for attribute
         lookup.
 
+        NOTE:
+
+        Attributes beginning with two underscores but not ending with
+        an unnderscore are considered private and are thus exempted
+        from the lookup in ``cat.element_class``.
+
         EXAMPLES:
 
         We test that ``1`` (an instance of the extension type
@@ -301 +307 @@
             Traceback (most recent call last):
             ...
             AttributeError: 'LeftZeroSemigroup_with_category.element_class' object has no attribute 'blah_blah'
+
+        We test that "private" attributes are not requested from the element class
+        of the category (trac ticket #10467)::
+
+            sage: C = CommutativeRings()
+            sage: P.<x> = QQ[]
+            sage: C.element_class.__foo = 'bar'
+            sage: x.parent().category() is C
+            True
+            sage: x.__foo
+            Traceback (most recent call last):
+            ...
+            AttributeError: 'sage.rings.polynomial.polynomial_rational_flint.Polynomial_rational_flint' object has no attribute '__foo'
+
         """
-        from sage.structure.parent import getattr_from_other_class
+        if name.startswith('__') and not name.endswith('_'):
+            raise_attribute_error(self, name)
         return getattr_from_other_class(self, self.parent().category().element_class, name)
 
     def __dir__(self):

sage/structure/parent.pxd

@@ -9 +9 @@
 #cimport sage.categories.object
 cimport sage.structure.category_object
 
+cdef inline raise_attribute_error(self, name)
 
 cdef class Parent(category_object.CategoryObject):
 

sage/structure/parent.pyx

@@ -87 +87 @@
 cdef inline parent_c(x):
     if PY_TYPE_CHECK(x, element.Element):
         return (<element.Element>x)._parent
-    elif hasattr(x, 'parent'):
-        return x.parent()
+#    elif hasattr(x, 'parent'):
+#        return x.parent()
+#    else:
+#        return <object>PY_TYPE(x)
     else:
-        return <object>PY_TYPE(x)
+        try:
+            return x.parent()
+        except AttributeError:
+            return <object>PY_TYPE(x)
 
 cdef _record_exception():
     from element import get_coercion_model
@@ -150 +155 @@
     pass
 methodwrapper = type(A.__call__)
 
-def raise_attribute_error(self, name):
+cdef inline raise_attribute_error(self, name):
     """
     Tries to emulate the standard Python AttributeError exception
 
     EXAMPLES::
 
-        sage: sage.structure.parent.raise_attribute_error(1, "bla")
+        sage: 1.bla  #indirect doctest
         Traceback (most recent call last):
         ...
         AttributeError: 'sage.rings.integer.Integer' object has no attribute 'bla'
-        sage: sage.structure.parent.raise_attribute_error(QQ[x].gen(), "bla")
+        sage: QQ[x].gen().bla
         Traceback (most recent call last):
         ...
         AttributeError: 'sage.rings.polynomial.polynomial_rational_flint.Polynomial_rational_flint' object has no attribute 'bla'
@@ -272 +277 @@
         raise_attribute_error(self, name)
     if isinstance(attribute, methodwrapper):
         raise_attribute_error(self, name)
-    if hasattr(attribute, "__get__"):
-        # Conditionally defined lazy_attributes don't work well with fake subclasses
-        # (a TypeError is raised if the lazy attribute is not defined)
-        # For the moment, we ignore that when this occurs
-        # Other descriptors (including __weakref__) also break.
-        try:
-            return attribute.__get__(self, cls)
-        except TypeError:
-            raise_attribute_error(self, name)
-    else:
+    try:
+        getter = attribute.__get__
+    except AttributeError:
         return attribute
+    # Conditionally defined lazy_attributes don't work well with fake subclasses
+    # (a TypeError is raised if the lazy attribute is not defined)
+    # For the moment, we ignore that when this occurs
+    # Other descriptors (including __weakref__) also break.
+    try:
+        return getter(self, cls)
+    except TypeError:
+        pass
+    raise_attribute_error(self, name)
 
 def dir_with_other_class(self, cls):
     """
@@ -500 +507 @@
            self.element_class = dynamic_class("%s.element_class"%self.__class__.__name__, (category.element_class,), self.Element)
          - This should lookup for Element classes in all super classes
         """
-        if hasattr(self, 'Element'):
+        try: #if hasattr(self, 'Element'):
             return self.__make_element_class__(self.Element, "%s.element_class"%self.__class__.__name__)
-        else:
+        except AttributeError: #else:
             return NotImplemented
 
 
@@ -536 +543 @@
             sage: k = GF(5); k._element_constructor # indirect doctest
             <bound method FiniteField_prime_modn_with_category._element_constructor_ of Finite Field of size 5>
         """
-        if hasattr(self, '_element_constructor_'):
-            assert callable(self._element_constructor_)
-            self._element_constructor = self._element_constructor_
-            self._element_init_pass_parent = guess_pass_parent(self, self._element_constructor)
+        try: #if hasattr(self, '_element_constructor_'):
+            _element_constructor_ = self._element_constructor_
+        except (AttributeError, TypeError):
+            # Remark: A TypeError can actually occur;
+            # it is a possible reason for "hasattr" to return False
+            return
+        assert callable(_element_constructor_)
+        self._element_constructor = _element_constructor_
+        self._element_init_pass_parent = guess_pass_parent(self, self._element_constructor)
 
     def category(self):
         """
@@ -664 +676 @@
         ``self`` being an instance of both ``Parent`` and
         ``cat.parent_class``, in that order, for attribute lookup.
 
+        NOTE:
+
+        Attributes beginning with two underscores but not ending with
+        an unnderscore are considered private and are thus exempted
+        from the lookup in ``cat.parent_class``.
+
         EXAMPLES:
 
         We test that ZZ (an extension type) inherits the methods from
@@ -698 +716 @@
             Traceback (most recent call last):
             ...
             AttributeError: 'PrimeNumbers_with_category' object has no attribute 'sadfasdf'
+
+        TESTS::
+
+        We test that "private" attributes are not requested from the element class
+        of the category (trac ticket #10467)::
+
+            sage: P = Parent(QQ, category=CommutativeRings())
+            sage: P.category().parent_class.__foo = 'bar'
+            sage: P.__foo
+            Traceback (most recent call last):
+            ...
+            AttributeError: 'sage.structure.parent.Parent' object has no attribute '__foo'
+
         """
+        if name.startswith('__') and not name.endswith('_'):
+            raise_attribute_error(self, name)
         if self._is_category_initialized():
             return getattr_from_other_class(self, self.category().parent_class, name)
         else:

sage/structure/sage_object.pyx

@@ -79 +79 @@
            ``cdef public __custom_name`` attribute.
         """
         if x is None:
-            if hasattr(self, '__custom_name'):
-                self.reset_name()
+            #if hasattr(self, '__custom_name'):
+            # that's tested in reset_name anyway...
+            self.reset_name()
         else:
             try:
                 self.__custom_name = str(x)
@@ -88 +89 @@
                 raise NotImplementedError, "object does not support renaming: %s"%self
 
     def reset_name(self):
+        """
+        Remove the custrom name of an object.
+
+        EXAMPLES::
+
+            sage: P.<x> = QQ[]
+            sage: P
+            Univariate Polynomial Ring in x over Rational Field
+            sage: P.rename('A polynomial ring')
+            sage: P
+            A polynomial ring
+            sage: P.reset_name()
+            sage: P
+            Univariate Polynomial Ring in x over Rational Field
+        """
         if hasattr(self, '__custom_name'):
             del self.__custom_name
         
 
     def __repr__(self):
-        if hasattr(self, '__custom_name'):
+        """
+        Default method for string representation.
+
+        NOTE:
+
+        Do not overwrite this method. Instead, implement
+        a ``_repr_`` (single underscore) method.
+
+        EXAMPLES:
+
+        By default, the string representation coincides with
+        the output of the single underscore ``_repr_``::
+
+            sage: P.<x> = QQ[]
+            sage: repr(P) == P._repr_()  #indirect doctest
+            True
+
+        Using :meth:`rename`, the string representation can
+        be customized::
+
+            sage: P.rename('A polynomial ring')
+            sage: repr(P) == P._repr_()
+            False
+
+        The original behaviour is restored with :meth:`reset_name`.
+
+            sage: P.reset_name()
+            sage: repr(P) == P._repr_()
+            True
+        """
+        try:
             name = self.__custom_name
             if name is not None:
                 return name
-        if hasattr(self, '_repr_'):
+        except:
+            pass
+        try:
             return self._repr_()
-        return str(type(self))
+        except AttributeError:
+            return str(type(self))
 
     def __hash__(self):
         return hash(self.__repr__())
@@ -375 +424 @@
             except (KeyError, ValueError):
                 pass
         nm = I.name()
-        if hasattr(self, '_%s_init_'%nm):
+        try:
             s = self.__getattribute__('_%s_init_'%nm)()
-        else:
+        except AttributeError:
             try:
               s = self._interface_init_(I)
             except: