Disable profiling.
181549
def disable(self, threads=True):
        
        if self.enabled_start:
            sys.settrace(None)
            self._disable()
        else:
            warn('Duplicate "disable" call')
1079595
def discard_config(self):
        """"""
        self.device.cu.rollback(rb_id=0)
        if not self.config_lock:
            self._unlock()
1299152
async def disable(self):
        
        await self.controller.disable_user(self.username)
        self._user_info.disabled = True
866988
def disable(self):
        
        self.engine.data.update(dns_relay_interface=[])
        self.engine.data.pop('dns_relay_profile_ref', None)
1234891
public void disableAll(int profileId, String client_uuid) {
        PreparedStatement statement = null;
        try (Connection sqlConnection = sqlService.getConnection()) {
            statement = sqlConnection.prepareStatement(
                "DELETE FROM " + Constants.DB_TABLE_ENABLED_OVERRIDE +
                    " WHERE " + Constants.CLIENT_PROFILE_ID + " = ?" +
                    " AND " + Constants.CLIENT_CLIENT_UUID + " =? "
            );
            statement.setInt(1, profileId);
            statement.setString(2, client_uuid);
            statement.executeUpdate();
            statement.close();
        } catch (SQLException e) {
            e.printStackTrace();
        } finally {
            try {
                if (statement != null) {
                    statement.close();
                }
            } catch (Exception e) {
            }
        }
    }
841186
def stop(self):
        """"""
        self._end.value = True
        if self.background_process:
            try:
                self.background_process.terminate()
            except Exception:
                pass
        for task_id, values in self.current_tasks.items():
            try:
                values['proc'].terminate()
            except Exception:
                pass
590367
def remove_network_profile(self, obj, params):
        """"""

        network_id = -1
        profiles = self.network_profiles(obj)

        for profile in profiles:
            if profile == params:
                network_id = profile.id

        if network_id != -1:
            self._send_cmd_to_wpas(obj['name'],
                'REMOVE_NETWORK {}'.format(network_id))
563214
def p_disable(self, p):
        ''
        p[0] = Disable(p[2], lineno=p.lineno(1))
        p.set_lineno(0, p.lineno(1))
1190158
def disable_buffering(self):
        """"""
        self._next = self._gen.next
        self.buffered = False
1173082
def profile_delete(self):
        """"""
        self.validate_profile_exists()

        profile_data = self.profiles.get(self.args.profile_name)
        fqfn = profile_data.get('fqfn')
        with open(fqfn, 'r+') as fh:
            data = json.load(fh)
            for profile in data:
                if profile.get('profile_name') == self.args.profile_name:
                    data.remove(profile)
            fh.seek(0)
            fh.write(json.dumps(data, indent=2, sort_keys=True))
            fh.truncate()

        if not data:
            # remove empty file
            os.remove(fqfn)
1267963
def stop(self):
        """"""
        self.StopTask()
        self.ClearTask()
        if self.clock:
            self.clock.StopTask()
            self.clock.ClearTask()
1127492
public static function disable()
    {

        if (self::isEnabled()) {
            // stop any timers still on stack (those might be stopped after calculation otherwise)
            $stackCopy = self::$stack;
            while ($timerName = array_pop($stackCopy)) {
                self::stop($timerName);
            }
        }
        self::$_enabled = false;

        self::calculate();
    }
348325
def disable():
        """"""
        if os.name != 'nt' or not Windows.is_enabled():
            return False

        getattr(sys.stderr, '_reset_colors', lambda: False)()
        getattr(sys.stdout, '_reset_colors', lambda: False)()

        if isinstance(sys.stderr, _WindowsStream):
            sys.stderr = getattr(sys.stderr, 'original_stream')
        if isinstance(sys.stderr, _WindowsStream):
            sys.stdout = getattr(sys.stdout, 'original_stream')

        return True
647244
def disable():
    
    Benchmark.enable = False
    ComparisonBenchmark.enable = False
    BenchmarkedFunction.enable = False
    BenchmarkedClass.enable = False
1179052
public static void stopProfilerAndReport() {
		profiler.stopCollecting();

		// Write a report file
		try {
			// Get path from property file
			String path = CoreProperties.getLoader().getPropertyAsString(
					VanillaDb.class.getName() + ".PROFILE_OUTPUT_DIR",
					System.getProperty("user.home"));
			File out = new File(path, System.currentTimeMillis()
					+ "_profile.txt");
			FileWriter wrFile = new FileWriter(out);
			BufferedWriter bwrFile = new BufferedWriter(wrFile);

			// Write Profiling Report
			bwrFile.write(profiler.getTopPackages(30));
			bwrFile.newLine();
			bwrFile.write(profiler.getTopMethods(30));
			bwrFile.newLine();
			bwrFile.write(profiler.getTopLines(30));

			/*
			 * I should write a more careful code here. I didn't do it, because
			 * of the same reason above.
			 */
			bwrFile.close();
		} catch (IOException e) {
			e.printStackTrace();
		}
	}
774890
def disable(self):
        
        log = logging.getLogger('ipsv.models.sites.site')
        sites_enabled_path = _cfg.get('Paths', 'NginxSitesEnabled')
        symlink_path = os.path.join(sites_enabled_path, '{domain}-{fn}.conf'.format(domain=self.domain.name,
                                                                                    fn=self.slug))
        log.debug('Symlink path: %s', symlink_path)
        if os.path.islink(symlink_path):
            log.info('Removing configuration symlink: %s', symlink_path)
            os.unlink(symlink_path)

        self.enabled = 0
        Session.commit()
933842
def remove_profile(self, profile):
        
        self.remove_file(
            os.path.join(
                self.root_directory, 'minimum_needs', profile + '.json')
        )