bcb-0001

# BigCodeBench/1

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

Allowed libraries: `collections`, `random`, `string`.

```python
import collections
import random
import string

def task_func(length=100):
    """
    Generate a random string of the specified length composed of uppercase and lowercase letters, 
    and then count the occurrence of each character in this string.

    Parameters:
    length (int, optional): The number of characters in the generated string. Default is 100.

    Returns:
    dict: A dictionary where each key is a character from the generated string and the value 
            is the count of how many times that character appears in the string.

    Requirements:
    - collections
    - random
    - string

    Raises:
    ValueError if the length is a negative number

    Example:
    >>> import random
    >>> random.seed(42)  # Ensures reproducibility for demonstration
    >>> task_func(10)
    {'h': 1, 'B': 2, 'O': 1, 'L': 1, 'm': 1, 'j': 1, 'u': 1, 'E': 1, 'V': 1}
    """
```

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

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

import unittest
import string
class TestCases(unittest.TestCase):
    def setUp(self):
        # Prepare valid characters and set a random seed for reproducibility
        self.valid_chars = string.ascii_uppercase + string.ascii_lowercase
        random.seed(42)  # Ensuring reproducibility for tests
    def test_generated_string_properties(self):
        # Consolidated test for different lengths to check structure and correctness
        test_lengths = [10, 50, 100, 150, 5]
        for length in test_lengths:
            with self.subTest(length=length):
                result = task_func(length)
                self.assertTrue(len(result) <= length, "Length of result should be <= requested string length")
                self.assertEqual(sum(result.values()), length, f"Total counts should sum to {length}")
                self.assertTrue(all(char in self.valid_chars for char in result), "All characters should be valid letters")
    def test_zero_length(self):
        # Test edge case where length is zero
        result = task_func(0)
        self.assertEqual(len(result), 0, "Result should be empty for zero length")
        self.assertEqual(sum(result.values()), 0, "Sum of counts should be zero for zero length")
    def test_negative_length(self):
        # Test handling of negative length input
        with self.assertRaises(ValueError, msg="Negative length should raise an error"):
            task_func(-1)

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 generate a random string of a specified length composed of uppercase and lowercase letters, and then count the occurrence of each character in this string. The solution should return a dictionary where each key is a character from the string and the value is the count of that character.

### Approach
1. **Input Validation**: Check if the provided length is a negative number. If it is, raise a `ValueError`.
2. **String Generation**: Use the `random` module to generate a string of the specified length. Each character in the string is randomly chosen from the set of uppercase and lowercase letters using the `string.ascii_letters` constant.
3. **Character Counting**: Utilize the `collections.Counter` class to count the occurrences of each character in the generated string. This class efficiently handles the counting and returns a dictionary-like object.

### Solution Code
```python
import collections
import random
import string

def task_func(length=100):
    if length < 0:
        raise ValueError("Length cannot be negative")
    chars = string.ascii_letters
    result_str = ''.join(random.choice(chars) for _ in range(length))
    counts = collections.Counter(result_str)
    return counts
```

### Explanation
1. **Input Validation**: The function first checks if the provided `length` is negative. If it is, a `ValueError` is raised to handle this invalid input.
2. **String Generation**: The string is generated using a list comprehension that iterates `length` times, each time selecting a random character from `string.ascii_letters` (which includes all uppercase and lowercase letters).
3. **Character Counting**: The `collections.Counter` class is used to count the occurrences of each character in the generated string. This class efficiently creates a dictionary where keys are characters and values are their respective counts.

This approach ensures that the function is both efficient and easy to understand, leveraging Python's built-in modules to handle the core functionalities of string generation and character counting.

Okay, I need to solve this Python problem. Let's read the task carefully.

The function is called task_func and it's supposed to generate a random string of a given length, composed of uppercase and lowercase letters. Then, it should count the occurrence of each character and return a dictionary with those counts.

First, I should handle the parameters. The function has a default length of 100. Oh, and it raises a ValueError if the length is negative. So I need to add a check at the beginning of the function.

Next, generating the string. The string should consist of uppercase and lowercase letters. So I can use the string module's ascii_letters, which includes both. For each character in the string, I'll randomly choose one from ascii_letters.

So, I'll loop for the given length, each time appending a random choice to a list or directly building the string.

Once the string is generated, I need to count each character's occurrence. The collections module has a Counter class which is perfect for this. I'll import collections and use Counter on the string to get the counts.

Wait, the function needs to return a dictionary. Counter returns a dictionary-like object, so that's fine.

Putting it all together:

1. Check if length is negative. If so, raise ValueError.
2. Generate the string: for each of the 'length' steps, pick a random character from string.ascii_letters.
3. Use collections.Counter to count the occurrences.
4. Return the resulting dictionary.

Let me think about the example given. When length is 10, the output is a dictionary with various counts. So the function works as expected.

What about edge cases? Like length 0? Well, the function would return an empty dictionary. But according to the problem statement, the function raises ValueError only if length is negative. So length 0 is allowed, returning an empty dict.

Now, let's structure the code.

Import the necessary modules: collections, random, string. These are already imported in the given code.

In the function:

- Check if length < 0: raise ValueError.
- Generate the string: ''.join(random.choice(string.ascii_letters) for _ in range(length))
- Count using collections.Counter.
- Return the counter as a dict.

Wait, but Counter returns a subclass of dict, so returning it directly should be fine.

So the code inside the function would be:

if length < 0:
    raise ValueError("Length cannot be negative")

chars = string.ascii_letters
result_str = ''.join(random.choice(chars) for _ in range(length))
counts = collections.Counter(result_str)
return counts

Wait, but in the example, the output has uppercase and lowercase letters as keys. So the Counter correctly captures each occurrence, regardless of case.

Yes, that's correct.

So putting it all together, the function should look like this.

Testing the example: when length is 10, and with random seed 42, the output is as given. So the code should handle that.

I think that's all. Now, I'll write the code accordingly.