def test_unpack_registery(self):
formats = get_unpack_formats()
def _boo(filename, extract_dir, extra):
self.assertEquals(extra, 1)
self.assertEquals(filename, 'stuff.boo')
self.assertEquals(extract_dir, 'xx')
register_unpack_format('Boo', ['.boo', '.b2'], _boo, [('extra', 1)])
unpack_archive('stuff.boo', 'xx')
# trying to register a .boo unpacker again
self.assertRaises(RegistryError, register_unpack_format, 'Boo2',
['.boo'], _boo)
# should work now
unregister_unpack_format('Boo')
register_unpack_format('Boo2', ['.boo'], _boo)
self.assertIn(('Boo2', ['.boo'], ''), get_unpack_formats())
self.assertNotIn(('Boo', ['.boo'], ''), get_unpack_formats())
# let's leave a clean state
unregister_unpack_format('Boo2')
self.assertEquals(get_unpack_formats(), formats)
def test_unpack_registery(self):
formats = get_unpack_formats()
def _boo(filename, extract_dir, extra):
self.assertEqual(extra, 1)
self.assertEqual(filename, 'stuff.boo')
self.assertEqual(extract_dir, 'xx')
register_unpack_format('Boo', ['.boo', '.b2'], _boo, [('extra', 1)])
unpack_archive('stuff.boo', 'xx')
# trying to register a .boo unpacker again
self.assertRaises(RegistryError, register_unpack_format, 'Boo2',
['.boo'], _boo)
# should work now
unregister_unpack_format('Boo')
register_unpack_format('Boo2', ['.boo'], _boo)
self.assertIn(('Boo2', ['.boo'], ''), get_unpack_formats())
self.assertNotIn(('Boo', ['.boo'], ''), get_unpack_formats())
# let's leave a clean state
unregister_unpack_format('Boo2')
self.assertEqual(get_unpack_formats(), formats)
def test_register_new_archive_formats(prepare_shutil_state):
"""Registering new archive formats should be fine"""
unpack_formats_v1 = [f[0] for f in shutil.get_unpack_formats()]
for format_id in tarball.ADDITIONAL_ARCHIVE_FORMATS:
assert format_id[0] not in unpack_formats_v1
# when
tarball.register_new_archive_formats()
# then
unpack_formats_v2 = [f[0] for f in shutil.get_unpack_formats()]
for format_id in tarball.ADDITIONAL_ARCHIVE_FORMATS:
assert format_id[0] in unpack_formats_v2
def _remove_compressed_file_endings(toolchain_uri: str):
unpack_extensions = ['.tar.bz2', '.bz2', '.tar.gz', '.tgz', '.tar', '.zip'] + \
sum(map(lambda info: info[1], shutil.get_unpack_formats()), [])
for extension in reversed(sorted(unpack_extensions, key=len)):
if toolchain_uri.endswith(extension):
return toolchain_uri.replace(extension, '')
return toolchain_uri
def getFileExtension(self):
availableFormats = get_unpack_formats()
for format in availableFormats:
if format[0] == self.config['format']:
## TODO: Refactor to allow check on any possible format
return format[1][0]
return ''
def is_compressed(file):
""" Check if file is compresses in zip, tar or rar format """
filename, file_extension = os.path.splitext(file)
return file_extension in [
format for unpack_format in shutil.get_unpack_formats()
for format in unpack_format[1]
]
def shutil_get_unpack_formats():
"""返回当前系统支持的解包格式"""
# exts表示归档格式对应的后缀名
for formats, exts, description in shutil.get_unpack_formats():
print("{:5}: {}, names ending in {}".format(formats, description,
exts))
r"""
async def import_(self, ctx: commands.Context, source: str = None):
"""
Imports sounds from an archive. Sounds are named the name of the file in the archive.
Supports .zip, .tar, .tar.gz, .tgz, .tar.bz2, .tbz2, .tar.xz, and .txz archives.
:param source: Download link to an archive. Can be omitted if archive is uploaded as an attachment.
"""
if source is None:
try:
source = ctx.message.attachments[0].url
except (IndexError, KeyError):
raise exceptions.NoDownload()
with tempfile.NamedTemporaryFile('wb+') as f, tempfile.TemporaryDirectory() as d:
async with aiohttp.ClientSession() as session:
async with session.get(source) as resp:
filename = resp.url.name
# this might block but i don't care.
while True:
chunk = await resp.content.read(1 << 20) # 1 MB
if not chunk:
break
f.write(chunk)
f.seek(0) # this probably doesn't matter
format = None
for fmt in shutil.get_unpack_formats():
for extension in fmt[1]:
if filename.endswith(extension):
format = fmt[0]
break
# this weird stuff is because python has no syntax for
# breaking out of multiple loops.
else:
continue
break
shutil.unpack_archive(f.name, d, format=format)
f.close()
succeeded = []
failed = []
for path in Path(d).glob('**/*'):
if not path.is_file():
continue
try:
await self._add(ctx, path.name, source, path, unlink=False)
succeeded.append(path.name)
except FileExistsError:
failed.append(path.name)
msg = f'{len(succeeded)} imported. {len(failed)} failed.'
if failed:
msg += '\nFailed imports:\n'
msg += '\n'.join(failed)
await ctx.send(msg)
def register_new_archive_formats():
"""Register new archive formats to uncompress
"""
registered_formats = [f[0] for f in shutil.get_unpack_formats()]
for name, extensions, function in ADDITIONAL_ARCHIVE_FORMATS:
if name in registered_formats:
continue
shutil.register_unpack_format(name, extensions, function)
def __init__(self, *args, **kwargs):
super(UnarchiveActivity, self).__init__(*args, **kwargs)
targetPath = args[0]
print("Extracting archives into %s" % targetPath)
self.__threads = []
webdav_url = self.doors('https', ['dcache-view'])
self.__download_url = webdav_url
self.__target_url = urljoin(webdav_url, targetPath + '/')
self.__extensions = [e for f in shutil.get_unpack_formats() for e in f[1]]
def get_sdist_extensions():
if SDIST_EXTENSIONS:
return SDIST_EXTENSIONS
for format in shutil.get_unpack_formats():
for ext in format[1]:
SDIST_EXTENSIONS.append(ext)
return SDIST_EXTENSIONS
def get_format(format):
for (fmt, extensions, _) in shutil.get_unpack_formats():
if format == fmt:
return fmt
if format in extensions:
return fmt
if "." + format in extensions:
return fmt
raise ValueError(f"Unrecognized format {format}")
def check_is_file_arc(name_arc):
"""By file name returns information on whether it is a valid archive or not."""
for name, format_of_arc in dict([
(x[0], x[1]) for x in shutil.get_unpack_formats()
]).items():
for el in format_of_arc:
if el in name_arc:
return True
else:
return False
def prepare_shutil_state():
"""Reset any shutil modification in its current state"""
import shutil
registered_formats = [f[0] for f in shutil.get_unpack_formats()]
for format_id in tarball.ADDITIONAL_ARCHIVE_FORMATS:
name = format_id[0]
if name in registered_formats:
shutil.unregister_unpack_format(name)
return shutil
def extract_arhcive(name_arc, dir_name_out):
try:
for name, format_of_arc in dict([
(x[0], x[1]) for x in shutil.get_unpack_formats()
]).items():
for el in format_of_arc:
if el in name_arc:
shutil.unpack_archive(name_arc, dir_name_out, name)
except Exception as e:
return False, e
else:
return True, "ok"
def unpack_archive(self, archive, chdir=True):
""" An archive is unpacked in the current directory. If requested its
top level directory becomes the current directory. The name of the
directory (not it's pathname) is returned.
"""
# Windows (maybe just 32-bits) has a problem extracting the Qt source
# archive (maybe the long pathnames). As a work around we extract it
# to the directory containing the archive and then move it later.
archive_dir, archive_name = os.path.split(archive)
original_cwd = os.getcwd()
os.chdir(archive_dir)
# Unpack the archive.
try:
shutil.unpack_archive(archive_name)
except Exception as e:
self.error("unable to unpack {0}".format(archive), detail=str(e))
# Assume that the name of the extracted directory is the same as the
# archive without the extension.
archive_root = None
for _, extensions, _ in shutil.get_unpack_formats():
for ext in extensions:
if archive_name.endswith(ext):
archive_root = archive_name[:-len(ext)]
break
if archive_root:
break
else:
# This should never happen if we have got this far.
self.error("'{0}' has an unknown extension".format(archive))
# Validate the assumption by checking the expected directory exists.
if not os.path.isdir(archive_root):
self.error(
"unpacking {0} did not create a directory called '{1}' as expected"
.format(archive, archive_root))
# Move the extracted archive.
archive_root_path = os.path.join(original_cwd, archive_root)
self.delete_dir(archive_root_path)
os.rename(archive_root, archive_root_path)
os.chdir(original_cwd)
# Change to the extracted directory if required.
if chdir:
os.chdir(archive_root)
# Return the directory name which the component plugin will often use
# to extract version information.
return archive_root
def unpack_archive(self, archive, chdir=True):
""" An archive is unpacked in the current directory. If requested its
top level directory becomes the current directory. The name of the
directory (not it's pathname) is returned.
"""
# Windows has a problem extracting the Qt source archive (probably the
# long pathnames). As a work around we copy it to the current
# directory and extract it from there.
self.copy_file(archive, '.')
archive_name = os.path.basename(archive)
# Unpack the archive.
self.verbose("Unpacking '{}'".format(archive_name))
try:
shutil.unpack_archive(archive_name)
except Exception as e:
self.error("unable to unpack {0}".format(archive_name),
detail=str(e))
# Assume that the name of the extracted directory is the same as the
# archive without the extension.
archive_root = None
for _, extensions, _ in shutil.get_unpack_formats():
for ext in extensions:
if archive_name.endswith(ext):
archive_root = archive_name[:-len(ext)]
break
if archive_root:
break
else:
# This should never happen if we have got this far.
self.error("'{0}' has an unknown extension".format(archive))
# Validate the assumption by checking the expected directory exists.
if not os.path.isdir(archive_root):
self.error(
"unpacking {0} did not create a directory called '{1}' as expected"
.format(archive_name, archive_root))
# Delete the copied archive.
os.remove(archive_name)
# Change to the extracted directory if required.
if chdir:
os.chdir(archive_root)
# Return the directory name which the component plugin will often use
# to extract version information.
return archive_root
def expandArchives(fs_root):
archive_extensions = []
for _, file_types, _ in shutil.get_unpack_formats():
archive_extensions.extend(file_types)
for root, dirs, files in os.walk(fs_root):
for file in files:
name, ext = os.path.splitext(file)
if ext in archive_extensions:
archive_file = os.path.join(root, file)
extract_dir = os.path.join(root, name + ".extracted")
os.makedirs(extract_dir, exist_ok=True)
shutil.unpack_archive(archive_file, extract_dir=extract_dir)
dirs.append(extract_dir)
def test_unpack_registery(self) -> None:
formats = get_unpack_formats()
def _boo(filename: str, extract_dir: str, extra: int) -> None:
self.assertEqual(extra, 1)
self.assertEqual(filename, "stuff.boo")
self.assertEqual(extract_dir, "xx")
register_unpack_format("Boo", [".boo", ".b2"], _boo, [("extra", 1)])
unpack_archive("stuff.boo", "xx")
# trying to register a .boo unpacker again
self.assertRaises(RegistryError, register_unpack_format, "Boo2", [".boo"], _boo)
# should work now
unregister_unpack_format("Boo")
register_unpack_format("Boo2", [".boo"], _boo)
self.assertIn(("Boo2", [".boo"], ""), get_unpack_formats())
self.assertNotIn(("Boo", [".boo"], ""), get_unpack_formats())
# let's leave a clean state
unregister_unpack_format("Boo2")
self.assertEqual(get_unpack_formats(), formats)
def unarchive_if_possible(dlto, year_dir):
'''Unarchives a file if possible, returns True if it did.'''
unzip_exts = []
_uf = shutil.get_unpack_formats()
for i in _uf:
unzip_exts += i[1]
dl_ext = os.path.splitext(dlto)[1]
#print(dlto, dl_ext, unzip_exts)
if os.path.exists(dlto) and (dl_ext in unzip_exts):
shutil.unpack_archive(dlto, year_dir)
os.remove(dlto)
print("Unarchived", dlto)
return True
return False
def _extract_sdist(pypi_metadata: Dict[str, Any]) -> Dict:
"""Get sdist file path from the meta-data"""
sdist_extensions = tuple(extension
for (name, extensions,
description) in shutil.get_unpack_formats()
for extension in extensions)
# The first one we can use. Usually a .tar.gz
for entry in pypi_metadata["urls"]:
if entry["filename"].endswith(sdist_extensions):
return entry
raise Exception("No sdist URL found for package %s (%s)" % (
pypi_metadata["info"].get("name"),
pypi_metadata["info"].get("package_url"),
))
def init_additional_unpackers():
"""Add external libraries for unpacking files.
Checks if `7z` or `unrar` are installed on the host system.
"""
if try_cmd('7z'):
register_unpack_format('7zip', [
'.zipx', '.gz', '.z', '.cab',
'.rar', '.lzh', '.7z', '.xz'
], un7z)
elif try_cmd('unrar'):
register_unpack_format('unrar', ['.rar'], unrar)
formats = get_unpack_formats()
formats = list(map(lambda item: item[1], formats))
formats = [item for sublist in formats for item in sublist]
download.unpack_formats = formats
def download_and_install(link, font, fontdir):
# might need to spoof the user agent here
with urllib.request.urlopen(link) as response:
with tempfile.NamedTemporaryFile(delete=False) as tmp_file:
shutil.copyfileobj(response, tmp_file)
fname = font.replace(" ", "_")
if "Content-Disposition" in response.info():
hh = cgi.parse_header(response.info()["Content-Disposition"])
fname = os.path.splitext(hh[1]["filename"])[0]
magic = subprocess.run(
["file", tmp_file.name], stdout=subprocess.PIPE, universal_newlines=True
).stdout.strip()
printv(magic)
for fmt in shutil.get_unpack_formats():
printv(fmt)
if fmt[0].lower() in magic.lower():
# think we'll need to unpack in place and then sudo mv
with tempfile.TemporaryDirectory() as tmpdir:
dirname = os.path.join(tmpdir, fname)
shutil.unpack_archive(tmp_file.name, dirname, fmt[0])
if fccachetry:
prompt(
"sudo mv "
+ shlex.quote(dirname)
+ " "
+ shlex.quote(os.path.join(fontdir, fname))
)
elif sys.platform.startswith("darwin"):
os.system("open " + shlex.quote(dirname) + "/*.ttf")
os.system("open " + shlex.quote(dirname) + "/*.otf")
break
else:
if "font" in magic:
prompt(
"sudo mv "
+ shlex.quote(tmp_file.name)
+ " "
+ shlex.quote(os.path.join(fontdir, fname))
)
else:
printq("Could not figure out what to do! Skipping")
printq(link)
def recursive_uncompress(self,
output_path=None,
remove_source=False,
remove_sub_sources=True,
clean_before_uncompress=False):
if output_path is None:
output_path = self.file_output_folder
else:
self.file_output_folder = output_path
self.uncompress(output_path=output_path,
remove_source=remove_source,
clean_before_uncompress=clean_before_uncompress)
for compatible_file_format in shutil.get_unpack_formats():
for file_format in compatible_file_format[1]:
# print("looking for files " + file_format)
for file in glob.glob(output_path + "/**/*" + file_format,
recursive=True):
# print("Found file " + file)
CompressedFile(file).recursive_uncompress(
remove_source=remove_sub_sources)
import urllib.error
import urllib.request
import warnings
from pathlib import Path
from typing import Any, Literal
from ruamel.yaml import YAML
class MkpkgFailedException(Exception):
pass
SDIST_EXTENSIONS = tuple(extension
for (name, extensions,
description) in shutil.get_unpack_formats()
for extension in extensions)
def _find_sdist(pypi_metadata: dict[str, Any]) -> dict[str, Any] | None:
"""Get sdist file path from the metadata"""
# The first one we can use. Usually a .tar.gz
for entry in pypi_metadata["urls"]:
if entry["packagetype"] == "sdist" and entry["filename"].endswith(
SDIST_EXTENSIONS):
return entry
return None
def _find_wheel(pypi_metadata: dict[str, Any]) -> dict[str, Any] | None:
"""Get wheel file path from the metadata"""
import argparse
import copy
import logging
import pathlib
import shutil
import sys
import tarfile
import unittest
from .base import Profile, Target, Scope
from .build import Build
from .config import ConfigDict
from .tests import Skip, TestCase
from . import compilers, targets
if not any([ '.xz' in i[1] for i in shutil.get_unpack_formats() ]):
def _extract_xz(filename, extract_dir):
try:
tarobj = tarfile.open(filename)
except tarfile.TarError as e:
raise ReadError('{} is not a tar file'.format(filename)) from e
try:
tarobj.extractall(extract_dir)
finally:
tarobj.close()
shutil.register_unpack_format('XZ file', ['.xz'], _extract_xz, [], 'Tar file compressed with XZ (LZMA) algorithm')
def stripPackExt(name):
for fmt in shutil.get_unpack_formats():
for ext in fmt[1]:
if name.endswith(ext):
return name.rstrip(ext)
return name
print(shutil.which("io_example.py"))
print(shutil.which("python3"))
path = os.pathsep.join([".", os.path.expanduser("~")])
mode = os.F_OK | os.R_OK
# path 参数默认是 os.environ('PATH')，但是可以是任何由 os.pathsep 分隔的字符串
filename = shutil.which("jmeter.log", mode=mode, path=path)
print(path)
print(filename)
print()
print("四、 压缩文件")
for format, des in shutil.get_archive_formats():
print(f"{format:>5} {des}")
for format, ends, des in shutil.get_unpack_formats():
print(f"{format :>5} {str(ends): <25} {des}")
logging.basicConfig(format="%(message)s",
stream=sys.stdout,
level=logging.DEBUG)
logger = logging.getLogger("pymotw")
print("Creating archive:")
shutil.make_archive("test_files/example",
"gztar",
root_dir=".",
base_dir="test_files",
logger=logger)
print("\nArchive contents:")
with tarfile.open("test_files/example.tar.gz", "r") as t:
for n in t.getnames():
def getSupportedExtensions():
supported_extensions = []
for format_ in shutil.get_unpack_formats():
supported_extensions += format_[1]
return supported_extensions
# shutil模块测试，用于拷贝/压缩文件等
import shutil
# shutil.copy('test.csv', 'test_copy.csv') # 拷贝test.csv为test_copy.csv
# shutil.copyfile('test.csv', 'test_copy_2.csv')
#
# shutil.copytree('../file', '../file2') # 拷贝目录file为file2
# # 拷贝目录file为file2_ignore，但是会忽略文件中以test和os开头的文件
# shutil.copytree('../file', '../file2_ignore', ignore=shutil.ignore_patterns('test*', 'os*'))
# 把父母录的class以zip格式进行压缩，压缩后生成test.zip文件在当前目录下。test也可以指定为绝对路径，这里是相对路径
shutil.make_archive('test', 'zip', '../class')
shutil.unpack_archive('test.zip', 'extracted',
'zip') # 把当前目录下的test.zip文件以zip算法进行解压缩到当前目录下的extracted目录下
print(shutil.get_archive_formats()) # 获取可用的压缩算法
print(shutil.get_unpack_formats()) # 获取可用的解压缩算法
async def download_profile(self, delete=False, chunk_size=4096) -> None:
"""Download all necessary profile files from the internet and extract them."""
self.download_status = []
output_dir = Path(self.profile.write_path())
download_dir = Path(
self.profile.write_path(
self.profile.get("download.cache_dir", "download")))
if delete and download_dir.exists():
self._logger.debug("Deleting download cache at %s", download_dir)
shutil.rmtree(download_dir)
download_dir.mkdir(parents=True, exist_ok=True)
# Load configuration
conditions = self.profile.get("download.conditions", {})
all_files = self.profile.get("download.files", {})
files_to_copy = {}
files_to_extract: Dict[str, List[Tuple[str, str]]] = defaultdict(list)
files_to_download: Set[str] = set()
async def download_file(url, filename):
try:
status = f"Downloading {url} to {filename}"
self.download_status.append(status)
self._logger.debug(status)
os.makedirs(os.path.dirname(filename), exist_ok=True)
async with self.session.get(url) as response:
with open(filename, "wb") as out_file:
async for chunk in response.content.iter_chunked(
chunk_size):
out_file.write(chunk)
status = f"Downloaded {filename}"
self.download_status.append(status)
self._logger.debug(status)
except Exception:
self._logger.exception(url)
# Try to delete partially downloaded file
try:
status = f"Failed to download {filename}"
self.download_status.append(status)
self._logger.debug(status)
os.unlink(filename)
except Exception:
pass
# Check conditions
machine_type = platform.machine()
download_tasks = []
for setting_name in conditions:
real_value = self.profile.get(setting_name, None)
# Compare setting values
for setting_value, files_dict in conditions[setting_name].items():
compare_func = self._get_compare_func(setting_value)
if compare_func(real_value):
# Check if file needs to be downloaded
for dest_name, src_name in files_dict.items():
dest_path = os.path.join(output_dir, dest_name)
if ":" in src_name:
# File is an archive
src_name, src_extract = src_name.split(":",
maxsplit=1)
src_path = os.path.join(download_dir, src_name)
files_to_extract[src_path].append(
(dest_path, src_extract))
else:
# Just a regular file
src_path = os.path.join(download_dir, src_name)
files_to_copy[src_path] = dest_path
# Get download/cache info for file
src_info = all_files.get(src_name, None)
if src_info is None:
self._logger.error("No entry for download file %s",
src_name)
continue
if not src_info.get("cache", True):
# File will be downloaded in-place
files_to_copy.pop(src_path)
src_path = dest_path
# Check if file is already in cache
if os.path.exists(src_path) and (
os.path.getsize(src_path) > 0):
self._logger.debug("Using cached %s for %s",
src_path, dest_name)
else:
# File needs to be downloaded
src_url = src_info.get("url", None)
if src_url is None:
# Try with machine type
if machine_type in src_info:
src_url = src_info[machine_type]["url"]
else:
self._logger.error(
"No entry for download file %s with machine type %s",
src_url,
machine_type,
)
continue
# Schedule file for download
if src_url not in files_to_download:
download_tasks.append(
self.loop.create_task(
download_file(src_url, src_path)))
files_to_download.add(src_url)
# Wait for downloads to complete
await asyncio.gather(*download_tasks)
# Copy files
for src_path, dest_path in files_to_copy.items():
# Remove existing file/directory
if os.path.isdir(dest_path):
self._logger.debug("Removing %s", dest_path)
shutil.rmtree(dest_path)
elif os.path.isfile(dest_path):
self._logger.debug("Removing %s", dest_path)
os.unlink(dest_path)
# Create necessary directories
os.makedirs(os.path.dirname(dest_path), exist_ok=True)
# Copy file/directory as is
status = f"Copying {src_path} to {dest_path}"
self.download_status.append(status)
self._logger.debug(status)
if os.path.isdir(src_path):
shutil.copytree(src_path, dest_path)
else:
shutil.copy2(src_path, dest_path)
# Extract/install files
unpack_extensions = [
ext for fmt in shutil.get_unpack_formats() for ext in fmt[1]
]
for src_path, extract_paths in files_to_extract.items():
# Check if the file extension will be understood by shutil.unpack_archive
known_format = False
for ext in unpack_extensions:
if src_path.endswith(ext):
known_format = True
def unpack_default(temp_dir):
return shutil.unpack_archive(src_path, temp_dir)
def unpack_gz(temp_dir):
return self._unpack_gz(src_path, temp_dir)
unpack = unpack_default
if not known_format:
# Handle special archives
if src_path.endswith(".gz"):
# Single file compressed with gzip
unpack = unpack_gz
else:
# Very bad situation
self._logger.warning(
"Unknown archive extension %s. This is probably going to fail.",
src_path,
)
# Cached file is an archive. Unpack first.
with tempfile.TemporaryDirectory() as temp_dir:
unpack(temp_dir)
for dest_path, src_extract in extract_paths:
src_exclude: Dict[str, List[str]] = {}
if "!" in src_extract:
extract_parts = src_extract.split("!")
src_extract = extract_parts[0]
src_exclude = defaultdict(list)
for exclude_path in extract_parts[1:]:
exclude_path = os.path.join(temp_dir, exclude_path)
exclude_dir, exclude_name = os.path.split(
exclude_path)
src_exclude[exclude_dir].append(exclude_name)
# Remove existing file/directory
if os.path.isdir(dest_path):
self._logger.debug("Removing %s", dest_path)
shutil.rmtree(dest_path)
elif os.path.isfile(dest_path):
self._logger.debug("Removing %s", dest_path)
os.unlink(dest_path)
# Create necessary directories
os.makedirs(os.path.dirname(dest_path), exist_ok=True)
if src_extract.endswith(":"):
# Unpack .gz inside archive
src_path = os.path.join(temp_dir, src_extract[:-1])
extract_path = self._unpack_gz(src_path, temp_dir)
else:
# Regular file
extract_path = os.path.join(temp_dir, src_extract)
# Copy specific file/directory
status = f"Copying {extract_path} to {dest_path}"
self.download_status.append(status)
self._logger.debug(status)
if os.path.isdir(extract_path):
if src_exclude:
# Ignore some files
# pylint: disable=W0640
shutil.copytree(
extract_path,
dest_path,
ignore=lambda d, fs: src_exclude[d],
)
else:
# Copy everything
shutil.copytree(extract_path, dest_path)
else:
shutil.copy2(extract_path, dest_path)
def shutil_get_unpack_formats():
for fmt, exts, desc in shutil.get_unpack_formats():
print('{:<5}: {}, names ending in {}'.format(fmt, desc, exts))
import shutil
import os
#arc_formats = shutil.get_archive_formats()
unarc_formats = shutil.get_unpack_formats()
print(unarc_formats)
# Source File location
source_file = '/home/arnamaity/Downloads/expense_tracker_api-master.zip'
# Constructing the path of the extraction location.
dir_path = os.getcwd()
path = os.path.join(dir_path, 'expense_tracker_api/')
os.mkdir(path)
dest_dir = path
print(path)
# Extract the files
shutil.unpack_archive(source_file, dest_dir, 'zip')
# Print the Extracted Contents.
dir_list = os.listdir(path)
print('The final directory list: ')
print(dir_list)
#
# def remove_readonly(func, path, _):
# "Clear the readonly bit and reattempt the removal"
# os.chmod(path, stat.S_IWRITE)
# func(path)
#
# shutil.rmtree(directory, onerror=remove_readonly)
# shutil.make_archive(base_name, format[, root_dir[, base_dir[, verbose[, dry_run[, owner[, group[, logger]]]]]]])
# 创建一个归档文件（例如 zip 或 tar）并返回其名称。
# print(shutil.make_archive("archive_name", 'zip',"./"))
# 这样会出现递归 归档！！
# 我们创建了一个 gzip 压缩的 tar 归档文件，其中包含用户的 .ssh 目录下的所有文件:
# from shutil import make_archive
# import os
# archive_name = os.path.expanduser(os.path.join('~', 'myarchive'))
# root_dir = os.path.expanduser(os.path.join('~', '.ssh'))
# print(make_archive(archive_name, 'gztar', root_dir))
# '/Users/tarek/myarchive.tar.gz'
# shutil.unpack_archive(filename[, extract_dir[, format]])
# 解包一个归档文件。 filename 是归档文件的完整路径。
print(shutil.get_archive_formats())
# [('bztar', "bzip2'ed tar-file"), ('gztar', "gzip'ed tar-file"), ('tar', 'uncompressed tar file'), ('xztar', "xz'ed tar-file"), ('zip', 'ZIP file')]
print(shutil.get_unpack_formats())
# [('bztar', ['.tar.bz2', '.tbz2'], "bzip2'ed tar-file"), ('gztar', ['.tar.gz', '.tgz'], "gzip'ed tar-file"), ('tar', ['.tar'], 'uncompressed tar file'), ('xztar', ['.tar.xz', '.txz'], "xz'ed tar-file"), ('zip', ['.zip'], 'ZIP file')]
print(shutil.get_terminal_size())
