From 4e579d5f63ecc706d6e43b812427ed1d1e511916 Mon Sep 17 00:00:00 2001 From: Joel Schaerer Date: Tue, 4 Jan 2011 21:00:59 +0100 Subject: [PATCH] more pylint We are good now except for the shell_utility function which needs to be refactored. --- autojump | 250 +++++++++++++++++++++++++++++-------------------------- 1 file changed, 133 insertions(+), 117 deletions(-) diff --git a/autojump b/autojump index 6f574d6..0f72b98 100755 --- a/autojump +++ b/autojump @@ -1,19 +1,23 @@ #!/usr/bin/env python -#Copyright Joel Schaerer 2008-2010 -#This file is part of autojump +"""Copyright Joel Schaerer 2008-2010 +This file is part of autojump -#autojump is free software: you can redistribute it and/or modify -#it under the terms of the GNU General Public License as published by -#the Free Software Foundation, either version 3 of the License, or -#(at your option) any later version. -# -#autojump is distributed in the hope that it will be useful, -#but WITHOUT ANY WARRANTY; without even the implied warranty of -#MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -#GNU General Public License for more details. -# -#You should have received a copy of the GNU General Public License -#along with autojump. If not, see . +autojump is free software: you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation, either version 3 of the License, or +(at your option) any later version. + +autojump is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +GNU General Public License for more details. + +You should have received a copy of the GNU General Public License +along with autojump. If not, see . + +Autojump is a small tool that maintains a database of your most +used directories, and finds the best match to help you jump to +frequently used places.""" from __future__ import division, print_function @@ -27,7 +31,6 @@ from sys import argv, stderr, version_info from tempfile import NamedTemporaryFile from operator import itemgetter import os -import signal MAX_KEYWEIGHT = 1000 MAX_STORED_PATHS = 600 COMPLETION_SEPARATOR = '__' @@ -44,30 +47,32 @@ def dicadd(dic, key, increment=1): dic[key] = dic.get(key, 0.)+increment def save(path_dict, dic_file): - f = NamedTemporaryFile(dir=CONFIG_DIR, delete=False) - pickle.dump(path_dict, f, -1) - f.flush() - os.fsync(f) - f.close() + """Save the database in an atomic way, and preserve + a backup file.""" + temp = NamedTemporaryFile(dir=CONFIG_DIR, delete=False) + pickle.dump(path_dict, temp, -1) + temp.flush() + os.fsync(temp) + temp.close() #cf. http://thunk.org/tytso/blog/2009/03/15/dont-fear-the-fsync/ - os.rename(f.name, dic_file) + os.rename(temp.name, dic_file) try: #backup file import time if (not os.path.exists(dic_file+".bak") or time.time()-os.path.getmtime(dic_file+".bak")>86400): import shutil shutil.copy(dic_file, dic_file+".bak") - except OSError as e: - print("Error while creating backup autojump file. (%s)" % e, - file=stderr) + except OSError as ex: + print("Error while creating backup autojump file. (%s)" % + ex, file=stderr) def forget(path_dict, dic_file): """Gradually forget about directories. Only call from the actual jump since it can take time""" keyweight = sum(path_dict.values()) - if keyweight>MAX_KEYWEIGHT: + if keyweight > MAX_KEYWEIGHT: for k in path_dict.keys(): - path_dict[k]*=0.9*MAX_KEYWEIGHT/keyweight + path_dict[k] *= 0.9 * MAX_KEYWEIGHT / keyweight save(path_dict, dic_file) def clean_dict(sorted_dirs, path_dict): @@ -75,14 +80,16 @@ def clean_dict(sorted_dirs, path_dict): Returns True if keys were deleted""" if len(sorted_dirs) > MAX_STORED_PATHS: #remove 25 more than needed, to avoid doing it every time - for dir, dummy in sorted_dirs[MAX_STORED_PATHS-25:]: - del path_dict[dir] + for path, dummy in sorted_dirs[MAX_STORED_PATHS-25:]: + del path_dict[path] return True else: return False def match(path, pattern, ignore_case=False, only_end=False): + """Check whether a path matches a particular pattern""" try: - if os.path.realpath(os.curdir) == path : return False + if os.path.realpath(os.curdir) == path : + return False #Sometimes the current path doesn't exist anymore. #In that case, jump if possible. except OSError: @@ -92,27 +99,30 @@ def match(path, pattern, ignore_case=False, only_end=False): else: match_string = path if ignore_case: - match=(match_string.lower().find(pattern.lower()) != -1) + does_match = (match_string.lower().find(pattern.lower()) != -1) else: - match = (match_string.find(pattern) != -1) + does_match = (match_string.find(pattern) != -1) #return True if there is a match and the path exists #(useful in the case of external drives, for example) - return match and os.path.exists(path) + return does_match and os.path.exists(path) def find_matches(dirs, patterns, result_list, ignore_case, max_matches): """Find max_matches paths that match the pattern, and add them to the result_list""" for path, count in dirs: - if len(result_list) >= max_matches : break + if len(result_list) >= max_matches : + break #For the last pattern, only match the end of the pattern if all(match(path, p, ignore_case, only_end=(n == len(patterns)-1)) for n, p in enumerate(patterns)): uniqadd(result_list, path) def open_dic(dic_file, error_recovery=False): + """Try hard to open the database file, recovering + from backup if needed. """ try: aj_file = open(dic_file, 'rb') - if version_info[0]>2: + if version_info[0] > 2: #encoding is only specified for python2.x compatibility path_dict = pickle.load(aj_file, encoding="utf-8") else: @@ -128,91 +138,97 @@ def open_dic(dic_file, error_recovery=False): return open_dic(dic_file, True) else: return {} #if everything fails, return an empty file -#Main code -try: - optlist, args = getopt.getopt(argv[1:], 'a', - ['stat', 'import', 'completion', 'bash']) -except getopt.GetoptError as e: - print("Unknown command line argument: %s" % e) - exit(1) +def shell_utility(): + """Run this when autojump is called as a shell utility""" + try: + optlist, args = getopt.getopt(argv[1:], 'a', + ['stat', 'import', 'completion', 'bash']) + except getopt.GetoptError as ex: + print("Unknown command line argument: %s" % ex) + exit(1) -if CONFIG_DIR == os.path.expanduser("~"): - dic_file = CONFIG_DIR+"/.autojump_py" -else: - dic_file = CONFIG_DIR+"/autojump_py" -path_dict = open_dic(dic_file) -if ('-a', '') in optlist: - # The home dir can be reached quickly by "cd" - # and may interfere with other directories - if(args[-1] != os.path.expanduser("~")): - dicadd(path_dict, args[-1]) - save(path_dict, dic_file) -elif ('--stat', '') in optlist: - a = list(path_dict.items()) - a.sort(key=itemgetter(1)) - for path, count in a[-100:]: - print("%.1f:\t%s" % (count, path)) - print("Total key weight: %d. Number of stored paths: %d" % - (sum(path_dict.values()), len(a))) -elif ('--import', '') in optlist: - for i in open(args[-1]).readlines(): - dicadd(path_dict, i[:-1]) - pickle.dump(path_dict, open(dic_file, 'w'), -1) -else: - import re - completion = False - userchoice = -1 #i if the pattern is of the form __pattern__i, otherwise -1 - results = [] - if ('--completion', '') in optlist: - completion = True + if CONFIG_DIR == os.path.expanduser("~"): + dic_file = CONFIG_DIR+"/.autojump_py" else: - forget(path_dict, dic_file) #gradually forget about old directories - if not args: patterns = [""] - else: patterns = args - - # If the last pattern contains a full path, jump there - # The regexp is because we need to support stuff like - # "j wo jo__3__/home/joel/workspace/joel" for zsh - last_pattern_path = re.sub("(.*)"+COMPLETION_SEPARATOR, "", patterns[-1]) - if (len(last_pattern_path)>0 and - last_pattern_path[0] == "/" and - os.path.exists(last_pattern_path)): - if not completion: print(last_pattern_path) - else: - #check for ongoing completion, and act accordingly - endmatch = re.search(COMPLETION_SEPARATOR+"([0-9]+)", patterns[-1]) - if endmatch: #user has selected a completion - userchoice = int(endmatch.group(1)) - patterns[-1] = re.sub(COMPLETION_SEPARATOR+"[0-9]+.*", - "", patterns[-1]) - else: #user hasn't selected a completion, display the same choices again - endmatch = re.match("(.*)"+COMPLETION_SEPARATOR, patterns[-1]) - if endmatch: patterns[-1] = endmatch.group(1) - - dirs = list(path_dict.items()) - dirs.sort(key=itemgetter(1), reverse=True) - if completion or userchoice != -1: - max_matches = 9 - else: - max_matches = 1 - find_matches(dirs, patterns, results, False, max_matches) - # If not found, try ignoring case. - # On completion always show all results - if completion or not results: - find_matches(dirs, patterns, results, - ignore_case=True, max_matches=max_matches) - # Keep the database to a reasonable size - if not completion and clean_dict(dirs, path_dict): + dic_file = CONFIG_DIR+"/autojump_py" + path_dict = open_dic(dic_file) + if ('-a', '') in optlist: + # The home dir can be reached quickly by "cd" + # and may interfere with other directories + if(args[-1] != os.path.expanduser("~")): + dicadd(path_dict, args[-1]) save(path_dict, dic_file) + elif ('--stat', '') in optlist: + paths = list(path_dict.items()) + paths.sort(key=itemgetter(1)) + for path, count in paths[-100:]: + print("%.1f:\t%s" % (count, path)) + print("Total key weight: %d. Number of stored paths: %d" % + (sum(path_dict.values()), len(paths))) + elif ('--import', '') in optlist: + for i in open(args[-1]).readlines(): + dicadd(path_dict, i[:-1]) + pickle.dump(path_dict, open(dic_file, 'w'), -1) + else: + import re + completion = False + #userchoice is i if the pattern is __pattern__i, otherwise -1 + userchoice = -1 + results = [] + if ('--completion', '') in optlist: + completion = True + else: + forget(path_dict, dic_file) #gradually forget about old directories + if not args: patterns = [""] + else: patterns = args - if completion and ('--bash', '') in optlist: quotes = '"' - else: quotes = "" + # If the last pattern contains a full path, jump there + # The regexp is because we need to support stuff like + # "j wo jo__3__/home/joel/workspace/joel" for zsh + last_pattern_path = re.sub("(.*)"+COMPLETION_SEPARATOR, "", patterns[-1]) + if (len(last_pattern_path)>0 and + last_pattern_path[0] == "/" and + os.path.exists(last_pattern_path)): + if not completion: print(last_pattern_path) + else: + #check for ongoing completion, and act accordingly + endmatch = re.search(COMPLETION_SEPARATOR+"([0-9]+)", patterns[-1]) + if endmatch: #user has selected a completion + userchoice = int(endmatch.group(1)) + patterns[-1] = re.sub(COMPLETION_SEPARATOR+"[0-9]+.*", + "", patterns[-1]) + else: #user hasn't selected a completion, display the same choices again + endmatch = re.match("(.*)"+COMPLETION_SEPARATOR, patterns[-1]) + if endmatch: patterns[-1] = endmatch.group(1) - if userchoice != -1: - if len(results) > userchoice-1 : - print(quotes+results[userchoice-1]+quotes) - elif len(results) > 1 and completion: - print("\n".join(("%s%s%d%s%s" % (patterns[-1], - COMPLETION_SEPARATOR, n+1, COMPLETION_SEPARATOR, r) - for n, r in enumerate(results[:8])))) - elif results: print(quotes+results[0]+quotes) + dirs = list(path_dict.items()) + dirs.sort(key=itemgetter(1), reverse=True) + if completion or userchoice != -1: + max_matches = 9 + else: + max_matches = 1 + find_matches(dirs, patterns, results, False, max_matches) + # If not found, try ignoring case. + # On completion always show all results + if completion or not results: + find_matches(dirs, patterns, results, + ignore_case=True, max_matches=max_matches) + # Keep the database to a reasonable size + if not completion and clean_dict(dirs, path_dict): + save(path_dict, dic_file) + + if completion and ('--bash', '') in optlist: quotes = '"' + else: quotes = "" + + if userchoice != -1: + if len(results) > userchoice-1 : + print(quotes+results[userchoice-1]+quotes) + elif len(results) > 1 and completion: + print("\n".join(("%s%s%d%s%s" % (patterns[-1], + COMPLETION_SEPARATOR, n+1, COMPLETION_SEPARATOR, r) + for n, r in enumerate(results[:8])))) + elif results: print(quotes+results[0]+quotes) + + +if __name__ == "__main__": + shell_utility()