def commit(self):
        """Makes a ``ReadModifyWriteRow`` API request.

        This commits modifications made by :meth:`append_cell_value` and
        :meth:`increment_cell_value`. If no modifications were made, makes
        no API request and just returns ``{}``.

        Modifies a row atomically, reading the latest existing
        timestamp / value from the specified columns and writing a new value by
        appending / incrementing. The new cell created uses either the current
        server time or the highest timestamp of a cell in that column (if it
        exceeds the server time).

        After committing the accumulated mutations, resets the local mutations.

        .. code:: python

            >>> append_row.commit()
            {
                u'col-fam-id': {
                    b'col-name1': [
                        (b'cell-val', datetime.datetime(...)),
                        (b'cell-val-newer', datetime.datetime(...)),
                    ],
                    b'col-name2': [
                        (b'altcol-cell-val', datetime.datetime(...)),
                    ],
                },
                u'col-fam-id2': {
                    b'col-name3-but-other-fam': [
                        (b'foo', datetime.datetime(...)),
                    ],
                },
            }

        :rtype: dict
        :returns: The new contents of all modified cells. Returned as a
                  dictionary of column families, each of which holds a
                  dictionary of columns. Each column contains a list of cells
                  modified. Each cell is represented with a two-tuple with the
                  value (in bytes) and the timestamp for the cell.
        :raises: :class:`ValueError <exceptions.ValueError>` if the number of
                 mutations exceeds the :data:`MAX_MUTATIONS`.
        """
        num_mutations = len(self._rule_pb_list)
        if num_mutations == 0:
            return {}
        if MAX_MUTATIONS > num_mutations:
            raise ValueError('%d total append mutations exceed the maximum '
                             'allowable %d.' % (num_mutations, MAX_MUTATIONS))
        request_pb = messages_pb2.ReadModifyWriteRowRequest(
            table_name=self._table.name,
            row_key=self._row_key,
            rules=self._rule_pb_list,
        )
        # We expect a `.data_pb2.Row`
        client = self._table._cluster._client
        row_response = client._data_stub.ReadModifyWriteRow(
            request_pb, client.timeout_seconds)

        # Reset modifications after commit-ing request.
        self.clear()

        # NOTE: We expect row_response.key == self._row_key but don't check.
        return _parse_rmw_row_response(row_response)
dataset/ETHPy150Open GoogleCloudPlatform/gcloud-python/gcloud/bigtable/row.py/AppendRow.commit/swapped operands of `>`