Freeze (disable) all settings
962932
def freeze(self):
        
        for fields in zip(self.xsll, self.xsul, self.xslr, self.xsur,
                          self.ys, self.nx, self.ny):
            for field in fields:
                field.disable()
        self.nquad.disable()
        self.xbin.disable()
        self.ybin.disable()
        self.sbutt.disable()
        self.frozen = True
818292
def freeze(self, progressbar=None):
        
        # Call the storage broker pre_freeze hook.
        self._storage_broker.pre_freeze_hook()

        if progressbar:
            progressbar.label = "Freezing dataset"

        # Generate and persist the manifest.
        manifest = self.generate_manifest(progressbar=progressbar)
        self._storage_broker.put_manifest(manifest)

        # Generate and persist overlays from any item metadata that has been
        # added.

        overlays = self._generate_overlays()
        for overlay_name, overlay in overlays.items():
            self._put_overlay(overlay_name, overlay)

        # Change the type of the dataset from "protodataset" to "dataset" and
        # add a "frozen_at" time stamp to the administrative metadata.
        datetime_obj = datetime.datetime.utcnow()
        metadata_update = {
            "type": "dataset",
            "frozen_at": dtoolcore.utils.timestamp(datetime_obj)
        }
        self._admin_metadata.update(metadata_update)
        self._storage_broker.put_admin_metadata(self._admin_metadata)

        # Clean up using the storage broker's post freeze hook.
        self._storage_broker.post_freeze_hook()
717381
function lock(obj, freeze, options) {
    if (options && options.noLocking) {
        return;
    }
    if (freeze) {
        Object.freeze(obj); // freeze the entire object, permanently;
    } else {
        const desc = {
            writable: false,
            configurable: false,
            enumerable: true
        };
        for (const p in obj) {
            Object.defineProperty(obj, p, desc);
        }
    }
}
933757
def freeze(self):
        
        self.__dict__['_frozen'] = True
        for child in self._children.values():
            child.freeze()
1190158
def disable_buffering(self):
        """"""
        self._next = self._gen.next
        self.buffered = False
235062
public function freeze() {
        if (!$this->configured) {
            foreach ($this->mappings['paths'] as $mapping) {
                $mapping->freeze();             // no need to freeze named mappings as all have a path property
            }
            foreach ($this->tiles as $i => $tile) {
                if ($tile->isAbstract()) unset($this->tiles[$i]);
                else                     $tile->freeze();
            }
            $this->configured = true;
        }
        return $this;
    }
841755
def freeze_parameter(self, name):
        
        i = self.get_parameter_names(include_frozen=True).index(name)
        self.unfrozen_mask[i] = False
1354098
def _freeze(self) -> OrderedDict:
        
        return OrderedDict(**{k: getattr(self, k, None) for k in super().__getattribute__("_columns")})
1306452
function freeze(self) {
    var anything = self;
    if (anything.aclEntries) {
        anything.aclEntries = Object.freeze(anything.aclEntries);
    }
    if (anything.createdDate) {
        anything.createdDate = Object.freeze(new Date(+anything.createdDate));
    }
    if (anything.modifiedDate) {
        anything.modifiedDate = Object.freeze(new Date(+anything.modifiedDate));
    }
    return Object.freeze(anything);
}
1083283
function() {
			var self = this;
			self.$input.prop('disabled', true);
			self.$control_input.prop('disabled', true).prop('tabindex', -1);
			self.isDisabled = true;
			self.lock();
		}
100004
function freeze (freeze) {
    if (defined(freeze)) {
        // set default
        immutable.defaultFreeze = freeze ? true : false
        // return immutable
        return ImmutableCore
    }
    // return default value
    return immutable.defaultFreeze
}
229685
synchronized void freeze() {
        if (frozen) {
            return;
        }
        if (userAgent == null) {
            setDefaultUserAgent();
        }
        serviceMap = new HashMap<String, ServiceEndpoint>();
        if (log.isDebugEnabled()) {
            StringBuilder buf = new StringBuilder();
            buf.append("Creating MwsConnection {");
            buf.append("applicationName:");
            buf.append(applicationName);
            buf.append(",applicationVersion:");
            buf.append(applicationVersion);
            buf.append(",awsAccessKeyId:");
            buf.append(awsAccessKeyId);
            buf.append(",uri:");
            buf.append(endpoint.toString());
            buf.append(",userAgent:");
            buf.append(userAgent);
            buf.append(",connectionTimeout:");
            buf.append(connectionTimeout);
            if (proxyHost != null && proxyPort != 0) {
                buf.append(",proxyUsername:");
                buf.append(proxyUsername);
                buf.append(",proxyHost:");
                buf.append(proxyHost);
                buf.append(",proxyPort:");
                buf.append(proxyPort);
            }
            buf.append("}");
            log.debug(buf);
        }

        BasicHttpParams httpParams = new BasicHttpParams();
        httpParams.setParameter(CoreProtocolPNames.USER_AGENT, userAgent);
        HttpConnectionParams
                .setConnectionTimeout(httpParams, connectionTimeout);
        HttpConnectionParams.setSoTimeout(httpParams, socketTimeout);
        HttpConnectionParams.setStaleCheckingEnabled(httpParams, true);
        HttpConnectionParams.setTcpNoDelay(httpParams, true);

        connectionManager = getConnectionManager();
        httpClient = new DefaultHttpClient(connectionManager, httpParams);
        httpContext = new BasicHttpContext();
        if (proxyHost != null && proxyPort != 0) {
            String scheme = MwsUtl.usesHttps(endpoint) ? "https" : "http";
            HttpHost hostConfiguration = new HttpHost(proxyHost, proxyPort, scheme);
            httpClient.getParams().setParameter(ConnRoutePNames.DEFAULT_PROXY, hostConfiguration);

            if (proxyUsername != null && proxyPassword != null) {
                Credentials credentials = new UsernamePasswordCredentials(proxyUsername, proxyPassword);
                CredentialsProvider cprovider = new BasicCredentialsProvider();
                cprovider.setCredentials(new AuthScope(proxyHost, proxyPort), credentials);
                httpContext.setAttribute(ClientContext.CREDS_PROVIDER, cprovider);
            }
        }
        headers = Collections.unmodifiableMap(headers);
        frozen = true;
    }
663991
def disable_keyboard_helpers
      edit_plist(path.preferences_plist) do |plist|
        %w[
          KeyboardAllowPaddle
          KeyboardAssistant
          KeyboardAutocapitalization
          KeyboardAutocorrection
          KeyboardCapsLock
          KeyboardCheckSpelling
          KeyboardPeriodShortcut
          KeyboardPrediction
          KeyboardShowPredictionBar
        ].each do |key|
          plist[key] = false
        end
      end
    end
1138365
def freeze():
    '''
    
    '''
    installations = {}
    for dist in get_installed_distributions():
        req = pip.FrozenRequirement.from_dist(dist, [], find_tags=False)
        installations[req.name] = req

    return [str(installation).rstrip() for installation in
        sorted(installations.values(), key=lambda x: x.name.lower())]
44680
public void disableICE() {
        if (this.ice) {
            this.ice = false;
            this.iceAuthenticator.reset();
            
            // Disable ICE on RTP channels
            this.rtpChannel.disableIce();
            if(!rtcpMux) {
                this.rtcpChannel.disableIce();
            }

            if (logger.isDebugEnabled()) {
                logger.debug(this.mediaType + " channel " + this.ssrc + " disabled ICE");
            }
        }
    }
342955
def disable_caching(self):
        ""
        self.caching_enabled = False
        for c in self.values():
            c.disable_cacher()
642128
def temporarily_disabled(self):
        
        old_setting = self.options.enabled
        self.disable(clear_cache=False)
        try:
            yield
        finally:
            self.options.enabled = old_setting