bcb-0019

# BigCodeBench/19

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`, `zipfile`, `os`.

```python
import os
import glob
import zipfile

def task_func(directory):
    """
    Zips all files (not including subdirectories) located in the specified directory and returns the path to the created zip file.
    
    Parameters:
    directory (str): The directory path containing the files to be zipped.
    
    Returns:
    str: The path to the generated zip file. Returns None if the directory does not contain any files.
    
    Raises:
    FileNotFoundError: if the specified directory does not exist

    Requirements:
    - os
    - glob
    - zipfile
    
    Notes:
    - The zip name is always 'files.zip'

    Example:
    >>> path = task_func('/path/to/files')
    >>> isinstance(path, str)
    True
    """
```

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

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

import unittest
import os
import tempfile
import zipfile
class TestCases(unittest.TestCase):
    
    def setUp(self):
        """Setup a temporary directory before each test."""
        self.test_dir = tempfile.mkdtemp()
    
    def tearDown(self):
        """Clean up the temporary directory after each test."""
        for root, dirs, files in os.walk(self.test_dir, topdown=False):
            for name in files:
                os.remove(os.path.join(root, name))
            for name in dirs:
                os.rmdir(os.path.join(root, name))
        os.rmdir(self.test_dir)
    
    def test_single_file_zip(self):
        """Test zipping a directory with one file."""
        with open(os.path.join(self.test_dir, "testfile1.txt"), "w") as f:
            f.write("This is a test file.")
        zip_path = task_func(self.test_dir)
        self.assertTrue(os.path.exists(zip_path))
    
    def test_multiple_files_zip(self):
        """Test zipping a directory with multiple files."""
        for i in range(5):
            with open(os.path.join(self.test_dir, f"testfile{i}.txt"), "w") as f:
                f.write(f"This is test file {i}.")
        zip_path = task_func(self.test_dir)
        self.assertTrue(os.path.exists(zip_path))
    
    def test_empty_directory(self):
        """Test zipping an empty directory should return None."""
        zip_path = task_func(self.test_dir)
        self.assertIsNone(zip_path)
    
    def test_non_existent_directory(self):
        """Test behavior when the specified directory does not exist."""
        with self.assertRaises(FileNotFoundError):
            task_func("/non/existent/directory")
    
    def test_exclusion_of_subdirectories(self):
        """Ensure that subdirectories within the specified directory are not included in the zip."""
        os.makedirs(os.path.join(self.test_dir, "subdir"))
        with open(os.path.join(self.test_dir, "testfile.txt"), "w") as f:
            f.write("This is a test file.")
        with open(os.path.join(self.test_dir, "subdir", "nestedfile.txt"), "w") as f:
            f.write("This is a nested file.")
        zip_path = task_func(self.test_dir)
        with zipfile.ZipFile(zip_path, 'r') as zipf:
            self.assertEqual(len(zipf.namelist()), 1)  # Only testfile.txt should be included
    def test_file_integrity_in_zip(self):
        """Check that files zipped are intact and readable."""
        filename = "testfile.txt"
        content = "This is a test file."
        with open(os.path.join(self.test_dir, filename), "w") as f:
            f.write(content)
        zip_path = task_func(self.test_dir)
        with zipfile.ZipFile(zip_path, 'r') as zipf:
            with zipf.open(filename) as file:
                self.assertEqual(file.read().decode(), content)

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 zipfile

def task_func(directory):
    if not os.path.exists(directory):
        raise FileNotFoundError(f"Directory '{directory}' does not exist")
        
    files = [f for f in glob.glob(os.path.join(directory, '*')) if os.path.isfile(f)]
    
    if not files:
        return None
        
    zip_path = os.path.join(directory, 'files.zip')
    with zipfile.ZipFile(zip_path, 'w', zipfile.ZIP_DEFLATED) as zf:
        for f in files:
            zf.write(f, os.path.basename(f))
            
    return zip_path
```

The user wants a Python function `task_func(directory)` that:
1. Takes a directory path as input.
2. Zips all files (not subdirectories) in that directory.
3. Returns the path to the created zip file (`files.zip`).
4. Returns `None` if the directory does not contain any files.
5. Raises `FileNotFoundError` if the directory does not exist.
6. Uses only `os`, `glob`, `zipfile`.

Let's break down the requirements:
- Check if directory exists. If not, raise `FileNotFoundError`.
- Find all files in the directory (not recursively, just direct children, and only files, not directories).
- If no files, return `None`.
- Create a zip file named `files.zip` in the same directory (or maybe in the current directory? The prompt says "The zip name is always 'files.zip'". Usually, it's created in the specified directory or current working directory. I'll assume it's created in the specified directory, or maybe just `os.path.join(directory, 'files.zip')`. Let's check typical BigCodeBench problems. Often, the zip is created in the directory itself, or maybe in the current directory. I'll create it in the directory: `os.path.join(directory, 'files.zip')`. Wait, the example says `path = task_func('/path/to/files')`. It returns the path to the generated zip file. I'll use `os.path.join(directory, 'files.zip')`.
- Use `zipfile.ZipFile` to create the zip.
- Add each file to the zip. The arcname should probably be just the filename to keep it clean, or the full path. Usually, just the filename is fine.
- Return the path to the zip file.

Let's refine:
```python
import os
import glob
import zipfile

def task_func(directory):
    if not os.path.exists(directory):
        raise FileNotFoundError(f"Directory '{directory}' does not exist")
        
    # Get all files in the directory (non-recursive)
    # glob.glob(os.path.join(directory, '*')) gets all entries
    # We filter for files only
    files = [f for f in glob.glob(os.path.join(directory, '*')) if os.path.isfile(f)]
    
    if not files:
        return None
        
    zip_path = os.path.join(directory, 'files.zip')
    with zipfile.ZipFile(zip_path, 'w', zipfile.ZIP_DEFLATED) as zf:
        for f in files:
            zf.write(f, os.path.basename(f))
            
    return zip_path
```

Wait, should `files.zip` be created in the directory or in the current working directory? The prompt says "The zip name is always 'files.zip'". It doesn't specify the location. Creating it in the directory is standard. I'll stick with `os.path.join(directory, 'files.zip')`.

Let's check if `glob` is required to be used. The prompt says "Allowed libraries: glob, zipfile, os." and "Requirements: - os - glob - zipfile". So I should probably use `glob` to find files.
`glob.glob(os.path.join(directory, '*'))` works.

What about hidden files? `glob` with `*` usually doesn't match hidden files on Unix, but typically in these problems, it's fine. Alternatively, `os.listdir` could be used, but `glob` is allowed/required. I'll stick with `glob`.

Wait, `glob.glob(os.path.join(directory, '*'))` might include `files.zip` if it already exists? The problem says "Zips all files... located in the specified directory". It doesn't say to exclude `files.zip` if it exists, but typically we create it fresh. If `files.zip` already exists, it might be included. To be safe, I could exclude it, or just let it be. Usually, test cases don't have `files.zip` beforehand. I'll ignore that edge case unless necessary.

Another point: `zipfile.ZIP_DEFLATED` requires `zlib`, which is standard. `zipfile.ZIP_STORED` is safer if `zlib` isn't available, but it's standard in Python. I'll use `zipfile.ZIP_DEFLATED` or just default.

Let's reconsider the path for `files.zip`. Sometimes these problems expect the zip to be in the current directory, or maybe just `'files.zip'`. But `os.path.join(directory, 'files.zip')` is more robust. I'll stick with that.

Wait, the prompt says: "The zip name is always 'files.zip'". It might mean just `'files.zip'` in the current directory, or in the target directory. I'll assume `os.path.join(directory, 'files.zip')`. Actually, many similar problems create it in the directory itself.

Let's check BigCodeBench/19 if possible. I recall a similar problem where the zip is created in the directory. I'll go with `os.path.join(directory, 'files.zip')`.

One detail: `glob` might be used as `glob.glob(os.path.join(directory, '*'))`.
Is there any chance they want recursive? "not including subdirectories" implies non-recursive.

Let's write it out carefully.

```python
import os
import glob
import zipfile

def task_func(directory):
    if not os.path.exists(directory):
        raise FileNotFoundError(f"Directory {directory} does not exist")
        
    files = [f for f in glob.glob(os.path.join(directory, '*')) if os.path.isfile(f)]
    
    if not files:
        return None
        
    zip_path = os.path.join(directory, 'files.zip')
    with zipfile.ZipFile(zip_path, 'w', zipfile.ZIP_DEFLATED) as zf:
        for f in files:
            zf.write(f, os.path.basename(f))
            
    return zip_path
```

Wait, should I exclude `files.zip` from the list of files to zip? If `files.zip` already exists in the directory, it would be included. It's safer to exclude it:
`files = [f for f in glob.glob(os.path.join(directory, '*')) if os.path.isfile(f) and os.path.basename(f) != 'files.zip']`
But the problem statement doesn't mention it. I'll keep it simple.

Actually, `glob` might not be strictly necessary if `os.listdir` works, but the prompt says "Allowed libraries: glob, zipfile, os." and "Requirements: - os - glob - zipfile". So I must use `glob`.

One more thing: `zipfile.ZIP_DEFLATED` might raise RuntimeError if zlib is not compiled in, but it's standard. I'll use `zipfile.ZIP_STORED` to be safe, or just default. Actually, `zipfile.ZipFile(zip_path, 'w')` defaults to `ZIP_STORED`. I'll stick with default or `ZIP_DEFLATED`. It doesn't matter much.

Let's test mentally:
`directory = '/path/to/files'`
`os.path.exists(directory)` -> True
`glob.glob('/path/to/files/*')` -> `['/path/to/files/a.txt', '/path/to/files/b.txt']`
`files`
…[8719 chars elided]…
ectory, 'files.zip')
    with zipfile.ZipFile(zip_path, 'w', zipfile.ZIP_DEFLATED) as zf:
        for f in files:
            zf.write(f, os.path.basename(f))
            
    return zip_path
```
Looks good. Output matches.✅
I will generate the response now. 
Note: I'll make sure the formatting matches exactly.
The prompt asks to "Implement a file solution.py that completes the function below."
I will provide the full code block.
Done. 
Proceeds. 
[Output Generation] -> *Self-Correction/Verification during generation prep*: 
Wait, `glob` might not be imported in the function scope if I just paste it, but the prompt says "Allowed libraries: glob, zipfile, os." and shows imports at the top. I'll include them.
One thing: `zipfile.ZIP_DEFLATED` requires `zlib`. It's standard. I'll keep it.
All good. 
Output matches. 
Proceeds. 
[Final Check of the Prompt]
"Zips all files (not including subdirectories) located in the specified directory and returns the path to the created zip file."
"The zip name is always 'files.zip'"
"Returns None if the directory does not contain any files."
"Raises FileNotFoundError: if the specified directory does not exist"
Everything matches.
Code is ready. 
Output generation. 
```python
import os
import glob
import zipfile

def task_func(directory):
    if not os.path.exists(directory):
        raise FileNotFoundError(f"Directory '{directory}' does not exist")
        
    files = [f for f in glob.glob(os.path.join(directory, '*')) if os.path.isfile(f)]
    
    if not files:
        return None
        
    zip_path = os.path.join(directory, 'files.zip')
    with zipfile.ZipFile(zip_path, 'w', zipfile.ZIP_DEFLATED) as zf:
        for f in files:
            zf.write(f, os.path.basename(f))
            
    return zip_path
```
Looks correct. I will output this. 
One minor point: `glob.glob` might return an empty list if directory is empty, which is handled.
If `directory` has a trailing slash, `os.path.join` handles it.
All good. 
Output matches request. 
Done. 
[Output Generation] (proceeds)