py-02-csv-groupby

# CSV Group Sum

Implement a file **`solution.py`** containing a function:

```python
def group_sum(csv_text: str, key_col: str, val_col: str) -> dict[str, float]:
    ...
```

Parse `csv_text` as CSV and return a dictionary mapping each distinct value in
column `key_col` to the **sum** of column `val_col` for all rows with that key.

Rules:

- The **first non-blank line** is the header row naming the columns.
- Columns are comma-separated. `key_col` and `val_col` name two of those columns.
- Values in `val_col` are numeric (int or float); sum them as floats.
- **Ignore blank lines** anywhere in the input (including trailing newlines).
- If the input has only a header (or is empty), return an empty dict `{}`.
- You may assume `key_col` and `val_col` exist in the header.

Example:

```python
csv_text = "name,amount\\nalice,10\\nbob,5\\nalice,2.5\\n"
group_sum(csv_text, "name", "amount") == {"alice": 12.5, "bob": 5.0}
```

from solution import group_sum


def test_basic_sum():
    csv_text = "name,amount\nalice,10\nbob,5\nalice,2.5\n"
    assert group_sum(csv_text, "name", "amount") == {"alice": 12.5, "bob": 5.0}


def test_returns_floats():
    csv_text = "k,v\na,1\na,2\n"
    out = group_sum(csv_text, "k", "v")
    assert out == {"a": 3.0}
    assert all(isinstance(v, float) for v in out.values())


def test_ignores_blank_lines():
    csv_text = "\n\nname,amount\nalice,1\n\nbob,2\n\n\n"
    assert group_sum(csv_text, "name", "amount") == {"alice": 1.0, "bob": 2.0}


def test_header_only():
    assert group_sum("name,amount\n", "name", "amount") == {}


def test_empty_input():
    assert group_sum("", "name", "amount") == {}
    assert group_sum("\n\n", "name", "amount") == {}


def test_column_order_independent():
    csv_text = "amount,name\n10,x\n5,y\n3,x\n"
    assert group_sum(csv_text, "name", "amount") == {"x": 13.0, "y": 5.0}


def test_three_columns_picks_right_ones():
    csv_text = "region,product,sales\neast,a,100\nwest,b,50\neast,c,25\n"
    assert group_sum(csv_text, "region", "sales") == {"east": 125.0, "west": 50.0}


def test_negative_and_float_values():
    csv_text = "g,n\nx,-1.5\nx,0.5\ny,4\n"
    assert group_sum(csv_text, "g", "n") == {"x": -1.0, "y": 4.0}

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 csv
from collections import defaultdict

def group_sum(csv_text: str, key_col: str, val_col: str) -> dict[str, float]:
    lines = [line for line in csv_text.splitlines() if line.strip()]
    if not lines:
        return {}
        
    reader = csv.reader(lines)
    header = next(reader)
    
    key_idx = header.index(key_col)
    val_idx = header.index(val_col)
    
    sums = defaultdict(float)
    for row in reader:
        sums[row[key_idx]] += float(row[val_idx])
        
    return dict(sums)
```

The user wants a Python function `group_sum` that takes a CSV string, a key column name, and a value column name, and returns a dictionary mapping each unique key to the sum of the corresponding values.

Let's break down the requirements:
1. Parse `csv_text` as CSV.
2. First non-blank line is the header.
3. Columns are comma-separated.
4. `key_col` and `val_col` are column names.
5. Values in `val_col` are numeric, sum as floats.
6. Ignore blank lines anywhere.
7. If only header or empty, return `{}`.
8. Assume `key_col` and `val_col` exist in the header.

I should use Python's built-in `csv` module for robust parsing, but since it's a simple comma-separated format, I could also just split lines. However, `csv` module handles edge cases better (like quoted fields, though not explicitly required, it's safer). But the problem says "Columns are comma-separated", so simple splitting might suffice. I'll stick to `csv` module for correctness, or just manual parsing if it's simpler. Actually, `csv` module is standard and handles blank lines gracefully if we filter them out.

Wait, the `csv` module's `reader` doesn't automatically skip blank lines. I'll filter out blank lines first.

Let's design the function:
```python
import csv
import io

def group_sum(csv_text: str, key_col: str, val_col: str) -> dict[str, float]:
    lines = [line for line in csv_text.splitlines() if line.strip()]
    if not lines:
        return {}
    
    reader = csv.reader(io.StringIO('\n'.join(lines)))
    header = next(reader)
    
    key_idx = header.index(key_col)
    val_idx = header.index(val_col)
    
    sums = {}
    for row in reader:
        if not row: # Should be filtered out, but just in case
            continue
        key = row[key_idx]
        val = float(row[val_idx])
        sums[key] = sums.get(key, 0.0) + val
        
    return sums
```

Wait, `csv.reader` might treat empty lines differently. Filtering lines beforehand is safer.
Also, `csv_text.splitlines()` handles `\n`, `\r\n`, etc.
`line.strip()` removes whitespace. If a line is just spaces, it's blank.

Let's test mentally with the example:
`csv_text = "name,amount\nalice,10\nbob,5\nalice,2.5\n"`
`lines` -> `["name,amount", "alice,10", "bob,5", "alice,2.5"]`
`header` -> `["name", "amount"]`
`key_idx` -> 0, `val_idx` -> 1
Loop:
`row` -> `["alice", "10"]` -> `sums["alice"] = 10.0`
`row` -> `["bob", "5"]` -> `sums["bob"] = 5.0`
`row` -> `["alice", "2.5"]` -> `sums["alice"] = 12.5`
Returns `{"alice": 12.5, "bob": 5.0}`. Matches example.

What about blank lines in the middle?
`csv_text = "name,amount\n\nalice,10\n"`
`lines` -> `["name,amount", "alice,10"]` -> works.

What if `csv_text` has only header?
`lines` -> `["name,amount"]`
`header` -> `["name", "amount"]`
Loop over `reader` yields nothing. Returns `{}`. Works.

What if `csv_text` is empty?
`lines` -> `[]`
Returns `{}`. Works.

One detail: `csv.reader` might be overkill if we just split by comma, but it's safer. However, sometimes CSV values can contain commas if quoted. The problem says "Columns are comma-separated", doesn't mention quotes. I'll stick with `csv` module as it's standard.

Wait, `io.StringIO('\n'.join(lines))` creates a new string. That's fine.
Alternatively, I can just use `csv.reader(lines)` directly since `csv.reader` accepts any iterable of strings.
`reader = csv.reader(lines)` works perfectly.

Let's refine:
```python
import csv

def group_sum(csv_text: str, key_col: str, val_col: str) -> dict[str, float]:
    lines = [line for line in csv_text.splitlines() if line.strip()]
    if not lines:
        return {}
        
    reader = csv.reader(lines)
    header = next(reader)
    
    key_idx = header.index(key_col)
    val_idx = header.index(val_col)
    
    sums = {}
    for row in reader:
        if not row:
            continue
        key = row[key_idx]
        val = float(row[val_idx])
        sums[key] = sums.get(key, 0.0) + val
        
    return sums
```

Wait, `csv.reader` might yield rows with empty strings if there are trailing commas, but that's fine.
Is there any case where `row` could be empty after filtering? `csv.reader` on a non-empty line won't yield an empty list unless the line is empty, which we filtered. So `if not row: continue` is safe but maybe unnecessary. I'll keep it or remove it. It's fine.

One thing: `csv_text.splitlines()` might keep `\r` if not handled? `splitlines()` handles all line boundaries. `line.strip()` removes whitespace including `\r`. So it's fine.

What about performance? It's fine for typical use.
Could use `collections.defaultdict(float)` for cleaner code.

```python
import csv
from collections import defaultdict

def group_sum(csv_text: str, key_col: str, val_col: str) -> dict[str, float]:
    lines = [line for line in csv_text.splitlines() if line.strip()]
    if not lines:
        return {}
        
    reader = csv.reader(lines)
    header = next(reader)
    
    key_idx = header.index(key_col)
    val_idx = header.index(val_col)
    
    sums = defaultdict(float)
    for row in reader:
        sums[row[key_idx]] += float(row[val_idx])
        
    return dict(sums)
```

This is clean and Pythonic.

Let's double check constraints:
- "The first non-blank line is the header row naming the columns." -> handled.
- "Columns are comma-separated." -> handled by csv.reader.
- "Values in val_col are numeric (int or float); sum them as floats." -> handled.
- "Ignore blank lines anywhere in the input" -> handled.
- "If the input has only a header (or is empty), return an empty dict {}." -> handled.
- "You may assume key_col and val_col exist in the header." -> handled.

One minor point: `csv.reader` might treat lines with only whitespace as blank? We already filtered them.
What if a line has spaces around values? `csv.reader` preserves them. `float(" 10 ")` works in Python. So it's fine.
What if `key_col` has spaces? `header.index(key_col)` will match exactly. The problem says `key_col` names the column, so exact match is expected.

Is there any edge case with `csv` module and `splitlines`?
If `csv_text` contains `\r\n`, `splitlines()` splits correctly.
If `csv_text` ha
…[8270 chars elided]…
and val_col exist in the header." It doesn't explicitly guarantee row lengths, but typically in such problems, rows are well-formed. I'll assume well-formed.

All good.
Output matches.
Proceeds. 
Generating response. 
[Done] 
Output matches the requested format.
```python
import csv
from collections import defaultdict

def group_sum(csv_text: str, key_col: str, val_col: str) -> dict[str, float]:
    lines = [line for line in csv_text.splitlines() if line.strip()]
    if not lines:
        return {}
        
    reader = csv.reader(lines)
    header = next(reader)
    
    key_idx = header.index(key_col)
    val_idx = header.index(val_col)
    
    sums = defaultdict(float)
    for row in reader:
        sums[row[key_idx]] += float(row[val_idx])
        
    return dict(sums)
```
This is correct. I will present it. 
One minor thing: `csv` module is standard, so no extra dependencies. `defaultdict` is also standard.
The solution is complete. 
I'll output it now. 
(Self-Correction/Verification during generation prep)
Wait, `csv.reader` might treat empty lines differently if not filtered. I filtered them.
What about `line.strip()` removing significant whitespace? It's only used for filtering. The original `line` is kept in the list. So it's fine.
All good.
Output matches.
Proceeds. 
[Final Check]
The prompt asks for `solution.py` containing the function.
I will provide exactly that.
Code block format.
Done. 
Output Generation. 
```python
import csv
from collections import defaultdict

def group_sum(csv_text: str, key_col: str, val_col: str) -> dict[str, float]:
    lines = [line for line in csv_text.splitlines() if line.strip()]
    if not lines:
        return {}
        
    reader = csv.reader(lines)
    header = next(reader)
    
    key_idx = header.index(key_col)
    val_idx = header.index(val_col)
    
    sums = defaultdict(float)
    for row in reader:
        sums[row[key_idx]] += float(row[val_idx])
        
    return dict(sums)
```
Matches requirements perfectly.
Done. 
[Output Generation] -> *Proceeds*