Set autoclear flag for loop partition.
491263
def set_autoclear(self, value, auth_no_user_interaction=None):
        """"""
        return self._M.Loop.SetAutoclear(
            '(ba{sv})',
            value,
            filter_opt({
                'auth.no_user_interaction': ('b', auth_no_user_interaction),
            })
        )
493674
def set_flag(self, info, code=None):
        """"""
        self.flag = True
        self.flag_info += info
        if code is not None:
            self.flag_code = code
786685
void setActiveMigration() {
        InternalPartitionServiceImpl partitionService = getService();
        MigrationManager migrationManager = partitionService.getMigrationManager();
        MigrationInfo currentActiveMigration = migrationManager.setActiveMigration(migrationInfo);
        if (currentActiveMigration != null) {
            if (migrationInfo.equals(currentActiveMigration)) {
                migrationInfo = currentActiveMigration;
                return;
            }

            throw new RetryableHazelcastException("Cannot set active migration to " + migrationInfo
                    + ". Current active migration is " + currentActiveMigration);
        }
        PartitionStateManager partitionStateManager = partitionService.getPartitionStateManager();
        if (!partitionStateManager.trySetMigratingFlag(migrationInfo.getPartitionId())) {
            throw new RetryableHazelcastException("Cannot set migrating flag, "
                    + "probably previous migration's finalization is not completed yet.");
        }
    }
909838
def reset_dirty_flags(self):
        """"""
        for sm_id, sm in self.state_machines.items():
            sm.marked_dirty = False
693911
def reset(self):
        
        self.dataset_index.reset()
        self.partition_index.reset()
        self.identifier_index.reset()
1084807
public void checkpoint(ObjectEnvelope mod) throws PersistenceBrokerException
    {
        mod.doInsert();
        mod.setModificationState(StateOldClean.getInstance());
    }
516184
public void setActionFlags() {

        m_checkinBean.setFetchAndResetBeforeImport(m_fetchAndReset.getValue().booleanValue());
        switch (m_mode) {
            case checkOut:
                m_checkinBean.setCheckout(true);
                m_checkinBean.setResetHead(false);
                m_checkinBean.setResetRemoteHead(false);
                break;
            case checkIn:
                m_checkinBean.setCheckout(false);
                m_checkinBean.setResetHead(false);
                m_checkinBean.setResetRemoteHead(false);
                break;
            case resetHead:
                m_checkinBean.setCheckout(false);
                m_checkinBean.setResetHead(true);
                m_checkinBean.setResetRemoteHead(false);
                break;
            case resetRemoteHead:
                m_checkinBean.setCheckout(false);
                m_checkinBean.setResetHead(false);
                m_checkinBean.setResetRemoteHead(true);
                break;
            default:
                break;
        }

    }
252655
def _cleanup(self):
        """"""
        self._expkg = None
        self._extmp = None
        self._flag_e = True
        self._ifile.close()
267017
public void setDiscarded()
    {
        state = state.transition(LifeCycle.DISCARDED);
        // release any memory owned by this allocator; automatically signals waiters
        onHeap.releaseAll();
        offHeap.releaseAll();
    }
904230
public void setAutoResetToZero(final boolean AUTO_RESET_TO_ZERO) {
        model.setAutoResetToZero(AUTO_RESET_TO_ZERO);

        if (model.isAutoResetToZero()) {
            setThresholdVisible(false);
            setLedVisible(false);
        }
    }
206021
public void doRestart(List<Long> masters, Map<Integer, Long> partitionMasters)
    {
        List<Long> copy = new ArrayList<Long>(masters);
        m_restartMasters.set(copy);

        m_restartMastersMap.set(Maps.newHashMap(partitionMasters));
    }
1050552
def toggle_autojump():
    """"""
    if not autojump_enabled():
        with open(AUTOJUMP_FILE, 'w+') as ajfile:
            ajfile.write("enabled")
    else:
        os.remove(AUTOJUMP_FILE)
179290
public void setAutoFlushCommands(boolean autoFlush) {

        synchronized (stateLock) {
            this.autoFlushCommands = autoFlush;
            connectionProvider.forEach(connection -> connection.setAutoFlushCommands(autoFlush));
        }
    }
229013
def _reset_build(self, sources):
        """"""
        from ambry.orm.exc import NotFoundError

        for p in self.dataset.partitions:
            if p.type == p.TYPE.SEGMENT:
                self.log("Removing old segment partition: {}".format(p.identity.name))
                try:
                    self.wrap_partition(p).local_datafile.remove()
                    self.session.delete(p)
                except NotFoundError:
                    pass

        for s in sources:

            # Don't delete partitions fro mother bundles!
            if s.reftype == 'partition':
                continue

            p = s.partition
            if p:
                try:
                    self.wrap_partition(p).local_datafile.remove()
                    self.session.delete(p)
                except NotFoundError:
                    pass

            if s.state in (self.STATES.BUILDING, self.STATES.BUILT):
                s.state = self.STATES.INGESTED

        self.commit()
98269
def _reset_bind(self):
        """"""
        self.binded = False
        self._buckets = {}
        self._curr_module = None
        self._curr_bucket_key = None
401294
def _set_persistent_boot(self, values=[]):
        """"""

        xml = self._create_dynamic_xml(
            'SET_PERSISTENT_BOOT', 'SERVER_INFO', 'write')

        if six.PY2:
            child_iterator = xml.getiterator()
        else:
            child_iterator = xml.iter()

        for child in child_iterator:
            for val in values:
                if child.tag == 'SET_PERSISTENT_BOOT':
                    etree.SubElement(child, 'DEVICE', VALUE=val)
        d = self._request_ilo(xml)
        data = self._parse_output(d)
        return data
260163
def set_mode (filename, flags):
    """"""
    try:
        mode = os.lstat(filename).st_mode
    except OSError:
        # ignore
        return
    if not (mode & flags):
        try:
            os.chmod(filename, flags | mode)
        except OSError as msg:
            log_error("could not set mode flags for `%s': %s" % (filename, msg))