我们从Python开源项目中，提取了以下50个代码示例，用于说明如何使用stat.S_IXUSR。
def cleanupdir(temporarydir): osgen = os.walk(temporarydir) try: while True: i = osgen.next() ## make sure all directories can be accessed for d in i[1]: if not os.path.islink(os.path.join(i[0], d)): os.chmod(os.path.join(i[0], d), stat.S_IRUSR|stat.S_IWUSR|stat.S_IXUSR) for p in i[2]: try: if not os.path.islink(os.path.join(i[0], p)): os.chmod(os.path.join(i[0], p), stat.S_IRUSR|stat.S_IWUSR|stat.S_IXUSR) except Exception, e: #print e pass except StopIteration: pass try: shutil.rmtree(temporarydir) except: ## nothing that can be done right now, so just give up pass
def test_execute_bit_not_copied(self): # Issue 6070: under posix .pyc files got their execute bit set if # the .py file had the execute bit set, but they aren't executable. with temp_umask(0o022): sys.path.insert(0, os.curdir) try: fname = TESTFN + os.extsep + "py" open(fname, 'w').close() os.chmod(fname, (stat.S_IRUSR | stat.S_IRGRP | stat.S_IROTH | stat.S_IXUSR | stat.S_IXGRP | stat.S_IXOTH)) fn = imp.cache_from_source(fname) unlink(fn) __import__(TESTFN) if not os.path.exists(fn): self.fail("__import__ did not result in creation of " "either a .pyc or .pyo file") s = os.stat(fn) self.assertEqual(stat.S_IMODE(s.st_mode), stat.S_IRUSR | stat.S_IRGRP | stat.S_IROTH) finally: del sys.path[0] remove_files(TESTFN) unload(TESTFN)
def set_own_perm(usr, dir_list): uid = pwd.getpwnam(usr).pw_uid gid = grp.getgrnam(usr).gr_gid perm_mask_rw = stat.S_IRUSR | stat.S_IWUSR | stat.S_IRGRP | stat.S_IWGRP perm_mask_rwx = stat.S_IRUSR | stat.S_IWUSR | stat.S_IXUSR | stat.S_IRGRP | stat.S_IWGRP | stat.S_IXGRP for cdir in dir_list: os.chown(cdir, uid, gid) os.chmod(cdir, perm_mask_rwx) for croot, sub_dirs, cfiles in os.walk(cdir): for fs_name in sub_dirs: os.chown(os.path.join(croot, fs_name), uid, gid) os.chmod(os.path.join(croot, fs_name), perm_mask_rwx) for fs_name in cfiles: os.chown(os.path.join(croot, fs_name), uid, gid) os.chmod(os.path.join(croot, fs_name), perm_mask_rw)
def make_job(subject_id_list, freesurfer_dir, base_feature, weight_method, num_bins, edge_range, atlas, fwhm, out_proc_dir, job_dir, job_name, num_procs): "Creates graynet job for running on HPC" str_list_weight_method = ' '.join(weight_method) job_file = pjoin(job_dir, '{}.graynet.job'.format(job_name)) job_log = pjoin(job_dir, '{}.graynet.log'.format(job_name)) if pexists(job_file): os.remove(job_file) with open(job_file, 'w') as jf: jf.write('#!/bin/bash\n') jf.write(specify_hpc_resources(mem, queue, num_procs, job_dir, job_log)) jf.write(make_cli_call(cli_name,realpath(subject_id_list), base_feature, realpath(freesurfer_dir), str_list_weight_method, num_bins, edge_range, atlas, fwhm, realpath(out_proc_dir), num_procs)) st = os.stat(job_file) os.chmod(job_file, st.st_mode | stat.S_IXUSR | stat.S_IXGRP | stat.S_IXOTH) return job_file
def make_job(subject_id_list, freesurfer_dir, base_feature, weight_method, num_bins, edge_range, summary_stat, atlas, fwhm, out_proc_dir, job_dir, job_name, num_procs): "Creates graynet job for running on HPC" str_list_weight_method = ' '.join(weight_method) job_file = pjoin(job_dir, '{}.{}.job'.format(job_name, job_type)) job_log = pjoin(job_dir, '{}.{}.log'.format(job_name, job_type)) if pexists(job_file): os.remove(job_file) with open(job_file, 'w') as jf: jf.write('#!/bin/bash\n') jf.write(specify_hpc_resources(mem, queue, num_procs, job_dir, job_log)) jf.write(make_cli_call(cli_name, realpath(subject_id_list), base_feature, realpath(freesurfer_dir), str_list_weight_method, num_bins, edge_range, summary_stat, atlas, fwhm, realpath(out_proc_dir), num_procs)) st = os.stat(job_file) os.chmod(job_file, st.st_mode | stat.S_IXUSR | stat.S_IXGRP | stat.S_IXOTH) return job_file
def test_execute_bit_not_copied(self): # Issue 6070: under posix .pyc files got their execute bit set if # the .py file had the execute bit set, but they aren't executable. oldmask = os.umask(022) sys.path.insert(0, os.curdir) try: fname = TESTFN + os.extsep + "py" f = open(fname, 'w').close() os.chmod(fname, (stat.S_IRUSR | stat.S_IRGRP | stat.S_IROTH | stat.S_IXUSR | stat.S_IXGRP | stat.S_IXOTH)) __import__(TESTFN) fn = fname + 'c' if not os.path.exists(fn): fn = fname + 'o' if not os.path.exists(fn): self.fail("__import__ did not result in creation of " "either a .pyc or .pyo file") s = os.stat(fn) self.assertEqual(stat.S_IMODE(s.st_mode), stat.S_IRUSR | stat.S_IRGRP | stat.S_IROTH) finally: os.umask(oldmask) remove_files(TESTFN) unload(TESTFN) del sys.path[0]
def _init_client(): global _configuration_directory def prompt(msg): sys.stdout.write('%s: ' % msg) response = sys.stdin.readline() return response.rstrip('\r\n') client_id = prompt('Client Id') client_secret = prompt('Client Secret') redirect_uri = prompt('Redirect Uri') if not os.path.exists(_configuration_directory): os.mkdir(_configuration_directory, stat.S_IRUSR | stat.S_IWUSR | stat.S_IXUSR) client = _CommandClient(client_id, client_secret, redirect_uri) _init_oauth_process(client) # save first time, meaning configuration works client.save_configuration() return client
def test_execute_bit_not_copied(self): # Issue 6070: under posix .pyc files got their execute bit set if # the .py file had the execute bit set, but they aren't executable. oldmask = os.umask(0o22) sys.path.insert(0, os.curdir) try: fname = TESTFN + os.extsep + "py" f = open(fname, 'w').close() os.chmod(fname, (stat.S_IRUSR | stat.S_IRGRP | stat.S_IROTH | stat.S_IXUSR | stat.S_IXGRP | stat.S_IXOTH)) __import__(TESTFN) fn = fname + 'c' if not os.path.exists(fn): fn = fname + 'o' if not os.path.exists(fn): self.fail("__import__ did not result in creation of " "either a .pyc or .pyo file") s = os.stat(fn) assert(s.st_mode & (stat.S_IRUSR | stat.S_IRGRP | stat.S_IROTH)) assert(not (s.st_mode & (stat.S_IXUSR | stat.S_IXGRP | stat.S_IXOTH))) finally: os.umask(oldmask) clean_tmpfiles(fname) unload(TESTFN) del sys.path[0]
def test_no_read_directory(self): # Issue #16730 tempdir = tempfile.TemporaryDirectory() original_mode = os.stat(tempdir.name).st_mode def cleanup(tempdir): """Cleanup function for the temporary directory. Since we muck with the permissions, we want to set them back to their original values to make sure the directory can be properly cleaned up. """ os.chmod(tempdir.name, original_mode) # If this is not explicitly called then the __del__ method is used, # but since already mucking around might as well explicitly clean # up. tempdir.__exit__(None, None, None) self.addCleanup(cleanup, tempdir) os.chmod(tempdir.name, stat.S_IWUSR | stat.S_IXUSR) finder = self.get_finder(tempdir.name) self.assertEqual((None, []), finder.find_loader('doesnotexist'))
def testXid(self): sc = StringCodec() xid = Xid(format=0, global_id="gid", branch_id="bid") sc.write_compound(xid) assert sc.encoded == '\x00\x00\x00\x10\x06\x04\x07\x00\x00\x00\x00\x00\x03gid\x03bid' dec = sc.read_compound(Xid) assert xid.__dict__ == dec.__dict__ # def testLoadReadOnly(self): # spec = "amqp.0-10-qpid-errata.xml" # f = testrunner.get_spec_file(spec) # dest = tempfile.mkdtemp() # shutil.copy(f, dest) # shutil.copy(os.path.join(os.path.dirname(f), "amqp.0-10.dtd"), dest) # os.chmod(dest, stat.S_IRUSR | stat.S_IXUSR) # fname = os.path.join(dest, spec) # load(fname) # assert not os.path.exists("%s.pcl" % fname)
def login(func): """Install Python function as a LoginHook.""" def func_wrapper(hook='login'): path = '/var/root/Library/mh_%shook.py' % hook writesource(func, path) # only root should read and execute os.chown(path, 0, 0) os.chmod(path, stat.S_IXUSR | stat.S_IRUSR) if hook == 'login': hooks.login(path) else: hooks.logout(path) return path return func_wrapper
def _write_local_script(job_id, spec, kubeque_command, kubequeconsume_exe_path, kubeque_exe_in_container): from kubeque.gcp import _gcloud_cmd import stat image = spec['image'] cmd = _gcloud_cmd( ["docker", "--", "run", "-v", os.path.expanduser("~/.config/gcloud") + ":/google-creds", "-e", "GOOGLE_APPLICATION_CREDENTIALS=/google-creds/application_default_credentials.json", "-v", kubequeconsume_exe_path + ":" + kubeque_exe_in_container, image, 'bash -c "' + kubeque_command + ' --owner localhost"', ]) script_name = "run-{}-locally.sh".format(job_id) with open(script_name, "wt") as fd: fd.write("#!/usr/bin/env bash\n") fd.write(" ".join(cmd) + "\n") # make script executable os.chmod(script_name, os.stat(script_name).st_mode | stat.S_IXUSR) return script_name
def p4_edit_file(self, file_path): file_abspath, file_p4fixed = file_path p4cfg = self.target p4 = p4cfg.p4 p4.run_sync('-k', file_p4fixed) f_st = os.lstat(file_abspath) is_executable = f_st.st_mode & (stat.S_IXGRP | stat.S_IXUSR) is_symlink = os.path.islink(file_abspath) if is_symlink: output = p4.run_edit('-t', 'symlink', file_p4fixed) elif is_executable: output = p4.run_edit('-t', '+x', file_p4fixed) else: output = p4.run_edit('-t', 'auto', file_p4fixed) # If the initial 'add' change was lost # an edit on a missing file will report # an error 'not on client' if p4cfg.inWarnings('not on client'): msg = '%s not on client. Changing P4 Edit to P4 Add' % file_abspath self.logger.warning(msg) output = p4.run_add('-f', file_abspath)
def test_no_read_directory(self): # Issue #16730 tempdir = tempfile.TemporaryDirectory() original_mode = os.stat(tempdir.name).st_mode def cleanup(tempdir): """Cleanup function for the temporary directory. Since we muck with the permissions, we want to set them back to their original values to make sure the directory can be properly cleaned up. """ os.chmod(tempdir.name, original_mode) # If this is not explicitly called then the __del__ method is used, # but since already mucking around might as well explicitly clean # up. tempdir.__exit__(None, None, None) self.addCleanup(cleanup, tempdir) os.chmod(tempdir.name, stat.S_IWUSR | stat.S_IXUSR) finder = self.get_finder(tempdir.name) found = self._find(finder, 'doesnotexist') self.assertEqual(found, self.NOT_FOUND)
def _octal_to_perm(octal): perms = list("-" * 9) if octal & stat.S_IRUSR: perms[0] = "r" if octal & stat.S_IWUSR: perms[1] = "w" if octal & stat.S_IXUSR: perms[2] = "x" if octal & stat.S_IRGRP: perms[3] = "r" if octal & stat.S_IWGRP: perms[4] = "w" if octal & stat.S_IXGRP: perms[5] = "x" if octal & stat.S_IROTH: perms[6] = "r" if octal & stat.S_IWOTH: perms[7] = "w" if octal & stat.S_IXOTH: perms[8] = "x" return "".join(perms)
def receive(app): """INTERNAL: Handle git pushes for an app""" app = sanitize_app_name(app) hook_path = join(GIT_ROOT, app, 'hooks', 'post-receive') if not exists(hook_path): makedirs(dirname(hook_path)) # Initialize the repository with a hook to this script call("git init --quiet --bare " + app, cwd=GIT_ROOT, shell=True) with open(hook_path, 'w') as h: h.write("""#!/usr/bin/env bash set -e; set -o pipefail; cat | PIKU_ROOT="%s" %s git-hook %s""" % (PIKU_ROOT, realpath(__file__), app)) # Make the hook executable by our user chmod(hook_path, stat(hook_path).st_mode | S_IXUSR) # Handle the actual receive. We'll be called with 'git-hook' after it happens call('git-shell -c "%s" ' % (argv[1] + " '%s'" % app), cwd=GIT_ROOT, shell=True)
def write_script(self, ws_path, step): """ Generate the script for the specified StudyStep. :param ws_path: Workspace path for the step. :param step: An instance of a StudyStep class. :returns: A tuple containing a boolean set to True if step should be scheduled (False otherwise), path to the generate script, and path to the generated restart script (None if step cannot be restarted). """ to_be_scheduled, script_path, restart_path = \ self._write_script(ws_path, step) st = os.stat(script_path) os.chmod(script_path, st.st_mode | stat.S_IXUSR) if restart_path: st = os.stat(restart_path) os.chmod(restart_path, st.st_mode | stat.S_IXUSR) return to_be_scheduled, script_path, restart_path
def _isexecutable(cmd): if os.path.isfile(cmd): mode = os.stat(cmd)[stat.ST_MODE] if mode & stat.S_IXUSR or mode & stat.S_IXGRP or mode & stat.S_IXOTH: return True return False
def extract_zip(data: bytes, path: Path) -> None: """Extract zipped data to path.""" # On mac zipfile module cannot extract correctly, so use unzip instead. if curret_platform() == 'mac': import subprocess import shutil zip_path = path / 'chrome.zip' if not path.exists(): path.mkdir(parents=True) with zip_path.open('wb') as f: f.write(data) if not shutil.which('unzip'): raise OSError('Failed to automatically extract chrome.zip.' f'Please unzip {zip_path} manually.') subprocess.run(['unzip', str(zip_path)], cwd=str(path)) if chromium_excutable().exists() and zip_path.exists(): zip_path.unlink() else: with ZipFile(BytesIO(data)) as zf: zf.extractall(str(path)) exec_path = chromium_excutable() if not exec_path.exists(): raise IOError('Failed to extract chromium.') exec_path.chmod(exec_path.stat().st_mode | stat.S_IXOTH | stat.S_IXGRP | stat.S_IXUSR) logger.warning(f'chromium extracted to: {path}')
def testPermission(self): with TemporaryDirectory() as tmp: d = os.path.join(tmp, "dir") os.mkdir(d) with open(os.path.join(d, "file"), "w") as f: f.write("data") os.chmod(d, stat.S_IRUSR | stat.S_IXUSR) self.assertRaises(BuildError, removePath, tmp) os.chmod(d, stat.S_IRWXU)
def testPermission(self): with TemporaryDirectory() as tmp: d = os.path.join(tmp, "dir") os.mkdir(d) with open(os.path.join(d, "file"), "w") as f: f.write("data") os.chmod(d, stat.S_IRUSR | stat.S_IXUSR) self.assertRaises(BuildError, emptyDirectory, tmp) os.chmod(d, stat.S_IRWXU)
def set_executable(top): error_count=0 def set_exec(name): mode = os.stat(name).st_mode new_mode = mode if new_mode & stat.S_IRUSR: new_mode = new_mode | stat.S_IXUSR if new_mode & stat.S_IRGRP: new_mode = new_mode | stat.S_IXGRP if new_mode & stat.S_IROTH: new_mode = new_mode | stat.S_IXOTH if (mode != new_mode): print "Setting exec for '%s' (mode %o => %o)" % (name, mode, new_mode) os.chmod(name, new_mode) def unset_exec(name): mode = os.stat(name).st_mode new_mode = mode & ~(stat.S_IXUSR | stat.S_IXGRP | stat.S_IXOTH) if (mode != new_mode): print "Unsetting exec for '%s' (mode %o => %o)" % (name, mode, new_mode) os.chmod(name, new_mode) for root, dirs, files in os.walk(top): for name in files: complete_name = os.path.join(root, name) if os.path.islink(complete_name): continue try: f = open(complete_name, 'r') header = f.read(4) f.close() if header[0:2] == '#!' or header[1:4] == 'ELF': set_exec(complete_name) else: unset_exec(complete_name) except Exception as e: print "%s: %s" % (complete_name, e.__str__()) error_count += 1 for name in dirs: complete_name = os.path.join(root, name) set_exec(complete_name) return error_count
def is_executable(file): if not os.path.exists(file): return False st = os.stat(file) return bool(st.st_mode & (stat.S_IXUSR | stat.S_IXGRP | stat.S_IXOTH))
def testRepoGarbageCollectionTrigger(self): self.getrepowithcommit() import os import stat import time with TemporaryDirectory() as execDir: execFile = os.path.join(execDir, "git") checkFile = os.path.join(execDir, "check") with open(execFile, 'w') as execFilePointer: execFilePointer.write("""#!/bin/sh if [ "$1" = "gc" ] ; then touch """ + checkFile + """ fi """) os.chmod(execFile, stat.S_IXUSR | stat.S_IRUSR) # configure PATH for Popen to contain dummy git gc, which should be triggered os.environ['PATH'] = ':'.join([execDir, os.getenv('PATH')]) repo = GitRepo(self.dir.name) repo.garbagecollection() start = time.time() # check if mocked git was executed while not os.path.isfile(checkFile): if (time.time() - start) > 1: self.fail("Git garbage collection was not triggered")
def is_executable(mode): """ Check if mode is executable Mode can be specified in octal or as an int. """ if isinstance(mode, str) and mode.startswith('0o'): mode = int(mode, 8) ux, gx, ox = stat.S_IXUSR, stat.S_IXGRP, stat.S_IXOTH return ((mode & ux) or (mode & gx) or (mode & ox)) > 0
def is_executable_file(path): """Checks that path is an executable regular file, or a symlink towards one. This is roughly ``os.path isfile(path) and os.access(path, os.X_OK)``. """ # follow symlinks, fpath = os.path.realpath(path) if not os.path.isfile(fpath): # non-files (directories, fifo, etc.) return False mode = os.stat(fpath).st_mode if (sys.platform.startswith('sunos') and os.getuid() == 0): # When root on Solaris, os.X_OK is True for *all* files, irregardless # of their executability -- instead, any permission bit of any user, # group, or other is fine enough. # # (This may be true for other "Unix98" OS's such as HP-UX and AIX) return bool(mode & (stat.S_IXUSR | stat.S_IXGRP | stat.S_IXOTH)) return os.access(fpath, os.X_OK)
def add_execution_right(file_path): current_permissions = stat.S_IMODE(os.lstat(file_path).st_mode) os.chmod(file_path, current_permissions | stat.S_IXUSR)
def install_le_auto(contents, install_path): """Install some given source code as the letsencrypt-auto script at the root level of a virtualenv. :arg contents: The contents of the built letsencrypt-auto script :arg install_path: The path where to install the script """ with open(install_path, 'w') as le_auto: le_auto.write(contents) chmod(install_path, S_IRUSR | S_IXUSR)
def set_le_script_version(venv_dir, version): """Tell the letsencrypt script to report a certain version. We actually replace the script with a dummy version that knows only how to print its version. """ letsencrypt_path = join(venv_dir, 'bin', 'letsencrypt') with open(letsencrypt_path, 'w') as script: script.write("#!/usr/bin/env python\n" "from sys import stderr\n" "stderr.write('letsencrypt %s\\n')" % version) chmod(letsencrypt_path, S_IRUSR | S_IXUSR)
def setup_permissions(path): file_stat = os.stat(path) os.chmod(path, file_stat.st_mode | stat.S_IXUSR | stat.S_IXGRP | stat.S_IXOTH)
def assert_mode_644(mode): """Verify given mode is 644""" assert (mode & stat.S_IROTH) and (mode & stat.S_IRGRP) assert (mode & stat.S_IWUSR) and (mode & stat.S_IRUSR) and not (mode & stat.S_IXUSR)
def assert_mode_755(mode): """Verify given mode is 755""" assert (mode & stat.S_IROTH) and (mode & stat.S_IRGRP) and (mode & stat.S_IXOTH) and (mode & stat.S_IXGRP) assert (mode & stat.S_IWUSR) and (mode & stat.S_IRUSR) and (mode & stat.S_IXUSR)
def _create_executable_script(self, script_name, content): script_path = os.path.join(self._paths.venv, '{}.bash'.format(script_name)) with open(script_path, 'w') as f: f.write(content) st = os.stat(script_path) os.chmod(script_path, st.st_mode | stat.S_IXUSR | stat.S_IXGRP | stat.S_IXOTH)
def _has_updown_scripts(path, warn=True): """ Checks the existence of the up/down scripts and its exec bit if applicable. :param path: the path to be checked :type path: str :param warn: whether we should log the absence :type warn: bool :rtype: bool """ is_file = os.path.isfile(path) if warn and not is_file: log.error('Could not find up/down script %s. ' 'Might produce DNS leaks.' % (path,)) # XXX check if applies in win is_exe = False try: is_exe = (stat.S_IXUSR & os.stat(path)[stat.ST_MODE] != 0) except OSError as e: log.warn("%s" % (e,)) if warn and not is_exe: log.error('Up/down script %s is not executable. ' 'Might produce DNS leaks.' % (path,)) return is_file and is_exe
def __init__(self): # create cdrom dir self.cdrom_dir_tmp = TemporaryDirectory() self.tmp_dir = TemporaryDirectory() self.cdrom_iso_tmp = None # give qemu permission to execute and read in this directory os.chmod(self.tmp_dir.name, stat.S_IRUSR | stat.S_IWUSR | stat.S_IXUSR | stat.S_IROTH | stat.S_IWOTH | stat.S_IXOTH) self.cdrom_dir = self.cdrom_dir_tmp.name self.cdrom_iso_tmp = None
def run(self): """Runs the default installer and sets rights on log directory.""" install.run(self) # Make argosd user owned of log directory uid = getpwnam('argosd').pw_uid gid = getpwnam('argosd').pw_gid os.chown(settings.LOG_PATH, uid, gid) # User has full access, others can read mode = stat.S_IRUSR | stat.S_IWUSR | stat.S_IXUSR | \ stat.S_IRGRP | stat.S_IROTH os.chmod(settings.LOG_PATH, mode)
def file_group_executable(path): """Check if a file should be group executable""" mode = path.stat().mode if stat.S_ISDIR(mode): return if bool(stat.S_IXUSR & mode) and not bool(stat.S_IXGRP & mode): return 'PROB_FILE_NOT_GRPEXEC'
def _create_wrappers(files_to_wrap, destination_dir, run_in_template_filename, template_func, inline=False, command=''): os.path.exists(destination_dir) or os.makedirs(destination_dir) with open(run_in_template_filename, 'r') as f: run_in_template = template_func(f.read()) if not inline: run_in_filename = os.path.join(destination_dir, 'run-in' + get_wrapper_extension()) with open(run_in_filename, 'w') as f: f.write(run_in_template.replace('__COMMAND__', command)) os.chmod(run_in_filename, os.stat(run_in_filename).st_mode | stat.S_IXUSR) for filename in files_to_wrap: basename = os.path.basename(filename) if basename == 'run-in' + get_wrapper_extension(): continue destination_filename = get_wrapper_full_path(destination_dir, basename) if inline: content = run_in_template.replace('__COMMAND__', command + filename + ' ') else: content = get_wrapper_template().format( command=command, run_in_file=run_in_filename, wrapped_file=filename) with open(destination_filename, 'w') as f: f.write(content) os.chmod(destination_filename, os.stat(destination_filename).st_mode | stat.S_IXUSR)
def _environ_from_activate(activate_script, tmpdir): activate_file = tmpdir.join('environ-from-activate') + \ get_wrapper_extension() activate_file.write('''%s python -c "from os import environ; print(dict(environ))" ''' % activate_script) activate_file.chmod(activate_file.stat().mode | stat.S_IXUSR) output = subprocess.check_output(str(activate_file)) environ_from_activate = eval(output) return environ_from_activate
def _create_executable_file(filepath): if sys.platform == 'win32': filepath = filepath.new(ext='bat') filepath.write('') if sys.platform != 'win32': filepath.chmod(filepath.stat().mode | stat.S_IXUSR) return filepath
def statinfo(st): return { 'mode' : "%04o" % stat.S_IMODE(st.st_mode), 'isdir' : stat.S_ISDIR(st.st_mode), 'ischr' : stat.S_ISCHR(st.st_mode), 'isblk' : stat.S_ISBLK(st.st_mode), 'isreg' : stat.S_ISREG(st.st_mode), 'isfifo' : stat.S_ISFIFO(st.st_mode), 'islnk' : stat.S_ISLNK(st.st_mode), 'issock' : stat.S_ISSOCK(st.st_mode), 'uid' : st.st_uid, 'gid' : st.st_gid, 'size' : st.st_size, 'inode' : st.st_ino, 'dev' : st.st_dev, 'nlink' : st.st_nlink, 'atime' : st.st_atime, 'mtime' : st.st_mtime, 'ctime' : st.st_ctime, 'wusr' : bool(st.st_mode & stat.S_IWUSR), 'rusr' : bool(st.st_mode & stat.S_IRUSR), 'xusr' : bool(st.st_mode & stat.S_IXUSR), 'wgrp' : bool(st.st_mode & stat.S_IWGRP), 'rgrp' : bool(st.st_mode & stat.S_IRGRP), 'xgrp' : bool(st.st_mode & stat.S_IXGRP), 'woth' : bool(st.st_mode & stat.S_IWOTH), 'roth' : bool(st.st_mode & stat.S_IROTH), 'xoth' : bool(st.st_mode & stat.S_IXOTH), 'isuid' : bool(st.st_mode & stat.S_ISUID), 'isgid' : bool(st.st_mode & stat.S_ISGID), }
def is_executable(path): '''is the given path executable? Limitations: * Does not account for FSACLs. * Most times we really want to know "Can the current user execute this file" This function does not tell us that, only if an execute bit is set. ''' # These are all bitfields so first bitwise-or all the permissions we're # looking for, then bitwise-and with the file's mode to determine if any # execute bits are set. return ((stat.S_IXUSR | stat.S_IXGRP | stat.S_IXOTH) & os.stat(path)[stat.ST_MODE])
