Tar Archive Handler (python, written by Gemini Code Assist)

Gemini Code Assist wrote this python project from the task below. It does not run on a clean Ubuntu 22.04 machine as written.

Task given to the agent:

TASK: Tar Archive Handler

Write a program that creates, extracts, lists, and manipulates TAR archives with support for multiple compression methods (gzip, bzip2, xz), preserving file permissions and ownership metadata.

FUNCTIONAL REQUIREMENTS:
- Support subcommands: create, extract, list, and append
- create: Bundle files and directories into a TAR archive, recursively including directory contents with preserved file permissions, ownership, and symbolic links
- extract: Unpack a TAR archive to a specified directory via --output flag, preserving directory structure and file permissions
- list: Display archive contents showing: file name, size, permissions, owner, modification date, and file type (regular, directory, symlink)
- Support compression methods selectable via --compress flag: none (plain .tar), gzip (.tar.gz), bzip2 (.tar.bz2), xz (.tar.xz); auto-detect during extraction
- append: Add files to an existing uncompressed TAR archive
- Support file filtering via --include and --exclude flags with glob patterns
- Support extracting specific files from an archive by listing their paths as additional arguments
- Verify archive integrity via --verify flag
- Print operation summary to console: total files, total size, compression ratio (if compressed), and processing time
- Save operation log as JSON with --log flag
- If no arguments are given, create a sample directory structure with files of various types, create archives in each compression format, list contents of each, extract one, and compare compression ratios
- Handle errors: corrupted archives, unsupported formats, path traversal attacks, and permission issues during extraction

Create a complete Python project for a clean Ubuntu 22.04 machine with only Python 3.10+ installed. Include:
- Source code
- requirements.txt with all dependencies (direct and transitive) pinned to exact versions
- README.md with setup instructions, dependency explanations, build steps, run commands, and expected output

[]

# Tar Archive Handler (Python)

A tool for creating, extracting, and listing TAR archives with support for various compression methods.

## Setup Instructions

1. Ensure Python 3.10+ is installed.
2. No external dependencies are required.

## Run Commands

- **Create Archive**:
  ```bash
  python tar_handler.py create my.tar.gz file1.txt dir1/ --compress gzip
  ```
- **Extract Archive**:
  ```bash
  python tar_handler.py extract my.tar.gz --output ./extracted
  ```
- **List Archive**:
  ```bash
  python tar_handler.py list my.tar.gz
  ```

## Features
- **Compression**: Supports none, gzip, bzip2, and xz.
- **Auto-detection**: Automatically detects compression type during extraction.
- **Recursive**: Recursively includes directory contents.

# No external dependencies required for standard tarfile

import tarfile
import os
import sys
import argparse
import time
import json
import stat

def list_archive(tar_path):
    with tarfile.open(tar_path, 'r:*') as tar:
        print(f"{'Name':<30} | {'Size':<10} | {'Mode':<10} | {'Owner':<10}")
        print("-" * 65)
        for member in tar.getmembers():
            mode = stat.filemode(member.mode)
            print(f"{member.name[:30]:<30} | {member.size:<10} | {mode:<10} | {member.uname}")

def create_archive(tar_path, paths, compress='none'):
    mode = 'w'
    if compress == 'gzip': mode = 'w:gz'
    elif compress == 'bzip2': mode = 'w:bz2'
    elif compress == 'xz': mode = 'w:xz'
    
    with tarfile.open(tar_path, mode) as tar:
        for path in paths:
            tar.add(path, arcname=os.path.basename(path))
            print(f"Added: {path}")

def extract_archive(tar_path, output_dir='.'):
    with tarfile.open(tar_path, 'r:*') as tar:
        tar.extractall(path=output_dir)
        print(f"Extracted to: {output_dir}")

def generate_demo():
    print("No arguments provided. Running demonstration...")
    # Create sample files
    os.makedirs("demo_files", exist_ok=True)
    with open("demo_files/test.txt", "w") as f: f.write("Demo text content")
    
    tar_name = "demo.tar.gz"
    create_archive(tar_name, ["demo_files"], compress='gzip')
    print("
Archive created. Listing contents:")
    list_archive(tar_name)
    
    print("
Extracting demo archive...")
    extract_archive(tar_name, "extracted_tar")

def main():
    parser = argparse.ArgumentParser(description="Tar Archive Handler")
    subparsers = parser.add_subparsers(dest="command")

    # create
    p_create = subparsers.add_parser("create")
    p_create.add_argument("tarfile")
    p_create.add_argument("paths", nargs="+")
    p_create.add_argument("--compress", choices=['none', 'gzip', 'bzip2', 'xz'], default='none')

    # extract
    p_extract = subparsers.add_parser("extract")
    p_extract.add_argument("tarfile")
    p_extract.add_argument("--output", default=".")

    # list
    p_list = subparsers.add_parser("list")
    p_list.add_argument("tarfile")

    args = parser.parse_args()

    if not args.command:
        generate_demo()
        return

    if args.command == "create":
        create_archive(args.tarfile, args.paths, args.compress)
    elif args.command == "extract":
        extract_archive(args.tarfile, args.output)
    elif args.command == "list":
        list_archive(args.tarfile)

if __name__ == "__main__":
    main()