Remove the acknowledge if it is not sticky

        :return: None
13471
def unacknowledge_problem_if_not_sticky(self):
        
        if hasattr(self, 'acknowledgement') and self.acknowledgement is not None:
            if not self.acknowledgement.sticky:
                self.unacknowledge_problem()
391232
def _notify_disconnected(self):
        ''' 

        '''
        if self.document is not None:
            self.document.remove_on_change(self)
            self._callbacks.remove_all_callbacks()
1204406
def remove(self, label):
        
        if label.id in self._labels:
            self._labels[label.id] = None
        self._dirty = True
1187541
def clear_synchronous_cb(self, cb):
        '''
        
        '''
        if len(self._pending_events):
            ev = self._pending_events[0]

            # We can't have a strict check using this simple mechanism,
            # because we could be waiting for a synch response while messages
            # are being published. So for now, if it's not in the list, do a
            # check to see if the callback is in the pending list, and if so,
            # then raise, because it means we received stuff out of order.
            # Else just pass it through. Note that this situation could happen
            # on any broker-initiated message.
            if ev == cb:
                self._pending_events.popleft()
                self._flush_pending_events()
                return ev

            elif cb in self._pending_events:
                raise ChannelError(
                    "Expected synchronous callback %s, got %s", ev, cb)
        # Return the passed-in callback by default
        return cb
876626
def remove_permission(self, label, callback=None):
        
        return self.connection.remove_permission(self, label, callback=callback)
877620
def remove(self):
        

        if self._multiscat is None:
            return

        self._multiscat.deallocate(self.id)
        self._multiscat = None

        self._viewer_state.remove_global_callback(self._update_scatter)
        self.state.remove_global_callback(self._update_scatter)
429048
def unhook_drag(self):
        
        widget = self.widget
        del widget.mousePressEvent
        del widget.mouseMoveEvent
        del widget.mouseReleaseEvent
1230786
def actually_toggle_deleted t
    if t.has_label? :deleted
      t.remove_label :deleted
      add_or_unhide t.first
      UpdateManager.relay self, :undeleted, t.first
      lambda do
        t.apply_label :deleted
        hide_thread t
        UpdateManager.relay self, :deleted, t.first
      end
    else
      t.apply_label :deleted
      hide_thread t
      UpdateManager.relay self, :deleted, t.first
      lambda do
        t.remove_label :deleted
        add_or_unhide t.first
        UpdateManager.relay self, :undeleted, t.first
      end
    end
  end
589472
def clear_content(self):
        
        for child in self[:]:
            if child.tag == qn('w:pPr'):
                continue
            self.remove(child)
1130535
def Forget(self, obj):
        '''
        '''
        obj = _get_idstr(obj)
        try:
            self.memo.remove(obj)
        except ValueError:
            pass
583549
def cleanup(self):
        
        if self._movie is not None:
            self._movie.frameChanged.disconnect(self._updateFrame)
            self._movie = None
321789
def acknowledge_time(self):
        
        if (self.is_acknowledged and
                self._proto.acknowledgeInfo.HasField('acknowledgeTime')):
            return parse_isostring(self._proto.acknowledgeInfo.acknowledgeTime)
        return None
1253072
def remove(self, iocb):
        """"""
        if _debug: IOQueue._debug("remove %r", iocb)

        # remove the request from the queue
        for i, item in enumerate(self.queue):
            if iocb is item[1]:
                if _debug: IOQueue._debug("    - found at %d", i)
                del self.queue[i]

                # if the queue is empty, clear the event
                qlen = len(self.queue)
                if not qlen:
                    self.notempty.clear()

                # record the new length
                # self.queuesize.Record( qlen, _time() )
                break
        else:
            if _debug: IOQueue._debug("    - not found")
312547
def remove(self):
        ""
        if not self.removed:
            self.hook.remove()
            self.removed=True
875485
public void markNotReady()
  {
    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
      SibTr.entry(tc, "markNotReady");

    ready = false;
    if(keyGroup != null)
      keyGroup.markNotReady();

    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
      SibTr.exit(tc, "markNotReady");

  }
1065339
def reject(self):
        
        if self.acknowledged:
            raise self.MessageStateError(
                "Message already acknowledged with state: %s" % self._state)
        self.backend.reject(self.delivery_tag)
        self._state = "REJECTED"
1287636
def flush(self, key=None):
        

        if not key is None:
            if key in self.data:
                del self.data[key]
        else:
            self.data = {}
            self.next_cleaning = time.time() + self.cleaning_interval