class _CallableGenericAlias(GenericAlias):
""" Represent `Callable[argtypes, resulttype]`.
- This sets ``__args__`` to a tuple containing the flattened ``argtypes``
- followed by ``resulttype``.
+ This sets ``__args__`` to a tuple containing the flattened
+ ``argtypes`` followed by ``resulttype``.
Example: ``Callable[[int, str], float]`` sets ``__args__`` to
``(int, str, float)``.
__marker = object()
def pop(self, key, default=__marker):
- '''D.pop(k[,d]) -> v, remove specified key and return the corresponding value.
- If key is not found, d is returned if given, otherwise KeyError is raised.
+ '''D.pop(k[,d]) -> v, remove specified key and return the corresponding
+ value. If key is not found, d is returned if given, otherwise
+ KeyError is raised.
'''
try:
value = self[key]
def update(self, other=(), /, **kwds):
''' D.update([E, ]**F) -> None. Update D from mapping/iterable E and F.
- If E present and has a .keys() method, does: for k in E.keys(): D[k] = E[k]
- If E present and lacks .keys() method, does: for (k, v) in E: D[k] = v
- In either case, this is followed by: for k, v in F.items(): D[k] = v
+ If E present and has a .keys() method, does:
+ for k in E.keys(): D[k] = E[k]
+ If E present and lacks .keys() method, does:
+ for (k, v) in E: D[k] = v
+ In either case, this is followed by:
+ for k, v in F.items(): D[k] = v
'''
if isinstance(other, Mapping):
for key in other:
yield self[i]
def index(self, value, start=0, stop=None):
- '''S.index(value, [start, [stop]]) -> integer -- return first index of value.
- Raises ValueError if the value is not present.
+ '''S.index(value, [start, [stop]]) -> integer -- return first index of
+ value. Raises ValueError if the value is not present.
Supporting start and stop arguments is optional, but
recommended.
self[i], self[n-i-1] = self[n-i-1], self[i]
def extend(self, values):
- 'S.extend(iterable) -- extend sequence by appending elements from the iterable'
+ """S.extend(iterable) -- extend sequence by appending elements from the
+ iterable"""
if values is self:
values = list(values)
for v in values:
self.append(v)
def pop(self, index=-1):
- '''S.pop([index]) -> item -- remove and return item at index (default last).
- Raise IndexError if list is empty or index is out of range.
+ '''S.pop([index]) -> item -- remove and return item at index (default
+ last). Raise IndexError if list is empty or index is out of range.
'''
v = self[index]
del self[index]
"""
Either returns an existing member, or creates a new enum class.
- This method is used both when an enum class is given a value to match
- to an enumeration member (i.e. Color(3)) and for the functional API
- (i.e. Color = Enum('Color', names='RED GREEN BLUE')).
+ This method is used both when an enum class is given a value to
+ match to an enumeration member (i.e. Color(3)) and for the
+ functional API (i.e. Color = Enum('Color', names='RED GREEN BLUE')).
The value lookup branch is chosen if the enum is final.
`value` will be the name of the new class.
- `names` should be either a string of white-space/comma delimited names
- (values will start at `start`), or an iterator/mapping of name, value pairs.
+ `names` should be either a string of white-space/comma delimited
+ names (values will start at `start`), or an iterator/mapping of
+ name, value pairs.
`module` should be set to the module this class is being created in;
- if it is not set, an attempt to find that module will be made, but if
- it fails the class will not be picklable.
+ if it is not set, an attempt to find that module will be made, but
+ if it fails the class will not be picklable.
- `qualname` should be set to the actual location this class can be found
- at in its module; by default it is set to the global scope. If this is
- not correct, unpickling will fail in some circumstances.
+ `qualname` should be set to the actual location this class can be
+ found at in its module; by default it is set to the global scope.
+ If this is not correct, unpickling will fail in some circumstances.
`type`, if set, will be mixed in as the first base class.
"""
"""
Returns a mapping of member name->value.
- This mapping lists all enum members, including aliases. Note that this
- is a read-only view of the internal mapping.
+ This mapping lists all enum members, including aliases. Note that
+ this is a read-only view of the internal mapping.
"""
return MappingProxyType(cls._member_map_)
If *maxsize* is set to None, the LRU features are disabled and the cache
can grow without bound.
- If *typed* is True, arguments of different types will be cached separately.
- For example, f(decimal.Decimal("3.0")) and f(3.0) will be treated as
- distinct calls with distinct results. Some types such as str and int may
- be cached separately even when typed is false.
+ If *typed* is True, arguments of different types will be cached
+ separately. For example, f(decimal.Decimal("3.0")) and f(3.0) will be
+ treated as distinct calls with distinct results. Some types such as
+ str and int may be cached separately even when typed is false.
Arguments to the cached function must be hashable.
View the cache statistics named tuple (hits, misses, maxsize, currsize)
- with f.cache_info(). Clear the cache and statistics with f.cache_clear().
- Access the underlying function with f.__wrapped__.
+ with f.cache_info(). Clear the cache and statistics with
+ f.cache_clear(). Access the underlying function with f.__wrapped__.
See: https://en.wikipedia.org/wiki/Cache_replacement_policies#Least_recently_used_(LRU)
The order of the returned list is undefined. Sort it if you need a
particular order.
- If `root_dir` is not None, it should be a path-like object specifying the
- root directory for searching. It has the same effect as changing the
- current directory before calling it (without actually
- changing it). If pathname is relative, the result will contain
- paths relative to `root_dir`.
+ If `root_dir` is not None, it should be a path-like object specifying
+ the root directory for searching. It has the same effect as changing
+ the current directory before calling it (without actually changing it).
+ If pathname is relative, the result will contain paths relative to
+ `root_dir`.
If `dir_fd` is not None, it should be a file descriptor referring to a
directory, and paths will then be relative to that directory.
- If `include_hidden` is true, the patterns '*', '?', '**' will match hidden
- directories.
+ If `include_hidden` is true, the patterns '*', '?', '**' will match
+ hidden directories.
If `recursive` is true, the pattern '**' will match any files and
zero or more directories and subdirectories.
particular order.
If `root_dir` is not None, it should be a path-like object specifying
- the root directory for searching. It has the same effect as changing
- the current directory before calling it (without actually
- changing it). If pathname is relative, the result will contain
- paths relative to `root_dir`.
+ the root directory for searching. It has the same effect as changing
+ the current directory before calling it (without actually changing it).
+ If pathname is relative, the result will contain paths relative to
+ `root_dir`.
If `dir_fd` is not None, it should be a file descriptor referring to a
directory, and paths will then be relative to that directory.
- If `include_hidden` is true, the patterns '*', '?', '**' will match hidden
- directories.
+ If `include_hidden` is true, the patterns '*', '?', '**' will match
+ hidden directories.
If `recursive` is true, the pattern '**' will match any files and
zero or more directories and subdirectories.
def translate(pat, *, recursive=False, include_hidden=False, seps=None):
"""Translate a pathname with shell wildcards to a regular expression.
- If `recursive` is true, the pattern segment '**' will match any number of
- path segments.
+ If `recursive` is true, the pattern segment '**' will match any number
+ of path segments.
If `include_hidden` is true, wildcards can match path segments beginning
with a dot ('.').
If a sequence of separator characters is given to `seps`, they will be
- used to split the pattern into segments and match path separators. If not
- given, os.path.sep and os.path.altsep (where available) are used.
+ used to split the pattern into segments and match path separators. If
+ not given, os.path.sep and os.path.altsep (where available) are used.
"""
if not seps:
if os.path.altsep:
encoding=None, errors=None, newline=None):
"""Open a gzip-compressed file in binary or text mode.
- The filename argument can be an actual filename (a str or bytes object), or
- an existing file object to read from or write to.
+ The filename argument can be an actual filename (a str or bytes object),
+ or an existing file object to read from or write to.
- The mode argument can be "r", "rb", "w", "wb", "x", "xb", "a" or "ab" for
- binary mode, or "rt", "wt", "xt" or "at" for text mode. The default mode is
- "rb", and the default compresslevel is 9.
+ The mode argument can be "r", "rb", "w", "wb", "x", "xb", "a" or "ab"
+ for binary mode, or "rt", "wt", "xt" or "at" for text mode. The default
+ mode is "rb", and the default compresslevel is 9.
- For binary mode, this function is equivalent to the GzipFile constructor:
- GzipFile(filename, mode, compresslevel). In this case, the encoding, errors
- and newline arguments must not be provided.
+ For binary mode, this function is equivalent to the GzipFile
+ constructor: GzipFile(filename, mode, compresslevel). In this case,
+ the encoding, errors and newline arguments must not be provided.
For text mode, a GzipFile object is created, and wrapped in an
io.TextIOWrapper instance with the specified encoding, error handling
"""The GzipFile class simulates most of the methods of a file object with
the exception of the truncate() method.
- This class only supports opening files in binary mode. If you need to open a
- compressed file in text mode, use the gzip.open() function.
+ This class only supports opening files in binary mode. If you need to
+ open a compressed file in text mode, use the gzip.open() function.
"""
non-trivial value.
The new class instance is based on fileobj, which can be a regular
- file, an io.BytesIO object, or any other object which simulates a file.
- It defaults to None, in which case filename is opened to provide
- a file object.
+ file, an io.BytesIO object, or any other object which simulates
+ a file. It defaults to None, in which case filename is opened to
+ provide a file object.
When fileobj is not None, the filename argument is only used to be
included in the gzip file header, which may include the original
filename of the uncompressed file. It defaults to the filename of
fileobj, if discernible; otherwise, it defaults to the empty string,
- and in this case the original filename is not included in the header.
-
- The mode argument can be any of 'r', 'rb', 'a', 'ab', 'w', 'wb', 'x', or
- 'xb' depending on whether the file will be read or written. The default
- is the mode of fileobj if discernible; otherwise, the default is 'rb'.
- A mode of 'r' is equivalent to one of 'rb', and similarly for 'w' and
- 'wb', 'a' and 'ab', and 'x' and 'xb'.
-
- The compresslevel argument is an integer from 0 to 9 controlling the
- level of compression; 1 is fastest and produces the least compression,
- and 9 is slowest and produces the most compression. 0 is no compression
- at all. The default is 9.
-
- The optional mtime argument is the timestamp requested by gzip. The time
- is in Unix format, i.e., seconds since 00:00:00 UTC, January 1, 1970.
- If mtime is omitted or None, the current time is used. Use mtime = 0
- to generate a compressed stream that does not depend on creation time.
+ and in this case the original filename is not included in the
+ header.
+
+ The mode argument can be any of 'r', 'rb', 'a', 'ab', 'w', 'wb',
+ 'x', or 'xb' depending on whether the file will be read or written.
+ The default is the mode of fileobj if discernible; otherwise, the
+ default is 'rb'. A mode of 'r' is equivalent to one of 'rb', and
+ similarly for 'w' and 'wb', 'a' and 'ab', and 'x' and 'xb'.
+
+ The compresslevel argument is an integer from 0 to 9 controlling
+ the level of compression; 1 is fastest and produces the least
+ compression, and 9 is slowest and produces the most compression.
+ 0 is no compression at all. The default is 9.
+
+ The optional mtime argument is the timestamp requested by gzip.
+ The time is in Unix format, i.e., seconds since 00:00:00 UTC,
+ January 1, 1970. If mtime is omitted or None, the current time
+ is used. Use mtime = 0 to generate a compressed stream that does
+ not depend on creation time.
"""
It is always true that:
result[0] + result[1] == p
- If the path contained a drive letter, drive_or_unc will contain everything
- up to and including the colon. e.g. splitdrive("c:/dir") returns ("c:", "/dir")
+ If the path contained a drive letter, drive_or_unc will contain
+ everything up to and including the colon. e.g. splitdrive("c:/dir")
+ returns ("c:", "/dir")
- If the path contained a UNC path, the drive_or_unc will contain the host name
- and share up to but not including the fourth directory separator character.
- e.g. splitdrive("//host/computer/dir") returns ("//host/computer", "/dir")
+ If the path contained a UNC path, the drive_or_unc will contain the
+ host name and share up to but not including the fourth directory
+ separator character. e.g. splitdrive("//host/computer/dir") returns
+ ("//host/computer", "/dir")
Paths cannot contain both a drive letter and a UNC path.
def split(p):
"""Split a pathname.
- Return tuple (head, tail) where tail is everything after the final slash.
- Either part may be empty."""
+ Return tuple (head, tail) where tail is everything after the final
+ slash. Either part may be empty."""
p = os.fspath(p)
seps = _get_bothseps(p)
d, r, p = splitroot(p)
size = 'Size in bytes.',
mtime = 'Time of last modification.',
chksum = 'Header checksum.',
- type = ('File type. type is usually one of these constants: '
- 'REGTYPE, AREGTYPE, LNKTYPE, SYMTYPE, DIRTYPE, FIFOTYPE, '
- 'CONTTYPE, CHRTYPE, BLKTYPE, GNUTYPE_SPARSE.'),
+ type = ('File type. type is usually one of these constants: '
+ 'REGTYPE,\n'
+ 'AREGTYPE, LNKTYPE, SYMTYPE, DIRTYPE, FIFOTYPE, '
+ 'CONTTYPE, CHRTYPE,\n'
+ 'BLKTYPE, GNUTYPE_SPARSE.'),
linkname = ('Name of the target file name, which is only present '
- 'in TarInfo objects of type LNKTYPE and SYMTYPE.'),
+ 'in TarInfo\n'
+ 'objects of type LNKTYPE and SYMTYPE.'),
uname = 'User name.',
gname = 'Group name.',
devmajor = 'Device major number.',
offset = 'The tar header starts here.',
offset_data = "The file's data starts here.",
pax_headers = ('A dictionary containing key-value pairs of an '
- 'associated pax extended header.'),
+ 'associated pax\n'
+ 'extended header.'),
sparse = 'Sparse member information.',
_tarfile = None,
_sparse_structs = None,
return tarinfo
def list(self, verbose=True, *, members=None):
- """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. 'members' is optional and must be a subset of the
- list returned by getmembers().
+ """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. 'members' is
+ optional and must be a subset of the list returned by getmembers().
"""
# Convert tarinfo type to stat type.
type2mode = {REGTYPE: stat.S_IFREG, SYMTYPE: stat.S_IFLNK,
self.addfile(tarinfo)
def addfile(self, tarinfo, fileobj=None):
- """Add the TarInfo object 'tarinfo' to the archive. If 'tarinfo' represents
- a non zero-size regular file, the 'fileobj' argument should be a binary file,
- and tarinfo.size bytes are read from it and added to the archive.
- You can create TarInfo objects directly, or by using gettarinfo().
+ """Add the TarInfo object 'tarinfo' to the archive.
+
+ If 'tarinfo' represents a non zero-size regular file, the 'fileobj'
+ argument should be a binary file, and tarinfo.size bytes are read
+ from it and added to the archive. You can create TarInfo objects
+ directly, or by using gettarinfo().
"""
self._check("awx")
| __members__
| Returns a mapping of member name->value.
|
- | This mapping lists all enum members, including aliases. Note that this
- | is a read-only view of the internal mapping."""
+ | This mapping lists all enum members, including aliases. Note that
+ | this is a read-only view of the internal mapping."""
expected_help_output_without_docs = """\
Help on class Color in module %s:
class DynamicClassAttribute:
"""Route attribute access on a class to __getattr__.
- This is a descriptor, used to define attributes that act differently when
- accessed through an instance and through a class. Instance access remains
- normal, but access to an attribute through a class will be routed to the
- class's __getattr__ method; this is done by raising AttributeError.
-
- This allows one to have properties active on an instance, and have virtual
- attributes on the class with the same name. (Enum used this between Python
- versions 3.4 - 3.9 .)
-
- Subclass from this to use a different method of accessing virtual attributes
- and still be treated properly by the inspect module. (Enum uses this since
- Python 3.10 .)
+ This is a descriptor, used to define attributes that act differently
+ when accessed through an instance and through a class. Instance access
+ remains normal, but access to an attribute through a class will be
+ routed to the class's __getattr__ method; this is done by raising
+ AttributeError.
+
+ This allows one to have properties active on an instance, and have
+ virtual attributes on the class with the same name. (Enum used this
+ between Python versions 3.4 - 3.9 .)
+
+ Subclass from this to use a different method of accessing virtual
+ attributes and still be treated properly by the inspect module. (Enum
+ uses this since Python 3.10 .)
"""
def __init__(self, fget=None, fset=None, fdel=None, doc=None):
2. Element represents a single node in this tree.
Interactions with the whole document (reading and writing to/from files) are
- usually done on the ElementTree level. Interactions with a single XML element
- and its sub-elements are done on the Element level.
+ usually done on the ElementTree level. Interactions with a single XML
+ element and its sub-elements are done on the Element level.
Element is a flexible container object designed to store hierarchical data
structures in memory. It can be described as a cross between a list and a
"""Find first matching element by tag name or path.
*path* is a string having either an element tag or an XPath,
- *namespaces* is an optional mapping from namespace prefix to full name.
+ *namespaces* is an optional mapping from namespace prefix to full
+ name.
Return the first matching element, or None if no element was found.
*path* is a string having either an element tag or an XPath,
*default* is the value to return if the element was not found,
- *namespaces* is an optional mapping from namespace prefix to full name.
+ *namespaces* is an optional mapping from namespace prefix to full
+ name.
Return text content of first matching element, or default value if
none was found. Note that if an element is found having no text
"""Find all matching subelements by tag name or path.
*path* is a string having either an element tag or an XPath,
- *namespaces* is an optional mapping from namespace prefix to full name.
+ *namespaces* is an optional mapping from namespace prefix to full
+ name.
Returns list containing all matching elements in document order.
"""Find all matching subelements by tag name or path.
*path* is a string having either an element tag or an XPath,
- *namespaces* is an optional mapping from namespace prefix to full name.
+ *namespaces* is an optional mapping from namespace prefix to full
+ name.
Return an iterable yielding all matching elements in document order.
def parse(self, source, parser=None):
"""Load external XML document into element tree.
- *source* is a file name or file object, *parser* is an optional parser
- instance that defaults to XMLParser.
+ *source* is a file name or file object, *parser* is an optional
+ parser instance that defaults to XMLParser.
ParseError is raised if the parser fails to parse the document.
def iter(self, tag=None):
"""Create and return tree iterator for the root element.
- The iterator loops over all elements in this tree, in document order.
+ The iterator loops over all elements in this tree, in document
+ order.
*tag* is a string with the tag name to iterate over
(default is to return all elements).
Same as getroot().find(path), which is Element.find()
*path* is a string having either an element tag or an XPath,
- *namespaces* is an optional mapping from namespace prefix to full name.
+ *namespaces* is an optional mapping from namespace prefix to full
+ name.
Return the first matching element, or None if no element was found.
Same as getroot().findtext(path), which is Element.findtext()
*path* is a string having either an element tag or an XPath,
- *namespaces* is an optional mapping from namespace prefix to full name.
+ *namespaces* is an optional mapping from namespace prefix to full
+ name.
Return the first matching element, or None if no element was found.
Same as getroot().findall(path), which is Element.findall().
*path* is a string having either an element tag or an XPath,
- *namespaces* is an optional mapping from namespace prefix to full name.
+ *namespaces* is an optional mapping from namespace prefix to full
+ name.
Return list containing all matching elements in document order.
"""Write element tree to a file as XML.
Arguments:
- *file_or_filename* -- file name or a file object opened for writing
+ *file_or_filename* -- file name or a file object opened for
+ writing
*encoding* -- the output encoding (default: US-ASCII)
- *xml_declaration* -- bool indicating if an XML declaration should be
- added to the output. If None, an XML declaration
- is added if encoding IS NOT either of:
- US-ASCII, UTF-8, or Unicode
+ *xml_declaration* -- bool indicating if an XML declaration should
+ be added to the output. If None, an XML
+ declaration is added if encoding IS NOT
+ either of: US-ASCII, UTF-8, or Unicode
- *default_namespace* -- sets the default XML namespace (for "xmlns")
+ *default_namespace* -- sets the default XML namespace (for
+ "xmlns")
*method* -- either "xml" (default), "html, "text", or "c14n"
*short_empty_elements* -- controls the formatting of elements
- that contain no content. If True (default)
- they are emitted as a single self-closed
- tag, otherwise they are emitted as a pair
- of start/end tags
+ that contain no content. If True
+ (default) they are emitted as a single
+ self-closed tag, otherwise they are
+ emitted as a pair of start/end tags
"""
if self._root is None:
is returned. Otherwise a bytestring is returned.
*element* is an Element instance, *encoding* is an optional output
- encoding defaulting to US-ASCII, *method* is an optional output which can
- be one of "xml" (default), "html", "text" or "c14n", *default_namespace*
- sets the default XML namespace (for "xmlns").
+ encoding defaulting to US-ASCII, *method* is an optional output which
+ can be one of "xml" (default), "html", "text" or "c14n",
+ *default_namespace* sets the default XML namespace (for "xmlns").
Returns an (optionally) encoded string containing the XML data.
"end" events are reported.
*source* is a filename or file object containing XML data, *events* is
- a list of events to report back, *parser* is an optional parser instance.
+ a list of events to report back, *parser* is an optional parser
+ instance.
Returns an iterator providing (event, elem) pairs.
def canonicalize(xml_data=None, *, out=None, from_file=None, **options):
"""Convert XML to its C14N 2.0 serialised form.
- If *out* is provided, it must be a file or file-like object that receives
- the serialised canonical XML output (text, not bytes) through its ``.write()``
- method. To write to a file, open it in text mode with encoding "utf-8".
- If *out* is not provided, this function returns the output as text string.
+ If *out* is provided, it must be a file or file-like object that
+ receives the serialised canonical XML output (text, not bytes) through
+ its ``.write()`` method. To write to a file, open it in text mode with
+ encoding "utf-8". If *out* is not provided, this function returns the
+ output as text string.
Either *xml_data* (an XML string) or *from_file* (a file path or
file-like object) must be provided as input.
Serialises parse events to XML C14N 2.0.
The *write* function is used for writing out the resulting data stream
- as text (not bytes). To write to a file, open it in text mode with encoding
- "utf-8" and pass its ``.write`` method.
+ as text (not bytes). To write to a file, open it in text mode with
+ encoding "utf-8" and pass its ``.write`` method.
Configuration options:
- *with_comments*: set to true to include comments
- - *strip_text*: set to true to strip whitespace before and after text content
- - *rewrite_prefixes*: set to true to replace namespace prefixes by "n{number}"
+ - *strip_text*: set to true to strip whitespace before and after text
+ content
+ - *rewrite_prefixes*: set to true to replace namespace prefixes by
+ "n{number}"
- *qname_aware_tags*: a set of qname aware tag names in which prefixes
should be replaced in text content
- - *qname_aware_attrs*: a set of qname aware attribute names in which prefixes
- should be replaced in text content
- - *exclude_attrs*: a set of attribute names that should not be serialised
+ - *qname_aware_attrs*: a set of qname aware attribute names in which
+ prefixes should be replaced in text content
+ - *exclude_attrs*: a set of attribute names that should not be
+ serialised
- *exclude_tags*: a set of tag names that should not be serialised
"""
def __init__(self, write, *,
def from_file(cls, filename, arcname=None, *, strict_timestamps=True):
"""Construct an appropriate ZipInfo for a file on the filesystem.
- filename should be the path to a file or directory on the filesystem.
+ filename should be the path to a file or directory on the
+ filesystem.
- arcname is the name which it will have within the archive (by default,
- this will be the same as filename, but without a drive letter and with
- leading path separators removed).
+ arcname is the name which it will have within the archive (by
+ default, this will be the same as filename, but without a drive
+ letter and with leading path separators removed).
"""
if isinstance(filename, os.PathLike):
filename = os.fspath(filename)
mode: The mode can be either read 'r', write 'w', exclusive create 'x',
or append 'a'.
compression: ZIP_STORED (no compression), ZIP_DEFLATED (requires zlib),
- ZIP_BZIP2 (requires bz2), ZIP_LZMA (requires lzma), or
- ZIP_ZSTANDARD (requires compression.zstd).
- allowZip64: if True ZipFile will create files with ZIP64 extensions when
- needed, otherwise it will raise an exception when this would
- be necessary.
- compresslevel: None (default for the given compression type) or an integer
- specifying the level to pass to the compressor.
- When using ZIP_STORED or ZIP_LZMA this keyword has no effect.
- When using ZIP_DEFLATED integers 0 through 9 are accepted.
- When using ZIP_BZIP2 integers 1 through 9 are accepted.
- When using ZIP_ZSTANDARD integers -7 though 22 are common,
- see the CompressionParameter enum in compression.zstd for
- details.
+ ZIP_BZIP2 (requires bz2), ZIP_LZMA (requires lzma), or
+ ZIP_ZSTANDARD (requires compression.zstd).
+ allowZip64: if True ZipFile will create files with ZIP64 extensions
+ when needed, otherwise it will raise an exception when this
+ would be necessary.
+ compresslevel: None (default for the given compression type) or
+ an integer specifying the level to pass to the compressor.
+ When using ZIP_STORED or ZIP_LZMA this keyword has no effect.
+ When using ZIP_DEFLATED integers 0 through 9 are accepted.
+ When using ZIP_BZIP2 integers 1 through 9 are accepted.
+ When using ZIP_ZSTANDARD integers -7 though 22 are common,
+ see the CompressionParameter enum in compression.zstd for
+ details.
"""
def __init__(self, file, mode="r", compression=ZIP_STORED, allowZip64=True,
compresslevel=None, *, strict_timestamps=True, metadata_encoding=None):
- """Open the ZIP file with mode read 'r', write 'w', exclusive create 'x',
- or append 'a'."""
+ """Open the ZIP file with mode read 'r', write 'w', exclusive create
+ 'x', or append 'a'."""
if mode not in ('r', 'w', 'x', 'a'):
raise ValueError("ZipFile requires mode 'r', 'w', 'x', or 'a'")
pwd is the password to decrypt files (only used for reading).
- When writing, if the file size is not known in advance but may exceed
- 2 GiB, pass force_zip64 to use the ZIP64 format, which can handle large
- files. If the size is known in advance, it is best to pass a ZipInfo
- instance for name, with zinfo.file_size set.
+ When writing, if the file size is not known in advance but may
+ exceed 2 GiB, pass force_zip64 to use the ZIP64 format, which can
+ handle large files. If the size is known in advance, it is best to
+ pass a ZipInfo instance for name, with zinfo.file_size set.
"""
if mode not in {"r", "w"}:
raise ValueError('open() requires mode "r" or "w"')
projects / thirdparty / Python / cpython.git / commitdiff
