code string | signature string | docstring string | loss_without_docstring float64 | loss_with_docstring float64 | factor float64 |
|---|---|---|---|---|---|
cmdlist = [cmd]
if verbosity > 1:
cmdlist.append('v')
else:
cmdlist.append('l')
cmdlist.append(archive)
return cmdlist | def list_lzh (archive, compression, cmd, verbosity, interactive) | List a LZH archive. | 3.410997 | 3.385232 | 1.007611 |
outfile = util.get_single_outfile(outdir, archive, extension=".wav")
return [cmd, archive, outfile, '-d'] | def extract_ape (archive, compression, cmd, verbosity, interactive, outdir) | Decompress an APE archive to a WAV file. | 17.676718 | 11.944559 | 1.479897 |
return [cmd, archive, '-d', outdir] | def extract_adf (archive, compression, cmd, verbosity, interactive, outdir) | Extract an ADF archive. | 23.078583 | 23.229021 | 0.993524 |
cmdlist = [cmd, '-d']
if verbosity > 1:
cmdlist.append('-v')
outfile = util.get_single_outfile(outdir, archive)
cmdlist.extend(["-o", outfile, os.path.abspath(archive)])
return cmdlist | def extract_lrzip (archive, compression, cmd, verbosity, interactive, outdir) | Extract a LRZIP archive. | 4.187282 | 4.201101 | 0.996711 |
return stripext(cmd, archive, verbosity) | def list_bzip2 (archive, compression, cmd, verbosity, interactive) | List a BZIP2 archive. | 65.971817 | 98.84491 | 0.667428 |
return stripext(cmd, archive, verbosity, extension=".wav") | def list_ape (archive, compression, cmd, verbosity, interactive) | List an APE archive. | 96.634254 | 136.753677 | 0.70663 |
if verbosity >= 0:
print(util.stripext(archive)+extension)
return None | def stripext (cmd, archive, verbosity, extension="") | Print the name without suffix. | 10.681758 | 7.475055 | 1.428987 |
opts = 'x'
if verbosity > 1:
opts += 'v'
cmdlist = [cmd, opts, os.path.abspath(archive)]
return (cmdlist, {'cwd': outdir}) | def extract_ar (archive, compression, cmd, verbosity, interactive, outdir) | Extract a AR archive. | 5.527061 | 5.376676 | 1.02797 |
opts = 't'
if verbosity > 1:
opts += 'v'
return [cmd, opts, archive] | def list_ar (archive, compression, cmd, verbosity, interactive) | List a AR archive. | 7.022075 | 6.965822 | 1.008076 |
opts = 'rc'
if verbosity > 1:
opts += 'v'
cmdlist = [cmd, opts, archive]
cmdlist.extend(filenames)
return cmdlist | def create_ar (archive, compression, cmd, verbosity, interactive, filenames) | Create a AR archive. | 5.150222 | 4.740026 | 1.086539 |
cmdlist = [cmd, '-d', outdir]
if verbosity > 0:
cmdlist.append('-v')
cmdlist.append(archive)
return cmdlist | def extract_cab (archive, compression, cmd, verbosity, interactive, outdir) | Extract a CAB archive. | 3.467714 | 3.441693 | 1.00756 |
cmdlist = [cmd, '-l']
if verbosity > 0:
cmdlist.append('-v')
cmdlist.append(archive)
return cmdlist | def list_cab (archive, compression, cmd, verbosity, interactive) | List a CAB archive. | 3.377882 | 3.383836 | 0.998241 |
cmdlist = [cmd, '-d', '-k']
if verbosity > 1:
cmdlist.append('-v')
outfile = util.get_single_outfile(outdir, archive)
cmdlist.extend(["-o", outfile, archive])
return cmdlist | def extract_rzip (archive, compression, cmd, verbosity, interactive, outdir) | Extract an RZIP archive. | 4.355125 | 4.314899 | 1.009323 |
if program in ('tar', ):
return compression in ('gzip', 'bzip2', 'xz', 'lzip', 'compress', 'lzma') + py_lzma
elif program in ('star', 'bsdtar', 'py_tarfile'):
return compression in ('gzip', 'bzip2') + py_lzma
return False | def program_supports_compression (program, compression) | Decide if the given program supports the compression natively.
@return: True iff the program supports the given compression format
natively, else False. | 6.856938 | 6.925399 | 0.990115 |
mime, compression = util.guess_mime(filename)
if not (mime or compression):
raise util.PatoolError("unknown archive format for file `%s'" % filename)
if mime in ArchiveMimetypes:
format = ArchiveMimetypes[mime]
else:
raise util.PatoolError("unknown archive format for file `%... | def get_archive_format (filename) | Detect filename archive format and optional compression. | 4.876785 | 4.569541 | 1.067237 |
if format not in ArchiveFormats:
raise util.PatoolError("unknown archive format `%s'" % format)
if compression is not None and compression not in ArchiveCompressions:
raise util.PatoolError("unkonwn archive compression `%s'" % compression) | def check_archive_format (format, compression) | Make sure format and compression is known. | 3.874162 | 3.431456 | 1.129014 |
commands = ArchivePrograms[format]
programs = []
if program is not None:
# try a specific program first
programs.append(program)
# first try the universal programs with key None
for key in (None, command):
if key in commands:
programs.extend(commands[key])
... | def find_archive_program (format, command, program=None) | Find suitable archive program for given format and mode. | 5.506076 | 5.401168 | 1.019423 |
print("Archive programs of", App)
print("Archive programs are searched in the following directories:")
print(util.system_search_path())
print()
for format in ArchiveFormats:
print(format, "files:")
for command in ArchiveCommands:
programs = ArchivePrograms[format]
... | def list_formats () | Print information about available archive formats to stdout. | 5.283613 | 5.087169 | 1.038616 |
program = os.path.basename(program)
if compression:
# check if compression is supported
if not program_supports_compression(program, compression):
if command == 'create':
comp_command = command
else:
comp_command = 'extract'
... | def check_program_compression(archive, command, program, compression) | Check if a program supports the given compression. | 4.210064 | 4.278527 | 0.983999 |
entries = os.listdir(outdir)
if len(entries) == 1:
src = os.path.join(outdir, entries[0])
dst = os.path.join(os.path.dirname(outdir), entries[0])
if os.path.exists(dst) or os.path.islink(dst):
return (False, "local file exists")
shutil.move(src, dst)
os.r... | def move_outdir_orphan (outdir) | Move a single file or directory inside outdir a level up.
Never overwrite files.
Return (True, outfile) if successful, (False, reason) if not. | 2.41282 | 2.229447 | 1.08225 |
# archive_cmdlist is a command list with optional keyword arguments
if isinstance(archive_cmdlist, tuple):
cmdlist, runkwargs = archive_cmdlist
else:
cmdlist, runkwargs = archive_cmdlist, {}
return util.run_checked(cmdlist, verbosity=verbosity, **runkwargs) | def run_archive_cmdlist (archive_cmdlist, verbosity=0) | Run archive command. | 4.073823 | 3.953458 | 1.030445 |
if not os.path.islink(filename):
util.set_mode(filename, stat.S_IRUSR) | def make_file_readable (filename) | Make file user readable if it is not a link. | 4.581609 | 3.232358 | 1.41742 |
for root, dirs, files in os.walk(directory, onerror=util.log_error):
for filename in files:
make_file_readable(os.path.join(root, filename))
for dirname in dirs:
make_dir_readable(os.path.join(root, dirname)) | def make_user_readable (directory) | Make all files in given directory user readable. Also recurse into
subdirectories. | 2.265985 | 2.193091 | 1.033238 |
make_user_readable(outdir)
# move single directory or file in outdir
(success, msg) = move_outdir_orphan(outdir)
if success:
# msg is a single directory or filename
return msg, "`%s'" % msg
# outdir remains unchanged
# rename it to something more user-friendly (basically the... | def cleanup_outdir (outdir, archive) | Cleanup outdir after extraction and return target file name and
result string. | 9.453372 | 9.103266 | 1.038459 |
if format is None:
format, compression = get_archive_format(archive)
check_archive_format(format, compression)
program = find_archive_program(format, 'extract', program=program)
check_program_compression(archive, 'extract', program, compression)
get_archive_cmdlist = get_archive_cmdlist... | def _extract_archive(archive, verbosity=0, interactive=True, outdir=None,
program=None, format=None, compression=None) | Extract an archive.
@return: output directory if command is 'extract', else None | 3.879462 | 3.907402 | 0.99285 |
if format is None:
format, compression = get_archive_format(archive)
check_archive_format(format, compression)
program = find_archive_program(format, 'create', program=program)
check_program_compression(archive, 'create', program, compression)
get_archive_cmdlist = get_archive_cmdlist_f... | def _create_archive(archive, filenames, verbosity=0, interactive=True,
program=None, format=None, compression=None) | Create an archive. | 4.463144 | 4.494586 | 0.993004 |
if format is None:
format, compression = get_archive_format(archive)
check_archive_format(format, compression)
if command not in ('list', 'test'):
raise util.PatoolError("invalid archive command `%s'" % command)
program = find_archive_program(format, command, program=program)
ch... | def _handle_archive(archive, command, verbosity=0, interactive=True,
program=None, format=None, compression=None) | Test and list archives. | 4.847889 | 4.831723 | 1.003346 |
# get python module for given archive program
key = util.stripext(os.path.basename(program).lower())
modulename = ".programs." + ProgramModules.get(key, key)
# import the module
try:
module = importlib.import_module(modulename, __name__)
except ImportError as msg:
raise util... | def get_archive_cmdlist_func (program, command, format) | Get the Python function that executes the given program. | 5.321344 | 5.54809 | 0.959131 |
msg = "Error in %s(%s): %s" % (func.__name__, path, str(exc[1]))
util.log_error(msg) | def rmtree_log_error (func, path, exc) | Error function for shutil.rmtree(). Raises a PatoolError. | 4.438535 | 4.454053 | 0.996516 |
if util.is_same_file(archive1, archive2):
return 0
diff = util.find_program("diff")
if not diff:
msg = "The diff(1) program is required for showing archive differences, please install it."
raise util.PatoolError(msg)
tmpdir1 = util.tmpdir()
try:
path1 = _extract_... | def _diff_archives (archive1, archive2, verbosity=0, interactive=True) | Show differences between two archives.
@return 0 if archives are the same, else 1
@raises: PatoolError on errors | 3.242328 | 2.992022 | 1.083658 |
grep = util.find_program("grep")
if not grep:
msg = "The grep(1) program is required for searching archive contents, please install it."
raise util.PatoolError(msg)
tmpdir = util.tmpdir()
try:
path = _extract_archive(archive, outdir=tmpdir, verbosity=-1)
return util.... | def _search_archive(pattern, archive, verbosity=0, interactive=True) | Search for given pattern in an archive. | 5.236221 | 5.126387 | 1.021425 |
format1, compression1 = get_archive_format(archive1)
format2, compression2 = get_archive_format(archive2)
if format1 == format2 and compression1 == compression2:
# same format and compression allows to copy the file
util.link_or_copy(archive1, archive2, verbosity=verbosity)
retu... | def _repack_archive (archive1, archive2, verbosity=0, interactive=True) | Repackage an archive to a different format. | 3.072739 | 2.991745 | 1.027073 |
format, compression = get_archive_format(archive)
if compression:
# only recompress the compression itself (eg. for .tar.xz)
format = compression
tmpdir = util.tmpdir()
tmpdir2 = util.tmpdir()
base, ext = os.path.splitext(os.path.basename(archive))
archive2 = util.get_single... | def _recompress_archive(archive, verbosity=0, interactive=True) | Try to recompress an archive to smaller size. | 3.693299 | 3.662635 | 1.008372 |
util.check_existing_filename(archive)
if verbosity >= 0:
util.log_info("Extracting %s ..." % archive)
return _extract_archive(archive, verbosity=verbosity, interactive=interactive, outdir=outdir, program=program) | def extract_archive(archive, verbosity=0, outdir=None, program=None, interactive=True) | Extract given archive. | 3.589395 | 3.590453 | 0.999705 |
# Set default verbosity to 1 since the listing output should be visible.
util.check_existing_filename(archive)
if verbosity >= 0:
util.log_info("Listing %s ..." % archive)
return _handle_archive(archive, 'list', verbosity=verbosity,
interactive=interactive, program=program) | def list_archive(archive, verbosity=1, program=None, interactive=True) | List given archive. | 7.709162 | 7.471518 | 1.031807 |
util.check_new_filename(archive)
util.check_archive_filelist(filenames)
if verbosity >= 0:
util.log_info("Creating %s ..." % archive)
res = _create_archive(archive, filenames, verbosity=verbosity,
interactive=interactive, program=program)
if verbosity >= 0:
... | def create_archive(archive, filenames, verbosity=0, program=None, interactive=True) | Create given archive with given files. | 2.999855 | 2.984551 | 1.005128 |
util.check_existing_filename(archive1)
util.check_existing_filename(archive2)
if verbosity >= 0:
util.log_info("Comparing %s with %s ..." % (archive1, archive2))
res = _diff_archives(archive1, archive2, verbosity=verbosity, interactive=interactive)
if res == 0 and verbosity >= 0:
... | def diff_archives(archive1, archive2, verbosity=0, interactive=True) | Print differences between two archives. | 2.762937 | 2.772002 | 0.99673 |
if not pattern:
raise util.PatoolError("empty search pattern")
util.check_existing_filename(archive)
if verbosity >= 0:
util.log_info("Searching %r in %s ..." % (pattern, archive))
res = _search_archive(pattern, archive, verbosity=verbosity, interactive=interactive)
if res == 1 ... | def search_archive(pattern, archive, verbosity=0, interactive=True) | Search pattern in archive members. | 3.704334 | 3.663782 | 1.011068 |
util.check_existing_filename(archive)
util.check_new_filename(archive_new)
if verbosity >= 0:
util.log_info("Repacking %s to %s ..." % (archive, archive_new))
res = _repack_archive(archive, archive_new, verbosity=verbosity, interactive=interactive)
if verbosity >= 0:
util.log_in... | def repack_archive (archive, archive_new, verbosity=0, interactive=True) | Repack archive to different file and/or format. | 2.794281 | 2.658222 | 1.051184 |
util.check_existing_filename(archive)
util.check_writable_filename(archive)
if verbosity >= 0:
util.log_info("Recompressing %s ..." % (archive,))
res = _recompress_archive(archive, verbosity=verbosity, interactive=interactive)
if res and verbosity >= 0:
util.log_info(res)
re... | def recompress_archive(archive, verbosity=0, interactive=True) | Recompress an archive to hopefully smaller size. | 3.365462 | 3.350877 | 1.004352 |
global mimedb
try:
mimedb = mimetypes.MimeTypes(strict=False)
except Exception as msg:
log_error("could not initialize MIME database: %s" % msg)
return
add_mimedb_data(mimedb) | def init_mimedb() | Initialize the internal MIME database. | 4.495564 | 4.603543 | 0.976544 |
mimedb.encodings_map['.bz2'] = 'bzip2'
mimedb.encodings_map['.lzma'] = 'lzma'
mimedb.encodings_map['.xz'] = 'xz'
mimedb.encodings_map['.lz'] = 'lzip'
mimedb.suffix_map['.tbz2'] = '.tar.bz2'
add_mimetype(mimedb, 'application/x-lzop', '.lzo')
add_mimetype(mimedb, 'application/x-adf', '.ad... | def add_mimedb_data(mimedb) | Add missing encodings and mimetypes to MIME database. | 1.659915 | 1.652514 | 1.004479 |
data = subprocess.Popen(cmd, stdout=subprocess.PIPE).communicate()[0]
return data.decode(encoding) | def backtick (cmd, encoding='utf-8') | Return decoded output from command. | 2.898232 | 2.77879 | 1.042983 |
# Note that shell_quote_nt() result is not suitable for copy-paste
# (especially on Unix systems), but it looks nicer than shell_quote().
if verbosity >= 0:
log_info("running %s" % " ".join(map(shell_quote_nt, cmd)))
if kwargs:
if verbosity >= 0:
log_info(" with %s" %... | def run (cmd, verbosity=0, **kwargs) | Run command without error checking.
@return: command return code | 3.737951 | 3.770232 | 0.991438 |
retcode = run(cmd, **kwargs)
if retcode not in ret_ok:
msg = "Command `%s' returned non-zero exit status %d" % (cmd, retcode)
raise PatoolError(msg)
return retcode | def run_checked (cmd, ret_ok=(0,), **kwargs) | Run command and raise PatoolError on error. | 2.842315 | 2.113879 | 1.344597 |
mime, encoding = guess_mime_file(filename)
if mime is None:
mime, encoding = guess_mime_mimedb(filename)
assert mime is not None or encoding is None
return mime, encoding | def guess_mime (filename) | Guess the MIME type of given filename using file(1) and if that
fails by looking at the filename extension with the Python mimetypes
module.
The result of this function is cached. | 3.802245 | 4.138139 | 0.91883 |
mime, encoding = None, None
if mimedb is not None:
mime, encoding = mimedb.guess_type(filename, strict=False)
if mime not in ArchiveMimetypes and encoding in ArchiveCompressions:
# Files like 't.txt.gz' are recognized with encoding as format, and
# an unsupported mime-type like ... | def guess_mime_mimedb (filename) | Guess MIME type from given filename.
@return: tuple (mime, encoding) | 7.292461 | 7.414321 | 0.983564 |
mime, encoding = None, None
base, ext = os.path.splitext(filename)
if ext.lower() in ('.alz',):
# let mimedb recognize these extensions
return mime, encoding
if os.path.isfile(filename):
file_prog = find_program("file")
if file_prog:
mime, encoding = gues... | def guess_mime_file (filename) | Determine MIME type of filename with file(1):
(a) using `file --mime`
(b) using `file` and look the result string
@return: tuple (mime, encoding) | 5.490761 | 5.442085 | 1.008944 |
mime, encoding = None, None
cmd = [file_prog, "--brief", "--mime-type", filename]
try:
mime = backtick(cmd).strip()
except OSError:
# ignore errors, as file(1) is only a fallback
pass
if mime not in ArchiveMimetypes:
mime, encoding = None, None
return mime, e... | def guess_mime_file_mime (file_prog, filename) | Determine MIME type of filename with file(1) and --mime option.
@return: tuple (mime, encoding) | 6.659467 | 6.946528 | 0.958676 |
for part in parts:
for subpart in part.split(" "):
if subpart.startswith("compressed-encoding="):
mime = subpart.split("=")[1].strip()
return Mime2Encoding.get(mime)
return None | def get_file_mime_encoding (parts) | Get encoding value from splitted output of file --mime --uncompress. | 5.011178 | 4.027546 | 1.244226 |
cmd = [file_prog, "--brief", filename]
try:
output = backtick(cmd).strip()
except OSError:
# ignore errors, as file(1) is only a fallback
return None
# match output against known strings
for matcher, mime in FileText2Mime.items():
if output.startswith(matcher) an... | def guess_mime_file_text (file_prog, filename) | Determine MIME type of filename with file(1). | 8.871283 | 7.643609 | 1.160614 |
if not os.path.exists(filename):
raise PatoolError("file `%s' was not found" % filename)
if not os.access(filename, os.R_OK):
raise PatoolError("file `%s' is not readable" % filename)
if onlyfiles and not os.path.isfile(filename):
raise PatoolError("`%s' is not a file" % filenam... | def check_existing_filename (filename, onlyfiles=True) | Ensure that given filename is a valid, existing file. | 2.182207 | 2.052023 | 1.063442 |
if not filenames:
raise PatoolError("cannot create archive with empty filelist")
for filename in filenames:
check_existing_filename(filename, onlyfiles=False) | def check_archive_filelist (filenames) | Check that file list is not empty and contains only existing files. | 8.496387 | 6.885698 | 1.233918 |
try:
mode = os.lstat(filename).st_mode
except OSError:
# ignore
return
if not (mode & flags):
try:
os.chmod(filename, flags | mode)
except OSError as msg:
log_error("could not set mode flags for `%s': %s" % (filename, msg)) | def set_mode (filename, flags) | Set mode flags for given filename if not already set. | 3.419758 | 3.09585 | 1.104627 |
return tempfile.mkstemp(suffix=suffix, prefix=prefix, dir=dir)[1] | def tmpfile (dir=None, prefix="temp", suffix=None) | Return a temporary file. | 3.634566 | 3.196599 | 1.13701 |
outfile = os.path.join(directory, stripext(archive))
if os.path.exists(outfile + extension):
# prevent overwriting existing files
i = 1
newfile = "%s%d" % (outfile, i)
while os.path.exists(newfile + extension):
newfile = "%s%d" % (outfile, i)
i += 1
... | def get_single_outfile (directory, archive, extension="") | Get output filename if archive is in a single file format like gzip. | 2.52747 | 2.48155 | 1.018505 |
value = os.getenv(key)
if value is not None:
print(key, "=", repr(value), file=out) | def print_env_info(key, out=sys.stderr) | If given environment key is defined, print it out. | 3.115072 | 2.900347 | 1.074034 |
print("System info:", file=out)
print(configuration.App, file=out)
print("Python %(version)s on %(platform)s" %
{"version": sys.version, "platform": sys.platform}, file=out)
stime = strtime(time.time())
print("Local time:", stime, file=out)
print("sys.argv", sys.argv, fi... | def print_app_info(out=sys.stderr) | Print system and application info (output defaults to stderr). | 4.076899 | 4.003558 | 1.018319 |
if os.name == 'nt':
# Assume RAR support is compiled into the binary.
return True
# the subdirectory and codec name
codecname = 'p7zip/Codecs/Rar29.so'
# search canonical user library dirs
for libdir in ('/usr/lib', '/usr/local/lib', '/usr/lib64', '/usr/local/lib64', '/usr/lib/i... | def p7zip_supports_rar() | Determine if the RAR codec is installed for 7z program. | 4.28382 | 4.082279 | 1.04937 |
if os.name == 'nt':
# Add some well-known archiver programs to the search path
path = os.environ['PATH']
path = append_to_path(path, get_nt_7z_dir())
path = append_to_path(path, get_nt_mac_dir())
path = append_to_path(path, get_nt_winrar_dir())
else:
# use de... | def find_program (program) | Look for program in environment PATH variable. | 3.8029 | 3.762541 | 1.010727 |
if not os.path.isdir(directory) or directory in path:
return path
if not path.endswith(os.pathsep):
path += os.pathsep
return path + directory | def append_to_path (path, directory) | Add a directory to the PATH environment variable, if it is a valid
directory. | 2.786218 | 2.784835 | 1.000497 |
# Python 3.x renamed the _winreg module to winreg
try:
import _winreg as winreg
except ImportError:
import winreg
try:
key = winreg.OpenKey(winreg.HKEY_LOCAL_MACHINE, r"SOFTWARE\7-Zip")
try:
return winreg.QueryValueEx(key, "Path")[0]
finally:
... | def get_nt_7z_dir () | Return 7-Zip directory from registry, or an empty string. | 2.253663 | 2.012751 | 1.119693 |
if filename1 == filename2:
return True
if os.name == 'posix':
return os.path.samefile(filename1, filename2)
return is_same_filename(filename1, filename2) | def is_same_file (filename1, filename2) | Check if filename1 and filename2 point to the same file object.
There can be false negatives, ie. the result is False, but it is
the same file anyway. Reason is that network filesystems can create
different paths to the same physical file. | 2.553263 | 2.521353 | 1.012656 |
return os.path.realpath(filename1) == os.path.realpath(filename2) | def is_same_filename (filename1, filename2) | Check if filename1 and filename2 are the same filename. | 2.891154 | 2.346729 | 1.231993 |
if verbosity > 0:
log_info("Copying %s -> %s" % (src, dst))
try:
os.link(src, dst)
except (AttributeError, OSError):
try:
shutil.copy(src, dst)
except OSError as msg:
raise PatoolError(msg) | def link_or_copy(src, dst, verbosity=0) | Try to make a hard link from src to dst and if that fails
copy the file. Hard links save some disk space and linking
should fail fast since no copying is involved. | 2.524749 | 2.456254 | 1.027886 |
try:
olddir = os.getcwd()
except OSError:
olddir = None
os.chdir(directory)
return olddir | def chdir(directory) | Remember and return current directory before calling os.chdir().
If the current directory could not be determined, return None. | 2.576847 | 2.398239 | 1.074475 |
outfile = util.get_single_outfile(outdir, archive, extension=".wav")
cmdlist = [cmd, '--decode', archive, '--output-name', outfile]
return cmdlist | def extract_flac (archive, compression, cmd, verbosity, interactive, outdir) | Decompress a FLAC archive to a WAV file. | 9.176444 | 8.576126 | 1.069999 |
cmdlist = [cmd, filenames[0], '--best', '--output-name', archive]
return cmdlist | def create_flac (archive, compression, cmd, verbosity, interactive, filenames) | Compress a WAV file to a FLAC archive. | 12.813111 | 13.500435 | 0.949089 |
cmdlist = [cmd, 'x']
if not interactive:
cmdlist.extend(['-p-', '-y'])
cmdlist.extend(['--', os.path.abspath(archive)])
return (cmdlist, {'cwd': outdir}) | def extract_rar (archive, compression, cmd, verbosity, interactive, outdir) | Extract a RAR archive. | 5.028095 | 4.780218 | 1.051855 |
cmdlist = [util.shell_quote(cmd), '--extract', '--make-directories',
'--preserve-modification-time']
if sys.platform.startswith('linux') and not cmd.endswith('bsdcpio'):
cmdlist.extend(['--no-absolute-filenames',
'--force-local', '--nonmatching', r'"*\.\.*"'])
if verbosity > 1:
... | def extract_cpio (archive, compression, cmd, verbosity, interactive, outdir) | Extract a CPIO archive. | 5.638616 | 5.526847 | 1.020223 |
cmdlist = [util.shell_quote(cmd), '--create']
if verbosity > 1:
cmdlist.append('-v')
if len(filenames) != 0:
findcmd = ['find']
findcmd.extend([util.shell_quote(x) for x in filenames])
findcmd.extend(['-print0', '|'])
cmdlist[0:0] = findcmd
cmdlist.append... | def create_cpio(archive, compression, cmd, verbosity, interactive, filenames) | Create a CPIO archive. | 3.580843 | 3.575953 | 1.001368 |
# Since extracted files will be placed in the current directory,
# the cwd argument has to be the output directory.
cmdlist = [cmd, 'x', os.path.abspath(archive)]
return (cmdlist, {'cwd': outdir}) | def extract_arc (archive, compression, cmd, verbosity, interactive, outdir) | Extract a ARC archive. | 8.116602 | 7.905382 | 1.026719 |
cmdlist = [cmd]
if verbosity > 1:
cmdlist.append('v')
else:
cmdlist.append('l')
cmdlist.append(archive)
return cmdlist | def list_arc (archive, compression, cmd, verbosity, interactive) | List a ARC archive. | 3.568218 | 3.456496 | 1.032322 |
targetname = util.get_single_outfile(outdir, archive)
try:
with gzip.GzipFile(archive) as gzipfile:
with open(targetname, 'wb') as targetfile:
data = gzipfile.read(READ_SIZE_BYTES)
while data:
targetfile.write(data)
... | def extract_gzip (archive, compression, cmd, verbosity, interactive, outdir) | Extract a GZIP archive with the gzip Python module. | 2.917709 | 2.920153 | 0.999163 |
if len(filenames) > 1:
raise util.PatoolError('multi-file compression not supported in Python gzip')
try:
with gzip.GzipFile(archive, 'wb') as gzipfile:
filename = filenames[0]
with open(filename, 'rb') as srcfile:
data = srcfile.read(READ_SIZE_BYTES)... | def create_gzip (archive, compression, cmd, verbosity, interactive, filenames) | Create a GZIP archive with the gzip Python module. | 2.93437 | 2.827944 | 1.037634 |
targetname = util.get_single_outfile(outdir, archive)
try:
with lzma.LZMAFile(archive, **_get_lzma_options(format)) as lzmafile:
with open(targetname, 'wb') as targetfile:
data = lzmafile.read(READ_SIZE_BYTES)
while data:
targetfile.wr... | def _extract(archive, compression, cmd, format, verbosity, outdir) | Extract an LZMA or XZ archive with the lzma Python module. | 3.139783 | 2.942366 | 1.067094 |
return _extract(archive, compression, cmd, 'alone', verbosity, outdir) | def extract_lzma(archive, compression, cmd, verbosity, interactive, outdir) | Extract an LZMA archive with the lzma Python module. | 12.043806 | 16.457476 | 0.731814 |
return _extract(archive, compression, cmd, 'xz', verbosity, outdir) | def extract_xz(archive, compression, cmd, verbosity, interactive, outdir) | Extract an XZ archive with the lzma Python module. | 5.432067 | 7.695666 | 0.705861 |
if len(filenames) > 1:
raise util.PatoolError('multi-file compression not supported in Python lzma')
try:
with lzma.LZMAFile(archive, mode='wb', **_get_lzma_options(format, preset=9)) as lzmafile:
filename = filenames[0]
with open(filename, 'rb') as srcfile:
... | def _create(archive, compression, cmd, format, verbosity, filenames) | Create an LZMA or XZ archive with the lzma Python module. | 3.217279 | 3.103233 | 1.036751 |
return _create(archive, compression, cmd, 'alone', verbosity, filenames) | def create_lzma(archive, compression, cmd, verbosity, interactive, filenames) | Create an LZMA archive with the lzma Python module. | 13.468284 | 15.683348 | 0.858763 |
return _create(archive, compression, cmd, 'xz', verbosity, filenames) | def create_xz(archive, compression, cmd, verbosity, interactive, filenames) | Create an XZ archive with the lzma Python module. | 5.975244 | 7.222532 | 0.827306 |
def wrapper(view_func):
def _checkssl(request, *args, **kwargs):
# allow_non_ssl=True lets non-https requests to come
# through to this view (and hence not redirect)
if hasattr(settings, 'SSL_ENABLED') and settings.SSL_ENABLED \
and not request.is... | def ssl_required(allow_non_ssl=False) | Views decorated with this will always get redirected to https
except when allow_non_ssl is set to true. | 3.144449 | 2.950107 | 1.065876 |
if redirect_to is None:
redirect_to = settings.LOGIN_REDIRECT_URL
@wraps(view)
def wrapper(request, *a, **k):
if request.user and request.user.is_authenticated():
return HttpResponseRedirect(redirect_to)
return view(request, *a, **k)
return wrapper | def anonymous_required(view, redirect_to=None) | Only allow if user is NOT authenticated. | 1.936638 | 1.856197 | 1.043336 |
return self._get_or_set('{0}{1}'.format(self._GENERIC_VAR_KEY_PREFIX, key), value) | def generic_var(self, key, value=None) | Stores generic variables in the session prepending it with _GENERIC_VAR_KEY_PREFIX. | 5.718583 | 3.463655 | 1.651026 |
try:
user = User.objects.get(email=username)
if user.check_password(password):
return user
except (User.DoesNotExist, User.MultipleObjectsReturned):
logging.warning('Unsuccessful login attempt using username/email: {0}'.format(username))
... | def authenticate(self, username=None, password=None, **kwargs) | "username" being passed is really email address and being compared to as such. | 2.917452 | 2.680624 | 1.088348 |
try:
help_text = None
css_classes = None
token_split = token.split_contents()
if len(token_split) == 4:
tag_name, form_field, help_text, css_classes = token.split_contents()
elif len(token_split) == 3:
tag_name, form_field, help_text = token.spli... | def render_form_field(parser, token) | Usage is {% render_form_field form.field_name optional_help_text optional_css_classes %}
- optional_help_text and optional_css_classes are strings
- if optional_help_text is not given, then it is taken from form field object | 2.098281 | 1.953885 | 1.073902 |
parser.add_argument('--length', default=self.length,
type=int, help=_('SECRET_KEY length default=%d' % self.length))
parser.add_argument('--alphabet', default=self.allowed_chars,
type=str, help=_('alphabet to use default=%s' % self.allowe... | def add_arguments(self, parser) | Define optional arguments with default values | 4.03659 | 3.725533 | 1.083493 |
if self.declared_fieldsets:
fields = flatten_fieldsets(self.declared_fieldsets)
else:
fields = None
if self.exclude is None:
exclude = []
else:
exclude = list(self.exclude)
exclude.extend(kwargs.get("exclude", []))
... | def get_formset(self, request, obj=None, **kwargs) | Returns a BaseInlineFormSet class for use in admin add/change views. | 2.067654 | 1.981809 | 1.043316 |
if value == "":
return None
if isinstance(value, dict):
value = json.dumps(value, cls=DjangoJSONEncoder)
return value | def get_prep_value(self, value) | Convert our JSON object to a string before we save | 3.566118 | 3.170186 | 1.124892 |
for possibility in possibilities:
if value == possibility:
return True
raise Exception('A different request value was encountered than expected: {0}'.format(value)) | def is_among(value, *possibilities) | Ensure that the method that has been used for the request is one
of the expected ones (e.g., GET or POST). | 6.720038 | 5.447973 | 1.233493 |
import django.core.mail
try:
logging.debug('Sending mail to: {0}'.format(', '.join(r for r in recipient_emails)))
logging.debug('Message: {0}'.format(message))
email = django.core.mail.EmailMessage(subject, message, from_email, recipient_emails,
... | def send_mail(subject, message, from_email, recipient_emails, files=None,
html=False, reply_to=None, bcc=None, cc=None, files_manually=None) | Sends email with advanced optional parameters
To attach non-file content (e.g. content not saved on disk), use
files_manually parameter and provide list of 3 element tuples, e.g.
[('design.png', img_data, 'image/png'),] which will be passed to
email.attach(). | 2.389552 | 2.441668 | 0.978656 |
timeDiff = datetime.datetime.now() - timestamp
days = timeDiff.days
hours = timeDiff.seconds / 3600
minutes = timeDiff.seconds % 3600 / 60
seconds = timeDiff.seconds % 3600 % 60
str = ""
if days > 0:
if days == 1:
t_str = "day"
else:
t_str = "day... | def humanize_time_since(timestamp=None) | Returns a fuzzy time since. Will only return the largest time. EX: 20 days, 14 min | 1.387473 | 1.381245 | 1.004509 |
if skipset is None:
skipset = set()
for item in iterable:
if item not in skipset:
skipset.add(item)
yield item | def skip_redundant(iterable, skipset=None) | Redundant items are repeated items or items in the original skipset. | 1.916529 | 1.833051 | 1.04554 |
# make tuple of needed metaclasses in specified priority order
metas = left_metas + tuple(map(type, bases)) + right_metas
needed_metas = remove_redundant(metas)
# return existing confict-solving meta, if any
if needed_metas in memoized_metaclasses_map:
return memoized_metaclasses_map[n... | def get_noconflict_metaclass(bases, left_metas, right_metas) | Not intended to be used outside of this module, unless you know what you are doing. | 6.445683 | 6.404524 | 1.006427 |
request.method_params['captcha_key'] = self.get_captcha_key(request)
request.method_params['captcha_sid'] = request.api_error.captcha_sid
return self.send(request) | def on_api_error_14(self, request) | 14. Captcha needed | 5.130621 | 4.271749 | 1.201059 |
logger.error('Authorization failed. Access token will be dropped')
self.access_token = self.get_access_token()
return self.send(request) | def on_api_error_15(self, request) | 15. Access denied
- due to scope | 7.815634 | 9.490342 | 0.823536 |
# Ask access
ask_access_response = auth_session.post(self.AUTHORIZE_URL, self.get_auth_params())
url_queries = self.get_response_url_queries(ask_access_response)
if 'access_token' not in url_queries:
# Grant access
grant_access_action = self.get_form_act... | def authorize(self, auth_session) | OAuth2 | 3.143698 | 3.156028 | 0.996093 |
quote = self.get_quote()
if quote:
self.reply("Actually, she said things like this: \n%s" % quote) | def talk_back(self, message) | that's what she said: Tells you some things she actually said. :) | 9.826841 | 7.352331 | 1.336561 |
import uuid
import time
import random
import hashlib
node = uuid.getnode()
h = hashlib.md5()
h.update(str("%s" % node).encode('utf-8'))
key1 = h.hexdigest()
time.sleep(random.uniform(0, 0.5))
node = uuid.getnode()
h = hashlib.md5()
h.update(str("%s" % node).encod... | def auto_key() | This method attempts to auto-generate a unique cryptographic key based on the hardware ID.
It should *NOT* be used in production, or to replace a proper key, but it can help get will
running in local and test environments more easily. | 1.880335 | 1.767921 | 1.063586 |
if (
getattr(settings, "GOOGLE_API_KEY", False)
and getattr(settings, "GOOGLE_CUSTOM_SEARCH_ENGINE_ID", False)
):
self.say(
"Sorry, I'm missing my GOOGLE_API_KEY and GOOGLE_CUSTOM_SEARCH_ENGINE_ID."
" Can someone give ... | def image_me(self, message, search_query) | image me ___ : Search google images for ___, and post a random one. | 2.741021 | 2.73603 | 1.001824 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.