OpenQuizz
Une application de gestion des contenus pédagogiques
|
Public Member Functions | |
def | __init__ (self, name=None, mode="r", fileobj=None, format=None, tarinfo=None, dereference=None, ignore_zeros=None, encoding=None, errors="surrogateescape", pax_headers=None, debug=None, errorlevel=None) |
def | open (cls, name=None, mode="r", fileobj=None, bufsize=RECORDSIZE, **kwargs) |
def | taropen (cls, name, mode="r", fileobj=None, **kwargs) |
def | gzopen (cls, name, mode="r", fileobj=None, compresslevel=9, **kwargs) |
def | bz2open (cls, name, mode="r", fileobj=None, compresslevel=9, **kwargs) |
def | close (self) |
def | getmember (self, name) |
def | getmembers (self) |
def | getnames (self) |
def | gettarinfo (self, name=None, arcname=None, fileobj=None) |
def | list (self, verbose=True) |
def | add (self, name, arcname=None, recursive=True, exclude=None, filter=None) |
def | addfile (self, tarinfo, fileobj=None) |
def | extractall (self, path=".", members=None) |
def | extract (self, member, path="", set_attrs=True) |
def | extractfile (self, member) |
def | makedir (self, tarinfo, targetpath) |
def | makefile (self, tarinfo, targetpath) |
def | makeunknown (self, tarinfo, targetpath) |
def | makefifo (self, tarinfo, targetpath) |
def | makedev (self, tarinfo, targetpath) |
def | makelink (self, tarinfo, targetpath) |
def | chown (self, tarinfo, targetpath) |
def | chmod (self, tarinfo, targetpath) |
def | utime (self, tarinfo, targetpath) |
def | next (self) |
def | __iter__ (self) |
def | __enter__ (self) |
def | __exit__ (self, type, value, traceback) |
Data Fields | |
mode | |
name | |
fileobj | |
pax_headers | |
closed | |
members | |
offset | |
inodes | |
firstmember | |
Static Public Attributes | |
debug | |
dereference | |
ignore_zeros | |
errorlevel | |
format | |
encoding | |
errors | |
tarinfo | |
fileobject | |
OPEN_METH | |
The TarFile Class provides an interface to tar archives.
def __init__ | ( | self, | |
name = None , |
|||
mode = "r" , |
|||
fileobj = None , |
|||
format = None , |
|||
tarinfo = None , |
|||
dereference = None , |
|||
ignore_zeros = None , |
|||
encoding = None , |
|||
errors = "surrogateescape" , |
|||
pax_headers = None , |
|||
debug = None , |
|||
errorlevel = 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.
def __enter__ | ( | self | ) |
def __exit__ | ( | self, | |
type, | |||
value, | |||
traceback | |||
) |
def __iter__ | ( | self | ) |
Provide an iterator object.
def add | ( | self, | |
name, | |||
arcname = None , |
|||
recursive = True , |
|||
exclude = None , |
|||
filter = None |
|||
) |
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. `exclude' is a function that should return True for each filename to be excluded. `filter' is a function that expects a TarInfo object argument and returns the changed TarInfo object, if it returns None the TarInfo object will be excluded from the archive.
def 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.
def bz2open | ( | cls, | |
name, | |||
mode = "r" , |
|||
fileobj = None , |
|||
compresslevel = 9 , |
|||
** | kwargs | ||
) |
Open bzip2 compressed tar archive name for reading or writing. Appending is not allowed.
def chmod | ( | self, | |
tarinfo, | |||
targetpath | |||
) |
Set file permissions of targetpath according to tarinfo.
def chown | ( | self, | |
tarinfo, | |||
targetpath | |||
) |
Set owner of targetpath according to tarinfo.
def close | ( | self | ) |
Close the TarFile. In write-mode, two finishing zero blocks are appended to the archive.
def extract | ( | self, | |
member, | |||
path = "" , |
|||
set_attrs = True |
|||
) |
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'. File attributes (owner, mtime, mode) are set unless `set_attrs' is False.
def 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().
def 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()
def 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 occurrence is assumed to be the most up-to-date version.
def 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.
def 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().
def 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.
def gzopen | ( | cls, | |
name, | |||
mode = "r" , |
|||
fileobj = None , |
|||
compresslevel = 9 , |
|||
** | kwargs | ||
) |
Open gzip compressed tar archive name for reading or writing. Appending is not allowed.
def 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.
def makedev | ( | self, | |
tarinfo, | |||
targetpath | |||
) |
Make a character or block device called targetpath.
def makedir | ( | self, | |
tarinfo, | |||
targetpath | |||
) |
Make a directory called targetpath.
def makefifo | ( | self, | |
tarinfo, | |||
targetpath | |||
) |
Make a fifo called targetpath.
def makefile | ( | self, | |
tarinfo, | |||
targetpath | |||
) |
Make a file called targetpath.
def 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.
def makeunknown | ( | self, | |
tarinfo, | |||
targetpath | |||
) |
Make a file from a TarInfo object with an unknown type at targetpath.
def 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.
def open | ( | cls, | |
name = None , |
|||
mode = "r" , |
|||
fileobj = None , |
|||
bufsize = RECORDSIZE , |
|||
** | kwargs | ||
) |
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, creating the file if necessary '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
def taropen | ( | cls, | |
name, | |||
mode = "r" , |
|||
fileobj = None , |
|||
** | kwargs | ||
) |
Open uncompressed tar archive name for reading or writing.
def utime | ( | self, | |
tarinfo, | |||
targetpath | |||
) |
Set modification time of targetpath according to tarinfo.
closed |
|
static |
|
static |
|
static |
|
static |
|
static |
fileobj |
|
static |
firstmember |
|
static |
|
static |
inodes |
members |
mode |
name |
offset |
|
static |
pax_headers |
|
static |