What do we want to do in the scenario that the other object doesn't have a _scope_id attribute? An AttributeError would not be particularly clear from a user perspective when comparing the equality of two different IPv6 address objects.

Returning False seems to make the most sense to me, but only in the scenario that self actually has a _scope_id that isn't None (since we already established that the addresses are equal at this point).

As I see it, IPv6Address object shall always have a _scope_id attribute. In case it is created from IPv6 address without scope id, the attribute would be set to None.
Case with absent _scope_id attribute could appear only if someone removes it explicitly.
May be, it would be ok to use public property scope_id in __eq__ method, and add try block to it?

    @property
    def scope_id(self):
        """Identifier of a particular zone of the address's scope.

        See RFC 4007 for details.

        Returns:
            A string identifying the zone of the address if specified, else None.

        """
        return getattr(self, '_scope_id', None)    

    def __eq__(self, other):
        address_equal = super().__eq__(other)
        if address_equal is NotImplemented:
            return NotImplemented
        if not address_equal:
            return False
        return self.scope_id == other.scope_id

@opavlyuk

As I see it, IPv6Address object shall always have a _scope_id attribute.
Case with absent _scope_id attribute could appear only if someone removes it explicitly.

If the object was instantiated from the version of the IPv6Address class in this PR (where _scope_id was just added), then yes. But if it's an object instantiated from an older version of the class or some other custom implementation, then _scope_id might not be present.

IMO, it seems worthwhile to provide some basic amount of compatibility with objects that don't have a _scope_id attribute, considering it is just being added now.

    @property
    def scope_id(self):
        return getattr(self, '_scope_id', None)    

    def __eq__(self, other):
        address_equal = super().__eq__(other)
        if address_equal is NotImplemented:
            return NotImplemented
        if not address_equal:
            return False
        return self.scope_id == other.scope_id

The above would only cover the situations in which the self object doesn't have a _scope_id, no? My concern is with the other object, as self is much more likely to have a _scope_id attribute in the first place. The above situation I was referring to was when other is an object that wasn't instantiated from this version of IPv6Address or is using some other implementation.

Also, in this case, I find the EAFP (try-except) approach in my above suggestion to be more explicit than LBYL (if hasattr() or getattr() with default). Mostly because the situation in which the other object does not have a _scope_id is an exception and not just a general conditional to check for.

A try-except is generally better performance wise (when in the vast majority of cases, the exception does not occur) in comparison to using getattr() with a default every single time the property is accessed or if hasattr() every time __eq__() is used.

What do you think @asvetlov?

@aeros , now I understood, and it makes sense.
At the same time, following seems more clean for me:

    def __eq__(self, other):
        address_equal = super().__eq__(other)
        if address_equal is NotImplemented:
            return NotImplemented
        if not address_equal:
            return False
        return self.scope_id == getattr(other, _'scope_id', None)

So, we consider, if other object has no _scope_id attribute, then it is the same as it is None.
Having measured the execution time on Python 3.7.4 on my GNU\Linux machine, I saw that option with getattr seems to be slightly faster in case when attribute exists and 5x faster in case with non-existent attribute.

I like the last version

I have no objections to the last version either, self.scope_id == getattr(other, _'scope_id', None) should work fine. My main issue with the first one was using return getattr(self, '_scope_id', None) as the getter for _scope_id, but that's not an issue in the most recent version.

Edit: I still think the EAFP approach might be a bit more idiomatic in this case. However, if it's a significant performance difference, getattr with a default should be okay.

I'm curious as to how this would perform in comparison to the above two, I might test it out later when I get the chance:

try:
    other_scope_id = other._scope_id
except AttributeError:
    other_scope_id = None
return self._scope_id == other_scope_id

@aeros I've pushed my version, but lets make the final decision after your benchmark.

@opavlyuk

I've pushed my version, but lets make the final decision after your benchmark.

Sounds good to me. I should have time to evaluate it later, I've been a bit occupied recently with studying for finals and working on other projects this last week.

If it gets to the point where everything else is finished and this is the last remaining step, feel free to move ahead with the PR. At the end of the day, I think either version would be acceptable.