Resets terminal to normal configuration
544610
def _at_exit(self):
        

        if self.process_exit:

            try:

                term = self.term

                if self.set_scroll:
                    term.reset()
                else:
                    term.move_to(0, term.height)

                self.term.feed()

            except ValueError:  # Possibly closed file handles
                pass
628854
def reset():
    
    global MAIN_DIR, TEMP_DIR, DOWNLOAD_DIR, SAVESTAT_DIR, LOGFILE_PATH, USING_CORES, LOG_LEVEL, DISABLE_TQDM, \
        SAVE_STATE_VERSION
    MAIN_DIR = Path('./')
    TEMP_DIR = MAIN_DIR.joinpath(Path('temp/'))
    DOWNLOAD_DIR = MAIN_DIR.joinpath(Path('downloads/'))
    SAVESTAT_DIR = MAIN_DIR.joinpath(Path('savestates/'))
    LOGFILE_PATH = MAIN_DIR.joinpath(Path('UniDown.log'))

    USING_CORES = 1
    LOG_LEVEL = 'INFO'
    DISABLE_TQDM = False

    SAVE_STATE_VERSION = Version('1')
53318
def cleanup(config_dir):
    """"""
    stdout_path = os.path.join(config_dir, 'pueue.stdout')
    stderr_path = os.path.join(config_dir, 'pueue.stderr')
    if os._exists(stdout_path):
        os.remove(stdout_path)
    if os._exists(stderr_path):
        os.remove(stderr_path)

    socketPath = os.path.join(config_dir, 'pueue.sock')
    if os.path.exists(socketPath):
        os.remove(socketPath)
324588
def reset(self, total_size=None):
        """"""
        self.root = FakeDirectory(self.path_separator, filesystem=self)
        self.cwd = self.root.name

        self.open_files = []
        self._free_fd_heap = []
        self._last_ino = 0
        self._last_dev = 0
        self.mount_points = {}
        self.add_mount_point(self.root.name, total_size)
        self._add_standard_streams()
716990
def reset!
      self.debug   = ENV['DEBUG']
      self.logger  = Logger.new(STDOUT)
      self.bin_dir = nil
      self.tmp_dir = '/tmp/audio_monster'
      self.file    = 'file'
      self.ffmpeg  = 'ffmpeg'
      self.ffprobe = 'ffprobe'
      self.lame    = 'lame'
      self.mp3val  = 'mp3val'
      self.sox     = 'sox'
      self.soxi    = 'soxi'
      self.twolame = 'twolame'
      self
    end
523036
def _reset_config(self):
        
        self._has_loaded = False
        self._printer = None

        self._printer_name = None
        self._printer_config = None
176648
private function reset()
	{
		// Reset the syntax element
		$syntax       = '\\Hubzero\\Database\\Syntax\\' . ucfirst($this->connection->getSyntax());
		$this->syntax = new $syntax($this->connection);
	}
554708
def reset
      self.user_agent         = DEFAULT_USER_AGENT
      self.server_url         = DEFAULT_SERVER_URL
      self.chef_version       = DEFAULT_CHEF_VERSION
      self.client_name        = DEFAULT_CLIENT_NAME
      self.client_key         = DEFAULT_CLIENT_KEY
      self.connection_options = DEFAULT_CONNECTION_OPTIONS
      self.middleware         = DEFAULT_MIDDLEWARE
      self
    end
696506
def reset_server_env(self, server_name, configure):
        
        env.host_string = configure[server_name]['host']
        env.user = configure[server_name]['user']
        env.password = configure[server_name]['passwd']
1096548
def reset_default(verbose=False):
    """"""
    paths = [jupyter_custom, jupyter_nbext]

    for fpath in paths:
        custom = '{0}{1}{2}.css'.format(fpath, os.sep, 'custom')
        try:
            os.remove(custom)
        except Exception:
            pass
    try:
        delete_font_files()
    except Exception:
        check_directories()
        delete_font_files()

    copyfile(defaultCSS, jupyter_customcss)
    copyfile(defaultJS, jupyter_customjs)

    if os.path.exists(theme_name_file):
        os.remove(theme_name_file)

    if verbose:
        print("Reset css and font defaults in:\n{} &\n{}".format(*paths))
118307
def restore_default_configuration():
    

    def restore(target, default_value):
        if target == default_value:
            return default_value

        if not isinstance(target, RedirectBuffer):
            return target

        try:
            target.active = False
            target.close()
        except Exception:
            pass

        return default_value

    sys.stdout = restore(sys.stdout, sys.__stdout__)
    sys.stderr = restore(sys.stderr, sys.__stderr__)
341959
def reset_to_default(self):
        """"""
        # Checks that this is indeed a default scheme
        scheme = self.current_scheme
        names = self.get_option('names')
        if scheme in names:
            for key in syntaxhighlighters.COLOR_SCHEME_KEYS:
                option = "{0}/{1}".format(scheme, key)
                value = CONF.get_default(self.CONF_SECTION, option)
                self.set_option(option, value)

            self.load_from_conf()
572144
def reset(self):
        
        self._cli.reset()
        self._cli.buffers[DEFAULT_BUFFER].reset()
        self._cli.renderer.request_absolute_cursor_position()
        self._cli._redraw()
201495
def clear_to_reset(self, config_vars):
        """"""

        super(BasicStreamingSubsystem, self).clear_to_reset(config_vars)
        self._in_progress_streamers = set()
296070
def reset!
      @options = {}
      self.client_id     = DEFAULT_CLIENT_ID
      self.client_secret = DEFAULT_CLIENT_SECRET
      self.adapter       = DEFAULT_ADAPTER
      self.endpoint      = DEFAULT_ENDPOINT
      self.user_agent    = DEFAULT_USER_AGENT
      self.token_type    = DEFAULT_TOKEN_TYPE
      self.debug         = ENV['DEBUG']
      self
    end
634302
def reset(project, user):
        """"""
        d = Project.path(project, user) + "output"
        if os.path.isdir(d):
            shutil.rmtree(d)
            os.makedirs(d)
        else:
            raise flask.abort(404)
        if os.path.exists(Project.path(project, user) + ".done"):
            os.unlink(Project.path(project, user) + ".done")
        if os.path.exists(Project.path(project, user) + ".status"):
            os.unlink(Project.path(project, user) + ".status")
1087343
private void resetConfigToDefault() {
    isUseWebservice = true;
    isUpdateAutomatic = true;
    isUseExternalMonomers = false;
    isUseExternalNucleotides = false;
    setUseExternalAttachments(false);
    webserviceMonomersURL = "http://localhost:8080/HELM2MonomerService/rest";
    webserviceMonomersPath = "monomer/";
    webserviceMonomersPutPath = "monomer/";
    webserviceEditorCategorizationURL = "http://localhost:8080";
    webserviceEditorCategorizationPath = "";
    externalNucleotidesPath = "";
    externalMonomersPath = "";
    setExternalAttachmentsPath("");
  }