rx/core/observablebase.py
def distinct_until_changed(self, key_mapper=None, comparer=None) -> 'ObservableBase':
        """Returns an observable sequence that contains only distinct
        contiguous elements according to the key_mapper and the
        comparer.

        1 - obs = observable.distinct_until_changed()
        2 - obs = observable.distinct_until_changed(lambda x: x.id)
        3 - obs = observable.distinct_until_changed(lambda x: x.id,
                                                    lambda x, y: x == y)

        key_mapper -- [Optional] A function to compute the comparison
            key for each element. If not provided, it projects the
            value.
        comparer -- [Optional] Equality comparer for computed key
            values. If not provided, defaults to an equality comparer
            function.

        Return an observable sequence only containing the distinct
        contiguous elements, based on a computed key value, from the source
        sequence.
        """
        from ..operators.observable.distinctuntilchanged import distinct_until_changed
        return distinct_until_changed(self, key_mapper, comparer)
Returns an observable sequence that contains only distinct
        contiguous elements according to the key_mapper and the
        comparer.

        1 - obs = observable.distinct_until_changed()
        2 - obs = observable.distinct_until_changed(lambda x: x.id)
        3 - obs = observable.distinct_until_changed(lambda x: x.id,
                                                    lambda x, y: x == y)

        key_mapper -- [Optional] A function to compute the comparison
            key for each element. If not provided, it projects the
            value.
        comparer -- [Optional] Equality comparer for computed key
            values. If not provided, defaults to an equality comparer
            function.

        Return an observable sequence only containing the distinct
        contiguous elements, based on a computed key value, from the source
        sequence.
        
Returns an observable sequence that contains only distinct
contiguous elements according to the key_mapper and the
comparer.



- [Optional] A function to compute the comparison
key for each element. If not provided, it projects the
value.
comparer -- [Optional] Equality comparer for computed key
values. If not provided, defaults to an equality comparer
function.

Return an observable sequence only containing the distinct
contiguous elements, based on a computed key value, from the source
sequence.
Returns an observable sequence that contains only distinct contiguous elements according to the key_mapper and the comparer . - [ Optional ] A function to compute the comparison key for each element . If not provided it projects the value . comparer -- [ Optional ] Equality comparer for computed key values . If not provided defaults to an equality comparer function . Return an observable sequence only containing the distinct contiguous elements based on a computed key value from the source sequence .
def distinct_until_changed(self, key_mapper=None, comparer=None) -> 'ObservableBase':
        from ..operators.observable.distinctuntilchanged import distinct_until_changed
        return distinct_until_changed(self, key_mapper, comparer)
def distinct_until_changed ( self , key_mapper = None , comparer = None ) -> 'ObservableBase' : from . . operators . observable . distinctuntilchanged import distinct_until_changed return distinct_until_changed ( self , key_mapper , comparer )
Returns an observable sequence that contains only distinct
contiguous elements according to the key_mapper and the
comparer.
Returns an observable sequence that contains only distinct contiguous elements according to the key_mapper and the comparer .
"""Returns an observable sequence that contains only distinct
        contiguous elements according to the key_mapper and the
        comparer.

        1 - obs = observable.distinct_until_changed()
        2 - obs = observable.distinct_until_changed(lambda x: x.id)
        3 - obs = observable.distinct_until_changed(lambda x: x.id,
                                                    lambda x, y: x == y)

        key_mapper -- [Optional] A function to compute the comparison
            key for each element. If not provided, it projects the
            value.
        comparer -- [Optional] Equality comparer for computed key
            values. If not provided, defaults to an equality comparer
            function.

        Return an observable sequence only containing the distinct
        contiguous elements, based on a computed key value, from the source
        sequence.
        """
self
key_mapper
comparer