Add docstrings for high-priority methods

- Add comprehensive docstring to Formatter.wrap_unload() method
- Add docstrings to S3FileSystem.put_file() and get_file() methods
- Fix indentation issues in docstring formatting

🤖 Generated with [Claude Code](https://claude.ai/code)

Co-Authored-By: Claude <noreply@anthropic.com>

Author: laughingman7743

pyathena/filesystem/s3.py

@@ -902,6 +902,23 @@ def cat_file(
         )[1]
 
     def put_file(self, lpath: str, rpath: str, callback=_DEFAULT_CALLBACK, **kwargs):
+        """Upload a local file to S3.
+
+        Uploads a file from the local filesystem to an S3 location. Supports
+        automatic content type detection based on file extension and provides
+        progress callback functionality.
+
+        Args:
+            lpath: Local file path to upload.
+            rpath: S3 destination path (s3://bucket/key).
+            callback: Progress callback for tracking upload progress.
+            **kwargs: Additional S3 parameters (e.g., ContentType, StorageClass).
+
+        Note:
+            Directories are not supported for upload. If lpath is a directory,
+            the method returns without performing any operation. Bucket-only
+            destinations (without key) are also not supported.
+        """
         if os.path.isdir(lpath):
             # No support for directory uploads.
             return
@@ -929,6 +946,22 @@ def put_file(self, lpath: str, rpath: str, callback=_DEFAULT_CALLBACK, **kwargs)
         self.invalidate_cache(rpath)
 
     def get_file(self, rpath: str, lpath: str, callback=_DEFAULT_CALLBACK, outfile=None, **kwargs):
+        """Download an S3 file to local filesystem.
+
+        Downloads a file from S3 to the local filesystem with progress tracking.
+        Reads the file in chunks to handle large files efficiently.
+
+        Args:
+            rpath: S3 source path (s3://bucket/key).
+            lpath: Local destination file path.
+            callback: Progress callback for tracking download progress.
+            outfile: Unused parameter for fsspec compatibility.
+            **kwargs: Additional S3 parameters passed to open().
+
+        Note:
+            If lpath is a directory, the method returns without performing
+            any operation.
+        """
         if os.path.isdir(lpath):
             return
 

pyathena/formatter.py

@@ -87,6 +87,44 @@ def wrap_unload(
         format_: str = AthenaFileFormat.FILE_FORMAT_PARQUET,
         compression: str = AthenaCompression.COMPRESSION_SNAPPY,
     ):
+        """Wrap a SELECT query with UNLOAD statement for high-performance result retrieval.
+
+        Transforms SELECT or WITH queries into UNLOAD statements that export results
+        directly to S3 in optimized formats (Parquet, ORC) with compression. This
+        approach is significantly faster than standard CSV-based result retrieval
+        for large datasets and preserves data types more accurately.
+
+        Args:
+            operation: SQL query to wrap. Must be a SELECT or WITH statement.
+            s3_staging_dir: Base S3 directory for storing UNLOAD results.
+            format_: Output file format. Defaults to Parquet for optimal performance.
+            compression: Compression algorithm. Defaults to Snappy for balanced
+                       compression ratio and speed.
+
+        Returns:
+            Tuple containing:
+            - Modified UNLOAD query string
+            - S3 location where results will be stored (None if not SELECT/WITH)
+
+        Example:
+            >>> query = "SELECT * FROM sales WHERE year = 2023"
+            >>> unload_query, location = Formatter.wrap_unload(
+            ...     query, "s3://my-bucket/results/"
+            ... )
+            >>> print(unload_query)
+            UNLOAD (
+                SELECT * FROM sales WHERE year = 2023
+            )
+            TO 's3://my-bucket/results/unload/20231215/uuid//'
+            WITH (
+                format = 'PARQUET',
+                compression = 'SNAPPY'
+            )
+
+        Note:
+            Only SELECT and WITH statements are wrapped. Other statement types
+            are returned unchanged with location=None.
+        """
         if not operation or not operation.strip():
             raise ProgrammingError("Query is none or empty.")