DELETE /events/:id/
        Deletes an event if the delete is permitted. In order for a delete to be permitted, there must be no pending or
        completed orders. Returns a boolean indicating success or failure of the delete.
19942
def delete_event(self, id, **data):
        
        
        return self.delete("/events/{0}/".format(id), data=data)
114585
def delete_column(self, id_or_name):
        
        url = self.build_url(self._endpoints.get('delete_column').format(id=quote(id_or_name)))
        return bool(self.session.post(url))
434003
def _cancel(self, id_cancel) -> None:
        
        if _logger is not None:
            self._log(DEBUG, "cancel", id=id_cancel)
        for event in self._events:
            if event.identifier == id_cancel:
                event.cancel()
                break
129256
def delete_external_event(self, calendar_id, event_uid):
        
        self.request_handler.delete(endpoint='calendars/%s/events' % calendar_id, data={'event_uid': event_uid})
705785
protected int onUpdateDeleteEvent()
    {
        if (kunderaQuery.isDeleteUpdate())
        {
            List result = fetch();

            onDeleteOrUpdate(result);
            return result != null ? result.size() : 0;
        }

        return 0;

    }
1274647
def find_or_create_event_by_id(id, &blk)      
      event = id ? find_event_by_id(id)[0] : nil

      if event
        setup_event(event, &blk)
      elsif id
        event = Event.new(id: id, new_event_with_id_specified: true)
        setup_event(event, &blk)
      else
        event = Event.new
        setup_event(event, &blk)
      end
    end
1012363
function(event) {
      if (event.guid == undefined)
        throw new Error('Event must have a GUID');

      if (this.contains(event))
        return event;

      this.pushed_guids_[event.guid] = true;
      this[this.length_++] = event;
      this.bounds_dirty_ = true;
      return event;
    }
642636
public synchronized boolean remove(int id)
   {
		if (tc.isEntryEnabled()) SibTr.entry(this, tc, "remove", ""+id);
      
      final boolean result = contains(id);
      if (result)
      {
         mutableKey.setValue(id);
         idToConvTable.remove(mutableKey);
      }
      if (tc.isEntryEnabled()) SibTr.exit(this, tc, "remove", ""+result);
      return result;
   }
1232796
def delete_event_ticket_class(self, id, ticket_class_id, **data):
        
        
        return self.delete("/events/{0}/ticket_classes/{0}/".format(id,ticket_class_id), data=data)
371932
async def delete(self, _id=None):
		
		if not _id:
			return {"error":400, 
					"reason":"Missed required fields"}

		document = await self.collection.find_one({"id": _id})

		if not document:
			return {"error":404, 
					"reason":"Not found"}

		deleted_count = await self.collection.delete_one(
							{"id": _id}).deleted_count

		return deleted_count
767005
def delete(self, id, id_name='id', **kwargs):
        
        response = self._new_response()
        if self._check_supported_op('delete', response):
            params = {'Key': {id_name: id}}
            self._call_ddb_method(self.table.delete_item, params, response)
            response.data = 'true'
        response.prepare()
        return response
297470
def delete_orderrun(self, orderrun_id):
        
        rc = DKReturnCode()
        if orderrun_id == 'good':
            rc.set(rc.DK_SUCCESS, None, None)
        else:
            rc.set(rc.DK_FAIL, 'ServingDeleteV2: unable to delete OrderRun')
        return rc
746350
def remove(event, value=nil)
      return unless @listeners[event]
      if value
        @listeners[event].delete(value)
        if @listeners[event].empty?
          @listeners.delete(event)
        end
      else
        @listeners.delete(event)
      end
    end
909348
def restore_event(self, requestId):
        
        with self.__requests:
            if requestId not in self.__requests:
                self.__requests[requestId] = RequestEvent(requestId)
                return True
        return False
722815
def complete_event(self, event_id: str):
        """"""
        event_ids = DB.get_list(self._processed_key)
        if event_id not in event_ids:
            raise KeyError('Unable to complete event. Event {} has not been '
                           'processed (ie. it is not in the processed '
                           'list).'.format(event_id))
        DB.remove_from_list(self._processed_key, event_id, pipeline=True)
        key = _keys.completed_events(self._object_type, self._subscriber)
        DB.append_to_list(key, event_id, pipeline=True)
        DB.execute()
951201
public boolean onDelete()
    {
        Record record = this.getMainRecord();
        if (record == null)
            return false;

        if (record.getEditMode() == Constants.EDIT_NONE)
            return true;
        if (record.getEditMode() == Constants.EDIT_ADD)
        {   // If they're adding, can't delete nothing!
            this.onRefresh();
            return true;
        }
        try {
            if (record.getEditMode() != Constants.EDIT_IN_PROGRESS)
                record.edit();
            record.remove();
            record.addNew();
            this.clearStatusText();
        } catch(DBException ex) {
            this.displayError(ex);
            return false;
        }
        return true;
    }
930902
async def wasDeleted(self, node):
        '''
        
        '''
        for func in self.ondels:
            try:
                retn = func(node)
                if s_coro.iscoro(retn):
                    await retn
            except asyncio.CancelledError:
                raise
            except Exception:
                logger.exception('error on ondel for %s' % (self.name,))

        await node.snap.core.triggers.runNodeDel(node)