| | |
- __builtin__.object
-
- TarFile
- TarInfo
- exceptions.Exception(exceptions.BaseException)
-
- TarError
class TarFile(__builtin__.object) |
| |
The TarFile Class provides an interface to tar archives.
|
| |
Methods defined here:
- __init__(self, name=None, mode='r', fileobj=None)
- Open an (uncompressed) tar archive `name'. `mode' is either 'r' to
read from an existing archive, 'a' to append data to an existing
file or 'w' to create a new file overwriting an existing one. `mode'
defaults to 'r'.
If `fileobj' is given, it is used for reading or writing data. If it
can be determined, `mode' is overridden by `fileobj's mode.
`fileobj' is not closed, when TarFile is closed.
- __iter__(self)
- Provide an iterator object.
- add(self, name, arcname=None, recursive=True)
- Add the file `name' to the archive. `name' may be any type of file
(directory, fifo, symbolic link, etc.). If given, `arcname'
specifies an alternative name for the file in the archive.
Directories are added recursively by default. This can be avoided by
setting `recursive' to False.
- addfile(self, tarinfo, fileobj=None)
- Add the TarInfo object `tarinfo' to the archive. If `fileobj' is
given, tarinfo.size bytes are read from it and added to the archive.
You can create TarInfo objects using gettarinfo().
On Windows platforms, `fileobj' should always be opened with mode
'rb' to avoid irritation about the file size.
- chmod(self, tarinfo, targetpath)
- Set file permissions of targetpath according to tarinfo.
- chown(self, tarinfo, targetpath)
- Set owner of targetpath according to tarinfo.
- close(self)
- Close the TarFile. In write-mode, two finishing zero blocks are
appended to the archive.
- extract(self, member, path='')
- Extract a member from the archive to the current working directory,
using its full name. Its file information is extracted as accurately
as possible. `member' may be a filename or a TarInfo object. You can
specify a different directory using `path'.
- extractall(self, path='.', members=None)
- Extract all members from the archive to the current working
directory and set owner, modification time and permissions on
directories afterwards. `path' specifies a different directory
to extract to. `members' is optional and must be a subset of the
list returned by getmembers().
- extractfile(self, member)
- Extract a member from the archive as a file object. `member' may be
a filename or a TarInfo object. If `member' is a regular file, a
file-like object is returned. If `member' is a link, a file-like
object is constructed from the link's target. If `member' is none of
the above, None is returned.
The file-like object is read-only and provides the following
methods: read(), readline(), readlines(), seek() and tell()
- getmember(self, name)
- Return a TarInfo object for member `name'. If `name' can not be
found in the archive, KeyError is raised. If a member occurs more
than once in the archive, its last occurence is assumed to be the
most up-to-date version.
- getmembers(self)
- Return the members of the archive as a list of TarInfo objects. The
list has the same order as the members in the archive.
- getnames(self)
- Return the members of the archive as a list of their names. It has
the same order as the list returned by getmembers().
- gettarinfo(self, name=None, arcname=None, fileobj=None)
- Create a TarInfo object for either the file `name' or the file
object `fileobj' (using os.fstat on its file descriptor). You can
modify some of the TarInfo's attributes before you add it using
addfile(). If given, `arcname' specifies an alternative name for the
file in the archive.
- list(self, verbose=True)
- Print a table of contents to sys.stdout. If `verbose' is False, only
the names of the members are printed. If it is True, an `ls -l'-like
output is produced.
- makedev(self, tarinfo, targetpath)
- Make a character or block device called targetpath.
- makedir(self, tarinfo, targetpath)
- Make a directory called targetpath.
- makefifo(self, tarinfo, targetpath)
- Make a fifo called targetpath.
- makefile(self, tarinfo, targetpath)
- Make a file called targetpath.
- makelink(self, tarinfo, targetpath)
- Make a (symbolic) link called targetpath. If it cannot be created
(platform limitation), we try to make a copy of the referenced file
instead of a link.
- makeunknown(self, tarinfo, targetpath)
- Make a file from a TarInfo object with an unknown type
at targetpath.
- next(self)
- Return the next member of the archive as a TarInfo object, when
TarFile is opened for reading. Return None if there is no more
available.
- proc_builtin(self, tarinfo)
- Process a builtin type member or an unknown member
which will be treated as a regular file.
- proc_gnulong(self, tarinfo)
- Process the blocks that hold a GNU longname
or longlink member.
- proc_member(self, tarinfo)
- Choose the right processing method for tarinfo depending
on its type and call it.
- proc_sparse(self, tarinfo)
- Process a GNU sparse header plus extra headers.
- utime(self, tarinfo, targetpath)
- Set modification time of targetpath according to tarinfo.
Class methods defined here:
- bz2open(cls, name, mode='r', fileobj=None, compresslevel=9) from __builtin__.type
- Open bzip2 compressed tar archive name for reading or writing.
Appending is not allowed.
- gzopen(cls, name, mode='r', fileobj=None, compresslevel=9) from __builtin__.type
- Open gzip compressed tar archive name for reading or writing.
Appending is not allowed.
- open(cls, name=None, mode='r', fileobj=None, bufsize=10240) from __builtin__.type
- Open a tar archive for reading, writing or appending. Return
an appropriate TarFile class.
mode:
'r' or 'r:*' open for reading with transparent compression
'r:' open for reading exclusively uncompressed
'r:gz' open for reading with gzip compression
'r:bz2' open for reading with bzip2 compression
'a' or 'a:' open for appending
'w' or 'w:' open for writing without compression
'w:gz' open for writing with gzip compression
'w:bz2' open for writing with bzip2 compression
'r|*' open a stream of tar blocks with transparent compression
'r|' open an uncompressed stream of tar blocks for reading
'r|gz' open a gzip compressed stream of tar blocks
'r|bz2' open a bzip2 compressed stream of tar blocks
'w|' open an uncompressed stream for writing
'w|gz' open a gzip compressed stream for writing
'w|bz2' open a bzip2 compressed stream for writing
- taropen(cls, name, mode='r', fileobj=None) from __builtin__.type
- Open uncompressed tar archive name for reading or writing.
Data descriptors defined here:
- __dict__
- dictionary for instance variables (if defined)
- __weakref__
- list of weak references to the object (if defined)
Data and other attributes defined here:
- OPEN_METH = {'bz2': 'bz2open', 'gz': 'gzopen', 'tar': 'taropen'}
- debug = 0
- dereference = False
- errorlevel = 0
- fileobject = <class 'tarfile.ExFileObject'>
- File-like object for reading an archive member.
Is returned by TarFile.extractfile(). Support for
sparse files included.
- ignore_zeros = False
- posix = False
|
|