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.

To solve this problem, we need to create a function that zips all files located in a specified directory and returns the path to the generated zip file. The function should handle cases where the directory does not exist or contains no files, and it should not include subdirectories in the zip file.

### Approach
1. **Check Directory Existence**: Verify if the specified directory exists and is a directory. If not, raise a `FileNotFoundError`.
2. **List Directory Contents**: Use `os.listdir` to get all entries in the directory.
3. **Filter Files**: Check each entry to determine if it is a file (using `os.path.isfile`).
4. **Handle No Files Case**: If no files are found, return `None`.
5. **Create Zip File**: If files are present, create a zip file named 'files.zip' in the specified directory.
6. **Add Files to Zip**: Add each file to the zip file using `zipfile.ZipFile`.

### Solution Code
```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
    """
    if not os.path.isdir(directory):
        raise FileNotFoundError(f"The specified directory {directory} does not exist.")
    
    files = []
    for entry in os.listdir(directory):
        path = os.path.join(directory, entry)
        if os.path.isfile(path):
            files.append(path)
    
    if not files:
        return None
    
    zip_path = os.path.join(directory, 'files.zip')
    with zipfile.ZipFile(zip_path, 'w') as zipf:
        for file in files:
            zipf.write(file, os.path.basename(file))
    
    return zip_path
```

### Explanation
- **Directory Check**: The function first checks if the provided directory exists and is a directory. This is done using `os.path.isdir`.
- **Listing and Filtering Files**: The function lists all entries in the directory and filters out non-file entries.
- **Handling No Files**: If no files are found, the function returns `None`.
- **Creating and Writing to Zip File**: If files are present, the function creates a zip file named 'files.zip' in the specified directory and adds each file to this zip file.

This approach ensures that only files are zipped, subdirectories are ignored, and appropriate error handling is in place for non-existent directories and empty directories.

Okay, I need to implement the task_func function as described. Let's see what the function is supposed to do.

The function is called task_func and takes a directory as input. It should zip all the files in that directory, not including subdirectories, and return the path to the zip file. If there are no files, it returns None. Also, if the directory doesn't exist, it raises a FileNotFoundError.

First, I should check if the directory exists. So I'll use os.path.exists or maybe os.makedirs with exist_ok, but probably just check existence first.

Next, I need to find all the files in the given directory. Since it's specified that subdirectories are not included, I should only get the files directly in that directory. Using glob might be helpful here. The pattern would be something like directory + '/*' but then I need to filter out directories.

Wait, glob can be used with a pattern. So maybe using glob.glob with the pattern set to the directory plus '/*' and then checking each entry if it's a file.

Alternatively, I can list all entries in the directory and check if each is a file.

So, step by step:

1. Check if the directory exists. If not, raise FileNotFoundError.

2. Get all entries in the directory.

3. For each entry, check if it's a file (using os.path.isfile). Collect these files.

4. If no files are found, return None.

5. If there are files, create a zip file named 'files.zip' in the same directory as the input directory.

6. Add all the collected files to this zip file.

Wait, but where should the zip file be created? The example shows that the function returns the path to the zip file. The note says the zip name is always 'files.zip'. So the zip file should be in the same directory as the input directory.

So the zip path would be os.path.join(directory, 'files.zip').

Now, how to create the zip. Using zipfile.ZipFile. I'll need to write the files into it.

But wait, when creating the zip, the files should be added with their names relative to the directory. So for each file in the directory, the arcname would be the filename.

So, the process is:

- Create a new ZipFile in write mode.

- For each file in the files list, add it to the zip with its name.

Now, putting it all together.

Let me outline the steps in code:

First, check if the directory exists. If not, raise FileNotFoundError.

Then, get all files in the directory. How?

Option 1: Using os.listdir and checking each entry.

files = []
for entry in os.listdir(directory):
    path = os.path.join(directory, entry)
    if os.path.isfile(path):
        files.append(path)

Option 2: Using glob. The pattern would be directory + '/*. But wait, the pattern needs to match all files, not directories. So glob.glob(os.path.join(directory, '*')) would give all entries, but then I need to filter to include only files.

So:

file_list = [f for f in glob.glob(os.path.join(directory, '*')) if os.path.isfile(f)]

Either way is fine. Maybe using os.listdir is more straightforward.

Once I have the list of files, if it's empty, return None.

Else, create the zip file.

Now, creating the zip:

zip_path = os.path.join(directory, 'files.zip')

with zipfile.ZipFile(zip_path, 'w') as zipf:
    for file in files:
        zipf.write(file, os.path.basename(file))

Wait, but the files are in the directory, so their basename is the filename. So adding them as such.

But wait, what about the case where the directory is the current directory? No, because the directory is passed as a parameter, and the files are in that directory.

So, after creating the zip, return the zip_path.

But wait, what if the directory is not the current directory? No, the code should handle that because we're joining the directory with 'files.zip'.

Now, putting it all together.

But wait, what about the case where the directory is empty? Then files is empty, return None.

Also, the function should raise FileNotFoundError if the directory doesn't exist.

So, the code outline is:

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

Wait, but in the example, the function returns the path as a string. So the code should return zip_path.

But wait, what if the directory is not a directory? Like, if it's a file. But the function is supposed to check if the directory exists. So if the input is a file, os.path.exists would return True, but os.listdir would fail. Hmm, but in the function, after checking if the directory exists, we proceed to list its contents. So if the input is a file, os.listdir would throw an error.

Wait, no. Because if the input is a file, then os.listdir(directory) would throw a NotADirectoryError. So we need to handle that.

Wait, but the function is supposed to raise FileNotFoundError if the directory does not exist. So perhaps we should check if it's a directory.

So, perhaps the initial check should be:

if not os.path.isdir(directory):
    raise FileNotFoundError(...)

Because if the directory doesn't exist, or it's a file, then it's not a directory, so we raise.

So, modifying the code:

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

That way, if the input is a file, it raises the error.

So, updating the code:

def task_func(directory):
    if not os.path.isdir(directory):
        raise FileNotFoundError(f"The specified directory {directory} does not exist.")
    files = []
    for entry in os.listdir(directory):
        path = os.path.join(directory, entry)
        if os.path.isfile(path):
            files.append(path)
    if not files:
        return None
    zip_path = os.path.join(directory, 'files.zip')
    with zipfile.ZipFile(zip_path, 'w') as zipf:
        for file in files:
            zipf.write(file, os.path.basename(file))
    return zip_path

Wait, but what about the case where the directory is empty? Then files is empty, return None.

Testing the example:

If the directory has files, it zips them and returns the path.

Now, let's think about possible issues.

What if the directory is the root directory, like '/'? Well, the code should still work, but in practice, it's unlikely and the function would process all files in that directory.

Another point: the function should not include subdirectories. So, using os.path.isfile ensures that only files are added.

What about hidden files on Unix systems? They are included because os.path.isfile returns True for them.

So, the code seems to handle that.

Now, let's test the function.

Sample Input: '/path/to/files' which contains some files.

The function lists all entries, checks if each is a file, collects them. Then creates a zip.

Another test case: directory has no files. Returns None.

Another test case: directory doesn't exist. Raises FileNotFoundError.

Another test case: directory is a file. Raises FileNotFoundError.

Another test case: directory has both files and subdirectories. Only files are zipped.

So, the code should handle all these cases.

I think this should work.