Executes all remove items related actions like
* remove
* removeAlias
422225
protected function executeRemoveActions()
    {
        if (!empty($this->actions[self::GROUP_REMOVE])) {
            $this->executeActions(self::GROUP_REMOVE);
        }
    }
1026699
def on_unselect(self, item, action):
        """"""
        if not isinstance(item, int):
            item = self.items.index(item)

        self._on_unselect[item] = action
559936
def cleanup(self):
        
        remove = []
        for handle, assoc in self.assocs.items():
            if assoc.expiresIn == 0:
                remove.append(handle)
        for handle in remove:
            del self.assocs[handle]
        return len(remove), len(self.assocs)
1242739
def do_delete(self, args):
        ''''''
        namespace = self.config['namespace']
        if not args.assume_yes:
            response = raw_input('Delete everything in {0!r}?  Enter namespace: '
                                 .format(namespace))
            if response != namespace:
                self.stdout.write('not deleting anything\n')
                return
        self.stdout.write('deleting namespace {0!r}\n'.format(namespace))
        self.task_master.clear()
670973
def do_rmall(self, line):
        ""
        args = self.getargs(line)
        if args and args[-1] == "yes":
            args.pop()

            if not args:
                args = [self.table.table_name]

            while args:
                table = boto.dynamodb2.table.Table(args.pop(0), connection=self.conn)
                print "from table " + table.table_name

                for item in table.scan(attributes_to_get=[], request_limit=10):
                    print "  removing %s" % item
                    item.delete()
        else:
            print "ok, never mind..."
1042678
public function cleanupAction()
    {
        $params = $this->_processParameters($this->showParameters);
        $params['contentTitle'] = $this->_('Clean up existing appointments?');
        $params['filterOn']     = 'gap_id_procedure';
        $params['filterWhen']   = 'gap_filter';

        $snippets = array(
            'Generic\\ContentTitleSnippet',
            'Agenda\\AppointmentCleanupSnippet',
            'Agenda_CalendarTableSnippet',
            );

        $this->addSnippets($snippets, $params);
    }
330316
def remove(item)
      prev_item = Soulmate.redis.hget(database, item["id"])
      if prev_item
        prev_item = MultiJson.decode(prev_item)
        # undo the operations done in add
        Soulmate.redis.pipelined do
          Soulmate.redis.hdel(database, prev_item["id"])
          phrase = ([prev_item["term"]] + (prev_item["aliases"] || [])).join(' ')
          prefixes_for_phrase(phrase).each do |p|
            Soulmate.redis.srem(base, p)
            Soulmate.redis.zrem("#{base}:#{p}", prev_item["id"])
          end
        end
      end
    end
242562
def __remove_actions(self):
        

        LOGGER.debug("> Removing '{0}' Component actions.".format(self.__class__.__name__))

        remove_project_action = "Actions|Umbra|Components|factory.script_editor|&File|Remove Project"
        self.__script_editor.command_menu.removeAction(self.__engine.actions_manager.get_action(remove_project_action))
        self.__engine.actions_manager.unregister_action(remove_project_action)
1180571
function remove(item, list) {
  var i = list.indexOf(item);
  if (~i) list.splice(i, 1);
}
766135
async def remove_items(self, *items):
    '''
    '''
    items = [i.id for i in (await self.process(items)) if i in self.items]
    if not items:
      return

    await self.connector.delete(
      'Playlists/{Id}/Items'.format(Id=self.id),
      EntryIds=','.join(items),
      remote=False
    )
1102356
def execute(self):
        """"""
        clean_cmd = ['git', 'clean', '-X', '-d']
        if 'CI' not in os.environ:
            LOGGER.info('The following files/directories will be deleted:')
            LOGGER.info('')
            LOGGER.info(check_output(clean_cmd + ['-n']).decode())
            if not strtobool(input('Proceed?: ')):
                return False
        check_call(clean_cmd + ['-f'])
        empty_dirs = self.get_empty_dirs(self.env_root)
        if empty_dirs != []:
            LOGGER.info('Now removing empty directories:')
        for directory in empty_dirs:
            LOGGER.info("Removing %s/", directory)
            shutil.rmtree(os.path.join(self.env_root, directory))
        return True
515242
def process_remove_action(processors, action, argument):
    """"""
    for processor in processors:
        processor(action, argument)
    db.session.commit()
534530
def delete_all(self):
        ''''''
        def delete_action_gen():
            scanner = scan(self.es,
                           index=self.index_name,
                           query={'query': {'match_all':{}}})
            for v in scanner:
                yield { '_op_type': 'delete',
                        '_index': self.index_name,
                        '_type': v['_type'],
                        '_id': v['_id'],
                      }
        bulk(self.es, delete_action_gen())
1158148
public function execute() {
        global $DB;

        // Automatic creation of deletion requests must be enabled.
        if (get_config('tool_dataprivacy', 'automaticdeletionrequests')) {
            // Select all deleted users that do not have any delete data requests created for them.
            $sql = "SELECT DISTINCT(u.id)
                  FROM {user} u
             LEFT JOIN {tool_dataprivacy_request} r
                       ON u.id = r.userid
                 WHERE u.deleted = ?
                       AND (r.id IS NULL
                           OR r.type != ?)";

            $params = [
                1,
                api::DATAREQUEST_TYPE_DELETE
            ];

            $deletedusers = $DB->get_records_sql($sql, $params);
            $createdrequests = 0;

            foreach ($deletedusers as $user) {
                api::create_data_request($user->id, api::DATAREQUEST_TYPE_DELETE,
                    get_string('datarequestcreatedfromscheduledtask', 'tool_dataprivacy'),
                    data_request::DATAREQUEST_CREATION_AUTO);
                $createdrequests++;
            }

            if ($createdrequests > 0) {
                mtrace($createdrequests . ' delete data request(s) created for existing deleted users');
            }
        }
    }
131028
def purgeDeletedWidgets():
        """"""
        toremove = []
        for field in AbstractEditorWidget.funit_fields:
            if sip.isdeleted(field):
                toremove.append(field)
        for field in toremove:
            AbstractEditorWidget.funit_fields.remove(field)

        toremove = []
        for field in AbstractEditorWidget.tunit_fields:
            if sip.isdeleted(field):
                toremove.append(field)
        for field in toremove:
            AbstractEditorWidget.tunit_fields.remove(field)
129207
static function cleanup()
    {
        $db = eZDB::instance();
        $sql = "SELECT productcollection_id FROM ezbasket";
        $limit = self::ITEM_LIMIT;

        $db->begin();
        do
        {
            $rows = $db->arrayQuery( $sql, array( 'offset' => 0, 'limit' => $limit ) );

            if ( count( $rows ) == 0 )
                break;

            $productCollectionIDList = array();
            foreach ( $rows as $row )
            {
                $productCollectionIDList[] = (int)$row['productcollection_id'];
            }
            eZProductCollection::cleanupList( $productCollectionIDList );

            $ids = implode( ', ', $productCollectionIDList );
            $db->query( "DELETE FROM ezbasket WHERE productcollection_id IN ( $ids )" );
        }
        while ( true );
        $db->commit();
    }
1335967
public function purge()
    {
        $this->dbHandler->beginTransaction();
        $query = $this->dbHandler->createDeleteQuery();
        $tables = [
            'ezsearch_object_word_link',
            'ezsearch_search_phrase',
            'ezsearch_word',
        ];
        foreach ($tables as $tbl) {
            $query->deleteFrom($tbl);
            $stmt = $query->prepare();
            $stmt->execute();
        }
        $this->dbHandler->commit();
    }