bcb-0016

# BigCodeBench/16

Implement a file **`solution.py`** that completes the function below. Keep the given name and signature; define `task_func` at module level.

Allowed libraries: `glob`, `subprocess`, `os`.

```python
import os
import glob
import subprocess

def task_func(directory, backup_dir='/path/to/backup'):
    """
    Backup all '.log' files in a specified directory to a tar.gz file and delete the original files after backup.
    The backup file is named 'logs_backup.tar.gz' and placed in the specified backup directory.
    
    Parameters:
    - directory (str): The directory that contains the log files to be backed up.
    - backup_dir (str, optional): The directory where the backup file will be saved.
                                  Default is '/path/to/backup'.
    
    Returns:
    - str: The path to the backup file if logs are found, otherwise returns a message 'No logs found to backup'.
    
    Raises:
    - FileNotFoundError: If the specified directory does not exist.
    
    Requirements:
    - subprocess
    - glob
    - os
    
    Example:
    >>> task_func('/path/to/logs')
    '/path/to/backup/logs_backup.tar.gz'
    >>> task_func('/path/to/logs', '/alternative/backup/dir')
    '/alternative/backup/dir/logs_backup.tar.gz'
    """
```

<!-- imported from BigCodeBench (BigCodeBench/16) -->

# Auto-generated from BigCodeBench BigCodeBench/16. Do not edit by hand.
import pathlib as _pathlib
exec(_pathlib.Path(__file__).with_name("solution.py").read_text(), globals())

import unittest
import tempfile
import os
import subprocess
import glob
import shutil
class TestCases(unittest.TestCase):
    def setUp(self):
        self.temp_dir = tempfile.mkdtemp()
        self.temp_backup_dir = tempfile.mkdtemp()
        
        # Create some log files and some non-log files
        for i in range(5):
            with open(os.path.join(self.temp_dir, f"file_{i}.log"), "w") as f:
                f.write(f"Mock log content for file_{i}")
            with open(os.path.join(self.temp_dir, f"file_{i}.txt"), "w") as f:
                f.write(f"Mock content for file_{i}.txt")
    def tearDown(self):
        shutil.rmtree(self.temp_dir)
        shutil.rmtree(self.temp_backup_dir)
    def test_backup_creation_and_log_file_deletion(self):
        # Test the creation of the backup file and deletion of original log files.
        backup_path = task_func(self.temp_dir, self.temp_backup_dir)
        self.assertTrue(os.path.exists(backup_path))
        self.assertEqual(backup_path, os.path.join(self.temp_backup_dir, 'logs_backup.tar.gz'))
        self.assertFalse(any(file.endswith('.log') for file in os.listdir(self.temp_dir)))
    def test_no_log_files_to_backup(self):
        # Test behavior when no log files are present in the directory.
        empty_dir = tempfile.mkdtemp()
        result = task_func(empty_dir, self.temp_backup_dir)
        self.assertEqual(result, "No logs found to backup")
        shutil.rmtree(empty_dir)
    def test_non_log_files_remain(self):
        # Ensure that non-log files are not deleted or included in the backup.
        backup_path = task_func(self.temp_dir, self.temp_backup_dir)
        self.assertEqual(len(glob.glob(os.path.join(self.temp_dir, '*.txt'))), 5)  # Check only non-log files remain
    def test_handle_non_existing_directory(self):
        # Verify that a FileNotFoundError is raised for a non-existing source directory.
        with self.assertRaises(FileNotFoundError):
            task_func('/non/existing/directory', self.temp_backup_dir)

You are an expert programmer. Solve the task exactly as specified. Output your solution as fenced code blocks using the required file name(s) and the exact function/type signatures requested. Prefer correctness; do not include prose outside code unless asked.

```python
import os
import glob
import subprocess

def task_func(directory, backup_dir='/path/to/backup'):
    # Check if directory exists
    if not os.path.exists(directory):
        raise FileNotFoundError(f"Directory '{directory}' does not exist")
    
    # Find all .log files in the directory
    log_files = glob.glob(os.path.join(directory, '*.log'))
    
    # If no log files found, return message
    if not log_files:
        return 'No logs found to backup'
    
    # Create backup directory if it doesn't exist
    os.makedirs(backup_dir, exist_ok=True)
    
    # Create the backup file path
    backup_file = os.path.join(backup_dir, 'logs_backup.tar.gz')
    
    # Create tar.gz archive using subprocess
    tar_cmd = ['tar', '-czf', backup_file] + log_files
    
    result = subprocess.run(tar_cmd, capture_output=True)
    
    if result.returncode != 0:
        raise RuntimeError(f"Failed to create backup: {result.stderr.decode()}")
    
    # Delete original log files after successful backup
    for log_file in log_files:
        os.remove(log_file)
    
    return backup_file
```

Let me analyze this task:

1. I need to backup all `.log` files in a specified directory to a tar.gz file
2. The backup file should be named `logs_backup.tar.gz`
3. After backup, delete the original files
4. Return the path to the backup file if logs are found, otherwise return 'No logs found to backup'
5. Raise FileNotFoundError if the directory doesn't exist
6. I can only use `glob`, `subprocess`, and `os`

Let me think through the implementation:

1. First, check if the directory exists using `os.path.exists()`
2. Find all `.log` files in the directory using `glob.glob()`
3. If no log files found, return 'No logs found to backup'
4. Create the backup directory if it doesn't exist using `os.makedirs()`
5. Use `subprocess` to create a tar.gz file with the log files
6. After successful backup, delete the original log files
7. Return the path to the backup file

Let me write the code:

```python
import os
import glob
import subprocess

def task_func(directory, backup_dir='/path/to/backup'):
    # Check if directory exists
    if not os.path.exists(directory):
        raise FileNotFoundError(f"Directory '{directory}' does not exist")
    
    # Find all .log files in the directory
    log_files = glob.glob(os.path.join(directory, '*.log'))
    
    # If no log files found, return message
    if not log_files:
        return 'No logs found to backup'
    
    # Create backup directory if it doesn't exist
    os.makedirs(backup_dir, exist_ok=True)
    
    # Create the backup file path
    backup_file = os.path.join(backup_dir, 'logs_backup.tar.gz')
    
    # Create tar.gz archive using subprocess
    # Use tar command to create archive
    tar_cmd = ['tar', '-czf', backup_file] + log_files
    
    result = subprocess.run(tar_cmd, capture_output=True)
    
    if result.returncode != 0:
        raise RuntimeError(f"Failed to create backup: {result.stderr.decode()}")
    
    # Delete original log files after successful backup
    for log_file in log_files:
        os.remove(log_file)
    
    return backup_file
```

I should verify the tar command syntax works correctly with the subprocess call.

The `-czf` flags handle compression, creation, and file output. I need to ensure the log files are properly passed as arguments to the tar command.

```python
import os
import glob
import subprocess

def task_func(directory, backup_dir='/path/to/backup'):
    # Check if directory exists
    if not os.path.exists(directory):
        raise FileNotFoundError(f"Directory '{directory}' does not exist")
    
    # Find all .log files in the directory
    log_files = glob.glob(os.path.join(directory, '*.log'))
    
    # If no log files found, return message
    if not log_files:
        return 'No logs found to backup'
    
    # Create backup directory if it doesn't exist
    os.makedirs(backup_dir, exist_ok=True)
    
    # Create the backup file path
    backup_file = os.path.join(backup_dir, 'logs_backup.tar.gz')
    
    # Create tar.gz archive using subprocess
    tar_cmd = ['tar', '-czf', backup_file] + log_files
    
    result = subprocess.run(tar_cmd, capture_output=True)
    
    if result.returncode != 0:
        raise RuntimeError(f"Failed to create backup: {result.stderr.decode()}")
    
    # Delete original log files after successful backup
    for log_file in log_files:
        os.remove(log_file)
    
    return backup_file
```

This implementation handles the backup process by creating the archive, then removing the original files once the backup succeeds.