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.

To solve this problem, we need to create a function that backs up all `.log` files from a specified directory into a single tar.gz file and then deletes the original files. The backup file is named `logs_backup.tar.gz` and is placed in a specified backup directory. If no `.log` files are found, the function returns a message indicating this. If the specified directory does not exist, a `FileNotFoundError` is raised.

### Approach
1. **Check Directory Existence**: Verify that the specified directory exists and is a directory. If not, raise a `FileNotFoundError`.
2. **Find Log Files**: Use `glob` to find all `.log` files in the specified directory.
3. **Handle Backup Directory**: Ensure the backup directory exists by creating it if necessary.
4. **Create Tar.gz Backup**: Use `subprocess` to run the `tar` command to create a compressed backup of the found `.log` files.
5. **Delete Original Files**: After successfully creating the backup, delete the original `.log` files.
6. **Return Backup Path**: Return the path to the backup file if the operation is successful.

### Solution Code
```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.
    """
    # Check if the directory exists and is a directory
    if not os.path.isdir(directory):
        raise FileNotFoundError(f"The directory {directory} does not exist or is not a directory.")
    
    # Find all .log files in the directory
    log_files = glob.glob(os.path.join(directory, '*.log'))
    
    if not log_files:
        return 'No logs found to backup'
    
    # Ensure the backup directory exists
    os.makedirs(backup_dir, exist_ok=True)
    
    # Create the output path
    output_path = os.path.join(backup_dir, 'logs_backup.tar.gz')
    
    # Create the tar.gz file
    subprocess.run(['tar', '-czf', output_path] + log_files, check=True)
    
    # Delete the original .log files
    for file in log_files:
        os.remove(file)
    
    return output_path
```

### Explanation
1. **Directory Check**: The function first checks if the specified directory exists and is a directory. This ensures that we do not proceed if the directory is invalid.
2. **Finding Log Files**: Using `glob.glob`, we find all files ending with `.log` in the specified directory. This helps in identifying all relevant files to be backed up.
3. **Backup Directory Handling**: The backup directory is created if it does not exist, ensuring that the backup file can be saved without issues.
4. **Tar.gz Creation**: The `tar` command is used to create a compressed backup of the found `.log` files. This is executed using `subprocess.run` to run the command in the shell.
5. **File Deletion**: After successfully creating the backup, the original `.log` files are deleted to free up space.
6. **Return Path**: The function returns the path to the backup file, indicating the success of the operation. If no `.log` files are found, it returns a message indicating this.

Okay, I need to implement the task_func function as described. Let's see what the function is supposed to do. The goal is to backup all '.log' files in a specified directory into a tar.gz file and then delete the original files. The backup file is named 'logs_backup.tar.gz' and placed in the backup directory. 

First, I should check if the given directory exists. If it doesn't, the function should raise a FileNotFoundError. So I'll need to use os.path.exists or os.access to check that.

Next, I need to find all the .log files in that directory. Using glob.glob seems appropriate here. The pattern would be something like os.path.join(directory, '*.log') to get all files ending with .log in the specified directory.

If there are no .log files, the function should return 'No logs found to backup'. So I'll have to check if the list of found files is empty after the glob.

Once I have the list of files, I need to create a tar.gz archive. How do I do that using subprocess? Well, the command would involve using tar with the z option for gzip. The command would be something like 'tar -czf {output_path} {input_files}'. 

Wait, the output path should be in the backup_dir. So I need to construct the output path as os.path.join(backup_dir, 'logs_backup.tar.gz'). 

So the steps are:

1. Check if the directory exists. If not, raise FileNotFoundError.
2. Use glob to find all .log files in the directory.
3. If no files found, return the message.
4. Otherwise, create a tar.gz of these files.
5. The tar command should be run via subprocess.run, probably with shell=True since it's a single command line string.

Wait, but using shell=True can be a security risk, but in this controlled scenario, it's probably acceptable. Alternatively, I could split the command into parts without using shell, but that might complicate things.

So the subprocess call would be something like:

subprocess.run(['tar', 'czf', output_path] + log_files, check=True)

Wait, no. Because the syntax for tar is 'tar -czf output.tar.gz file1 file2 ...'. So the arguments would be 'tar', '-czf', output_path, followed by each file. So in the subprocess, it's better to construct the command as a list.

Wait, but the way to pass arguments to subprocess.run is as a list where each element is a separate argument. So the command would be:

['tar', 'czf', output_path] + [each file in log_files]

Wait, no. Because 'czf' is a single argument. So the correct command is:

subprocess.run(['tar', 'czf', output_path] + log_files, shell=False, check=True)

Wait, no. Because 'tar' requires options to be passed as separate arguments. So 'tar' is the first argument, then '-czf' is the next, then the output file, then the files to compress.

Wait, no. Let me think again. The correct way to call tar with these options is:

tar -czf output.tar.gz file1 file2 ...

So in the subprocess, the command list should be ['tar', '-czf', output_path] + log_files.

Yes, that makes sense. So the command is built as a list where the first element is 'tar', then '-czf', then the output path, followed by all the log files.

I should also make sure that the backup directory exists. Because if it doesn't, the tar command might fail. So perhaps I should create the directory if it doesn't exist. Using os.makedirs with exist_ok=True.

Wait, but the function's parameters specify that backup_dir is optional, defaulting to '/path/to/backup'. So I should check if backup_dir exists. If not, create it. So before proceeding, I can do:

os.makedirs(backup_dir, exist_ok=True)

That way, the directory is created if necessary.

Once the tar.gz is created, the function needs to delete the original .log files. So after the backup, loop through each file in log_files and delete them using os.remove.

Putting it all together:

- Check if directory exists. If not, raise FileNotFoundError.
- Find all .log files in directory. If none, return message.
- Create backup_dir if it doesn't exist.
- Run the tar command to create the backup.
- Delete each .log file.
- Return the path to the backup file.

Wait, but what if the tar command fails? The subprocess.run with check=True will raise a CalledProcessError, which is a subprocess.CalledProcessError. Should I handle that? The function's docstring doesn't mention handling it, but perhaps it's better to let it propagate, as the function is supposed to raise FileNotFoundError but not sure about other exceptions.

So, the steps in code:

def task_func(directory, backup_dir='/path/to/backup'):
    # Check if directory exists
    if not os.path.exists(directory):
        raise FileNotFoundError(f"The directory {directory} does not exist.")
    
    # Find all .log files
    log_files = glob.glob(os.path.join(directory, '*.log'))
    
    if not log_files:
        return 'No logs found to backup'
    
    # Ensure backup directory exists
    os.makedirs(backup_dir, exist_ok=True)
    
    # Create the output path
    output_path = os.path.join(backup_dir, 'logs_backup.tar.gz')
    
    # Run the tar command
    subprocess.run(['tar', '-czf', output_path] + log_files, check=True)
    
    # Delete the original files
    for file in log_files:
        os.remove(file)
    
    # Return the backup path
    return output_path

Wait, but what about the case where the directory is not a directory? Like, if it's a file, os.path.exists would return True, but it's not a directory. So perhaps I should check if it's a directory.

So, better to use os.path.isdir(directory). Because if the directory doesn't exist or is not a directory, we should raise FileNotFoundError.

So adjust the first check:

if not os.path.isdir(directory):
    raise FileNotFoundError(f"The specified directory {directory} does not exist or is not a directory.")

That's better.

Another thing: when using glob, it's possible that the directory contains files that are not .log, but the pattern '*.log' should only match .log files.

Wait, but what about subdirectories? The glob pattern by default doesn't search recursively. So if the directory has subdirectories with .log files, they won't be included. But the function's description says 'in a specified directory', so perhaps it's intended to only look in the top-level directory, not subdirectories.

So the current approach is correct.

Testing the example:

Example 1:
task_func('/path/to/logs') should return '/path/to/backup/logs_backup.tar.gz'

In this case, the backup_dir is the default. The function finds the .log files, creates the tar.gz in the backup_dir, deletes the originals, and returns the path.

Another example:
task_func('/path/to/logs', '/alternative/backup/dir') returns '/alternative/backup/dir/logs_backup.tar.gz'

So the code should handle that.

What about edge cases?

Case where directory is empty except for .log files: handled, as log_files would be empty, returns the message.

What if the backup_dir is the same as the directory? Then the backup file is created in the same directory, and the original files are deleted. That's acceptable.

Another point: when using subprocess.run, if the command fails, it raises an exception. So the function will propagate that error, which is fine.

So the code should be as written.