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
def group_sum(csv_text: str, key_col: str, val_col: str) -> dict[str, float]:
    lines = csv_text.split('\n')
    
    # Filter out blank lines
    non_blank_lines = [line for line in lines if line.strip()]
    
    if len(non_blank_lines) < 1:
        return {}
    
    # Parse header
    header = non_blank_lines[0].split(',')
    
    # Find column indices
    try:
        key_idx = header.index(key_col)
        val_idx = header.index(val_col)
    except ValueError:
        return {}
    
    # Group sums
    result = {}
    
    # Process data rows (skip header)
    for line in non_blank_lines[1:]:
        values = line.split(',')
        if len(values) > max(key_idx, val_idx):
            key_value = values[key_idx]
            val_value = float(values[val_idx])
            if key_value in result:
                result[key_value] += val_value
            else:
                result[key_value] = val_value
    
    return result
```

Let me break down the requirements:

1. Parse CSV text where the first non-blank line is the header
2. Find the column indices for `key_col` and `val_col`
3. For each row (excluding header and blank lines), sum the values in `val_col` grouped by `key_col`
4. Return a dictionary mapping key values to sum of values (as floats)
5. Ignore blank lines
6. If only header or empty, return empty dict

Let me write the solution:

```python
def group_sum(csv_text: str, key_col: str, val_col: str) -> dict[str, float]:
    lines = csv_text.split('\n')
    
    # Filter out blank lines and find the first non-blank line (header)
    non_blank_lines = [line for line in lines if line.strip()]
    
    if len(non_blank_lines) < 1:
        return {}
    
    # Parse header
    header = non_blank_lines[0].split(',')
    
    # Find column indices
    try:
        key_idx = header.index(key_col)
        val_idx = header.index(val_col)
    except ValueError:
        # Columns don't exist, but problem says we can assume they exist
        return {}
    
    # Group sums
    result = {}
    
    # Process data rows (skip header)
    for line in non_blank_lines[1:]:
        values = line.split(',')
        if len(values) > max(key_idx, val_idx):
            key_value = values[key_idx]
            val_value = float(values[val_idx])
            if key_value in result:
                result[key_value] += val_value
            else:
                result[key_value] = val_value
    
    return result
```

Wait, I need to be careful about:
1. Blank lines should be ignored anywhere in the input
2. The first non-blank line is the header


3. Values should be summed as floats

I should also consider edge cases like empty strings in the CSV, multiple commas, and ensuring the sum is always a float. Let me refine the solution to handle these cases properly.

```python
def group_sum(csv_text: str, key_col: str, val_col: str) -> dict[str, float]:
    lines = csv_text.split('\n')
    
    # Filter out blank lines
    non_blank_lines = [line for line in lines if line.strip()]
    
    if len(non_blank_lines) < 1:
        return {}
    
    # Parse header
    header = non_blank_lines[0].split(',')
    
    # Find column indices
    try:
        key_idx = header.index(key_col)
        val_idx = header.index(val_col)
    except ValueError:
        return {}
    
    # Group sums
    result = {}
    
    # Process data rows (skip header)
    for line in non_blank_lines[1:]:
        values = line.split(',')
        if len(values) > max(key_idx, val_idx):
            key_value = values[key_idx]
            val_value = float(values[val_idx])
            if key_value in result:
                result[key_value] += val_value
            else:
                result[key_value] = val_value
    
    return result
```

I'm checking that the line has enough columns before accessing them, and converting the value to float for the sum. The key value stays as a string in the dictionary.

Actually, I should verify the column count more carefully. If a line has fewer columns than needed, I should skip it rather than crash. Let me make sure I'm handling that edge case properly.

```python
def group_sum(csv_text: str, key_col: str, val_col: str) -> dict[str, float]:
    lines = csv_text.split('\n')
    
    # Filter out blank lines
    non_blank_lines = [line for line in lines if line.strip()]
    
    if len(non_blank_lines) < 1:
        return {}
    
    # Parse header
    header = non_blank_lines[0].split(',')
    
    # Find column indices
    try:
        key_idx = header.index(key_col)
        val_idx = header.index(val_col)
    except ValueError:
        return {}
    
    # Group sums
    result = {}
    
    # Process data rows (skip header)
    for line in non_blank_lines[1:]:
        values = line.split(',')
        if len(values) > max(key_idx, val_idx):
            key_value = values[key_idx]
            val_value = float(values[val_idx])
            if key_value in result:
                result[key_value] += val_value
            else:
                result[key_value] = val_value
    
    return result
```

This looks good. The condition `len(values) > max(key_idx, val_idx)` ensures we have enough columns to access both the key and value indices.

Wait, I need to reconsider the blank line handling. The problem says to ignore blank lines anywhere, including trailing newlines. My current approach filters them out, which is correct.

Let me trace through the example:
- Input: "name,amount\nalice,10\nbob,5\nalice,2.5\n"
- After split: ["name,amount", "alice,10", "bob,5", "alice,2.5", ""]
- After filtering blank: ["name,amount", "alice,10", "bob,5", "alice,2.5"]
- Header: ["name", "amount"]
- key_idx = 0, val_idx = 1
- Process rows:
  - "alice,10" -> key="alice", val=10.0 -> result={"alice": 10.0}
  - "bob,5" -> key="bob", val=5.0 -> result={"alice": 10.0, "bob": 5.0}
  - "alice,2.5" -> key="alice", val=2.5 -> result={"alice": 12.5, "bob": 5.0}

This matches the expected output!

I should also consider edge cases like empty strings in the CSV. If a value is an empty string, `float('')` will raise a ValueError. However, the problem states that values in `val_col` are numeric, so I can assume they're valid.

Let me finalize the solution:

```python
def group_sum(csv_text: str, key_col: str, val_col: str) -> dict[str, float]:
    lines = csv_text.split('\n')
    
    # Filter out blank lines
    non_blank_lines = [line for line in lines if line.strip()]
    
    if len(non_blank_lines) < 1:
        return {}
    
    # Parse header
    header = non_blank_lines[0].split(',')
    
    # Find column indices
    try:
        key_idx = header.index(key_col)
        val_idx = header.index(val_col)
    except ValueError:
        return {}
    
    # Group sums
    result = {}
    
    # Process data rows (skip header)
    for line in non_blank_lines[1:]:
        values = line.split(',')
        if len(values) > max(key_idx, val_idx):
            key_value = values[key_idx]
            val_value = float(values[val_idx])
            if key_value in result:
                result[key_value] += val_value
            else:
                result[key_value] = val_value
    
    return result
```

This handles all the requirements correctly.