The Tor Browser: comparison python/which/which.py

--1:000000000000
+:6e2ba719e762
+#!/usr/bin/env python
+# Copyright (c) 2002-2005 ActiveState Corp.
+# See LICENSE.txt for license details.
+# Author:
+#   Trent Mick (TrentM@ActiveState.com)
+# Home:
+#   http://trentm.com/projects/which/
+r"""Find the full path to commands.
+which(command, path=None, verbose=0, exts=None)
+Return the full path to the first match of the given command on the
+path.
+whichall(command, path=None, verbose=0, exts=None)
+Return a list of full paths to all matches of the given command on
+the path.
+whichgen(command, path=None, verbose=0, exts=None)
+Return a generator which will yield full paths to all matches of the
+given command on the path.
+By default the PATH environment variable is searched (as well as, on
+Windows, the AppPaths key in the registry), but a specific 'path' list
+to search may be specified as well.  On Windows, the PATHEXT environment
+variable is applied as appropriate.
+If "verbose" is true then a tuple of the form
+(<fullpath>, <matched-where-description>)
+is returned for each match. The latter element is a textual description
+of where the match was found. For example:
+from PATH element 0
+from HKLM\SOFTWARE\...\perl.exe
+"""
+_cmdlnUsage = """
+Show the full path of commands.
+Usage:
+which [<options>...] [<command-name>...]
+Options:
+-h, --help      Print this help and exit.
+-V, --version   Print the version info and exit.
+-a, --all       Print *all* matching paths.
+-v, --verbose   Print out how matches were located and
+show near misses on stderr.
+-q, --quiet     Just print out matches. I.e., do not print out
+near misses.
+-p <altpath>, --path=<altpath>
+An alternative path (list of directories) may
+be specified for searching.
+-e <exts>, --exts=<exts>
+Specify a list of extensions to consider instead
+of the usual list (';'-separate list, Windows
+only).
+Show the full path to the program that would be run for each given
+command name, if any. Which, like GNU's which, returns the number of
+failed arguments, or -1 when no <command-name> was given.
+Near misses include duplicates, non-regular files and (on Un*x)
+files without executable access.
+"""
+__revision__ = "$Id: which.py 430 2005-08-20 03:11:58Z trentm $"
+__version_info__ = (1, 1, 0)
+__version__ = '.'.join(map(str, __version_info__))
+import os
+import sys
+import getopt
+import stat
+#---- exceptions
+class WhichError(Exception):
+pass
+#---- internal support stuff
+def _getRegisteredExecutable(exeName):
+"""Windows allow application paths to be registered in the registry."""
+registered = None
+if sys.platform.startswith('win'):
+if os.path.splitext(exeName)[1].lower() != '.exe':
+exeName += '.exe'
+import _winreg
+try:
+key = "SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\App Paths\\" +\
+exeName
+value = _winreg.QueryValue(_winreg.HKEY_LOCAL_MACHINE, key)
+registered = (value, "from HKLM\\"+key)
+except _winreg.error:
+pass
+if registered and not os.path.exists(registered[0]):
+registered = None
+return registered
+def _samefile(fname1, fname2):
+if sys.platform.startswith('win'):
+return ( os.path.normpath(os.path.normcase(fname1)) ==\
+os.path.normpath(os.path.normcase(fname2)) )
+else:
+return os.path.samefile(fname1, fname2)
+def _cull(potential, matches, verbose=0):
+"""Cull inappropriate matches. Possible reasons:
+- a duplicate of a previous match
+- not a disk file
+- not executable (non-Windows)
+If 'potential' is approved it is returned and added to 'matches'.
+Otherwise, None is returned.
+"""
+for match in matches:  # don't yield duplicates
+if _samefile(potential[0], match[0]):
+if verbose:
+sys.stderr.write("duplicate: %s (%s)\n" % potential)
+return None
+else:
+if not stat.S_ISREG(os.stat(potential[0]).st_mode):
+if verbose:
+sys.stderr.write("not a regular file: %s (%s)\n" % potential)
+elif not os.access(potential[0], os.X_OK):
+if verbose:
+sys.stderr.write("no executable access: %s (%s)\n"\
+% potential)
+else:
+matches.append(potential)
+return potential
+#---- module API
+def whichgen(command, path=None, verbose=0, exts=None):
+"""Return a generator of full paths to the given command.
+"command" is a the name of the executable to search for.
+"path" is an optional alternate path list to search. The default it
+to use the PATH environment variable.
+"verbose", if true, will cause a 2-tuple to be returned for each
+match. The second element is a textual description of where the
+match was found.
+"exts" optionally allows one to specify a list of extensions to use
+instead of the standard list for this system. This can
+effectively be used as an optimization to, for example, avoid
+stat's of "foo.vbs" when searching for "foo" and you know it is
+not a VisualBasic script but ".vbs" is on PATHEXT. This option
+is only supported on Windows.
+This method returns a generator which yields either full paths to
+the given command or, if verbose, tuples of the form (<path to
+command>, <where path found>).
+"""
+matches = []
+if path is None:
+usingGivenPath = 0
+path = os.environ.get("PATH", "").split(os.pathsep)
+if sys.platform.startswith("win"):
+path.insert(0, os.curdir)  # implied by Windows shell
+else:
+usingGivenPath = 1
+# Windows has the concept of a list of extensions (PATHEXT env var).
+if sys.platform.startswith("win"):
+if exts is None:
+exts = os.environ.get("PATHEXT", "").split(os.pathsep)
+# If '.exe' is not in exts then obviously this is Win9x and
+# or a bogus PATHEXT, then use a reasonable default.
+for ext in exts:
+if ext.lower() == ".exe":
+break
+else:
+exts = ['.COM', '.EXE', '.BAT']
+elif not isinstance(exts, list):
+raise TypeError("'exts' argument must be a list or None")
+else:
+if exts is not None:
+raise WhichError("'exts' argument is not supported on "\
+"platform '%s'" % sys.platform)
+exts = []
+# File name cannot have path separators because PATH lookup does not
+# work that way.
+if os.sep in command or os.altsep and os.altsep in command:
+pass
+else:
+for i in range(len(path)):
+dirName = path[i]
+# On windows the dirName *could* be quoted, drop the quotes
+if sys.platform.startswith("win") and len(dirName) >= 2\
+and dirName[0] == '"' and dirName[-1] == '"':
+dirName = dirName[1:-1]
+for ext in ['']+exts:
+absName = os.path.abspath(
+os.path.normpath(os.path.join(dirName, command+ext)))
+if os.path.isfile(absName):
+if usingGivenPath:
+fromWhere = "from given path element %d" % i
+elif not sys.platform.startswith("win"):
+fromWhere = "from PATH element %d" % i
+elif i == 0:
+fromWhere = "from current directory"
+else:
+fromWhere = "from PATH element %d" % (i-1)
+match = _cull((absName, fromWhere), matches, verbose)
+if match:
+if verbose:
+yield match
+else:
+yield match[0]
+match = _getRegisteredExecutable(command)
+if match is not None:
+match = _cull(match, matches, verbose)
+if match:
+if verbose:
+yield match
+else:
+yield match[0]
+def which(command, path=None, verbose=0, exts=None):
+"""Return the full path to the first match of the given command on
+the path.
+"command" is a the name of the executable to search for.
+"path" is an optional alternate path list to search. The default it
+to use the PATH environment variable.
+"verbose", if true, will cause a 2-tuple to be returned. The second
+element is a textual description of where the match was found.
+"exts" optionally allows one to specify a list of extensions to use
+instead of the standard list for this system. This can
+effectively be used as an optimization to, for example, avoid
+stat's of "foo.vbs" when searching for "foo" and you know it is
+not a VisualBasic script but ".vbs" is on PATHEXT. This option
+is only supported on Windows.
+If no match is found for the command, a WhichError is raised.
+"""
+try:
+match = whichgen(command, path, verbose, exts).next()
+except StopIteration:
+raise WhichError("Could not find '%s' on the path." % command)
+return match
+def whichall(command, path=None, verbose=0, exts=None):
+"""Return a list of full paths to all matches of the given command
+on the path.
+"command" is a the name of the executable to search for.
+"path" is an optional alternate path list to search. The default it
+to use the PATH environment variable.
+"verbose", if true, will cause a 2-tuple to be returned for each
+match. The second element is a textual description of where the
+match was found.
+"exts" optionally allows one to specify a list of extensions to use
+instead of the standard list for this system. This can
+effectively be used as an optimization to, for example, avoid
+stat's of "foo.vbs" when searching for "foo" and you know it is
+not a VisualBasic script but ".vbs" is on PATHEXT. This option
+is only supported on Windows.
+"""
+return list( whichgen(command, path, verbose, exts) )
+#---- mainline
+def main(argv):
+all = 0
+verbose = 0
+altpath = None
+exts = None
+try:
+optlist, args = getopt.getopt(argv[1:], 'haVvqp:e:',
+['help', 'all', 'version', 'verbose', 'quiet', 'path=', 'exts='])
+except getopt.GetoptError, msg:
+sys.stderr.write("which: error: %s. Your invocation was: %s\n"\
+% (msg, argv))
+sys.stderr.write("Try 'which --help'.\n")
+return 1
+for opt, optarg in optlist:
+if opt in ('-h', '--help'):
+print _cmdlnUsage
+return 0
+elif opt in ('-V', '--version'):
+print "which %s" % __version__
+return 0
+elif opt in ('-a', '--all'):
+all = 1
+elif opt in ('-v', '--verbose'):
+verbose = 1
+elif opt in ('-q', '--quiet'):
+verbose = 0
+elif opt in ('-p', '--path'):
+if optarg:
+altpath = optarg.split(os.pathsep)
+else:
+altpath = []
+elif opt in ('-e', '--exts'):
+if optarg:
+exts = optarg.split(os.pathsep)
+else:
+exts = []
+if len(args) == 0:
+return -1
+failures = 0
+for arg in args:
+#print "debug: search for %r" % arg
+nmatches = 0
+for match in whichgen(arg, path=altpath, verbose=verbose, exts=exts):
+if verbose:
+print "%s (%s)" % match
+else:
+print match
+nmatches += 1
+if not all:
+break
+if not nmatches:
+failures += 1
+return failures
+if __name__ == "__main__":
+sys.exit( main(sys.argv) )

The Tor Browser / file comparison

comparison: python/which/which.py

python/which/which.py