style/doc improvements, change arcname to archive_name

pandas/core/generic.py

@@ -2920,10 +2920,10 @@ def to_latex(self, buf=None, columns=None, col_space=None, header=True,
     def to_csv(self, path_or_buf=None, sep=",", na_rep='', float_format=None,
                columns=None, header=True, index=True, index_label=None,
                mode='w', encoding=None,
-               compression: Union[str, Dict, None] = 'infer', quoting=None,
-               quotechar='"', line_terminator=None, chunksize=None,
-               tupleize_cols=None, date_format=None, doublequote=True,
-               escapechar=None, decimal='.'):
+               compression: Union[str, Dict, None] = 'infer',
+               quoting=None, quotechar='"', line_terminator=None,
+               chunksize=None, tupleize_cols=None, date_format=None,
+               doublequote=True, escapechar=None, decimal='.'):
         r"""
         Write object to a comma-separated values (csv) file.
 
@@ -2977,9 +2977,8 @@ def to_csv(self, path_or_buf=None, sep=",", na_rep='', float_format=None,
             compression mode is 'infer' and `path_or_buf` is path-like, then
             detect compression mode from the following extensions: '.gz',
             '.bz2', '.zip' or '.xz'. (otherwise no compression). If dict given
-            and mode is 'zip' or inferred as 'zip', optional value at 'arcname'
-            specifies name of file within ZIP archive, assuming equal to
-            `path_or_buf` if not specified or None.
+            and mode is 'zip' or inferred as 'zip', other entries passed as
+            kwargs to ByteZipFile.
 
             .. versionchanged:: 0.25.0
 

pandas/io/common.py

@@ -9,7 +9,7 @@
 import lzma
 import mmap
 import os
-from typing import Dict, Tuple, Union
+from typing import Any, Dict, Tuple, Union
 from urllib.error import URLError  # noqa
 from urllib.parse import (  # noqa
     urlencode, urljoin, urlparse as parse_url, uses_netloc, uses_params,
@@ -254,7 +254,7 @@ def _get_compression_method(compression: Union[str, Dict, None]):
     ------
     ValueError on dict missing 'method' key
     """
-    compression_args = {}  # type: Dict
+    compression_args = {}  # type: Dict[str, Any]
     # Handle dict
     if isinstance(compression, dict):
         compression_args = compression.copy()
@@ -319,8 +319,8 @@ def _infer_compression(filepath_or_buffer, compression):
 
 
 def _get_handle(path_or_buf, mode, encoding=None,
-                compression: Union[str, Dict, None] = None, memory_map=False,
-                is_text=True):
+                compression: Union[str, Dict, None] = None,
+                memory_map=False, is_text=True):
     """
     Get file handle for given path/buffer and mode.
 
@@ -338,8 +338,7 @@ def _get_handle(path_or_buf, mode, encoding=None,
         and `filepath_or_buffer` is path-like, then detect compression from
         the following extensions: '.gz', '.bz2', '.zip', or '.xz' (otherwise
         no compression). If dict and compression mode is 'zip' or inferred as
-        'zip', optional value at key 'arcname' specifies the name of the file
-        within ZIP archive at `path_or_buf`.
+        'zip', other entries passed as kwargs to ByteZipFile.
 
         .. versionchanged:: 0.25.0
 
@@ -466,15 +465,18 @@ class BytesZipFile(zipfile.ZipFile, BytesIO):  # type: ignore
     """
     # GH 17778
     def __init__(self, file, mode, compression=zipfile.ZIP_DEFLATED,
-                 arcname: Union[str, zipfile.ZipInfo, None] = None, **kwargs):
+                 archive_name: Union[str, zipfile.ZipInfo, None] = None,
+                 **kwargs):
         if mode in ['wb', 'rb']:
             mode = mode.replace('b', '')
-        self.arcname = arcname
+        self.archive_name = archive_name
         super().__init__(file, mode, compression, **kwargs)
 
     def write(self, data):
-        arcname = self.filename if self.arcname is None else self.arcname
-        super().writestr(arcname, data)
+        archive_name = self.filename
+        if self.archive_name is not None:
+            archive_name = self.archive_name
+        super().writestr(archive_name, data)
 
     @property
     def closed(self):

pandas/io/formats/csvs.py

@@ -28,19 +28,19 @@ class CSVFormatter(object):
     def __init__(self, obj, path_or_buf=None, sep=",", na_rep='',
                  float_format=None, cols=None, header=True, index=True,
                  index_label=None, mode='w', nanRep=None, encoding=None,
-                 compression: Union[str, Dict, None] = 'infer', quoting=None,
-                 line_terminator='\n', chunksize=None, tupleize_cols=False,
-                 quotechar='"', date_format=None, doublequote=True,
-                 escapechar=None, decimal='.'):
+                 compression: Union[str, Dict, None] = 'infer',
+                 quoting=None, line_terminator='\n', chunksize=None,
+                 tupleize_cols=False, quotechar='"', date_format=None,
+                 doublequote=True, escapechar=None, decimal='.'):
 
         self.obj = obj
 
         if path_or_buf is None:
             path_or_buf = StringIO()
 
         # Extract compression mode as given, if dict
-        compression, self.compression_args \
-            = _get_compression_method(compression)
+        compression, self.compression_args = _get_compression_method(
+            compression)
 
         self.path_or_buf, _, _, _ = get_filepath_or_buffer(
             path_or_buf, encoding=encoding,

pandas/tests/io/formats/test_to_csv.py

@@ -550,18 +550,18 @@ def test_to_csv_compression_dict(self, compression_only):
             tm.assert_frame_equal(read_df, df)
 
     @pytest.mark.parametrize("compression", ["zip", "infer"])
-    @pytest.mark.parametrize("arcname", [None, "test_to_csv.csv",
-                                         "test_to_csv.zip"])
-    def test_to_csv_zip_arcname(self, compression, arcname):
+    @pytest.mark.parametrize("archive_name", [None, "test_to_csv.csv",
+                                              "test_to_csv.zip"])
+    def test_to_csv_zip_arguments(self, compression, archive_name):
         # GH 26023
         from zipfile import ZipFile
 
         df = DataFrame({"ABC": [1]})
-        with tm.ensure_clean("to_csv_arcname.zip") as path:
+        with tm.ensure_clean("to_csv_archive_name.zip") as path:
             df.to_csv(path, compression={"method": compression,
-                                         "arcname": arcname})
+                                         "archive_name": archive_name})
             zp = ZipFile(path)
-            expected_arcname = path if arcname is None else arcname
+            expected_arcname = path if archive_name is None else archive_name
             expected_arcname = os.path.basename(expected_arcname)
             assert len(zp.filelist) == 1
             archived_file = os.path.basename(zp.filelist[0].filename)