# Parse Extract Input

> For text processing: extract numbers, words, structured data from messy text using regex patterns, parsing utilities.

- Skill: `jimmc414/parse-extract-input` (Agent Skill)
- Install (CLI): `npx skillmds@latest add jimmc414/parse-extract-input`
- Raw SKILL.md: https://api.skillmd.com/api/skills/jimmc414/parse-extract-input/raw
- Safety review: pending
- Works with: Claude Code, Claude.ai, OpenAI Codex
- Category: Coding & Dev Tools
- Author: jimmc414 (https://skillmd.com/u/jimmc414)
- Updated: 2026-09-17
- Page: https://skillmd.com/skills/jimmc414/parse-extract-input

---


# parse-extract-input

## When to Use
- Extracting numbers from text
- Finding words or identifiers
- Parsing structured input files
- Data cleaning
- Advent of Code input parsing

## When NOT to Use
- Structured format (use JSON/CSV parsers)
- Complex grammar (use proper parser)
- Simple split is enough

## The Pattern

Use regex or helper functions to extract structured data from text.

```python
import re

def ints(text):
    """Extract all integers from text."""
    return tuple(map(int, re.findall(r'-?[0-9]+', text)))

def words(text):
    """Extract all words from text."""
    return tuple(re.findall(r'[a-zA-Z]+', text))

def atoms(text):
    """Extract all atoms (numbers or identifiers)."""
    return tuple(atom(s) for s in re.findall(r'[+-]?\d+\.?\d*|\w+', text))

def atom(s):
    """Parse string as number or keep as string."""
    try:
        return int(s)
    except ValueError:
        try:
            return float(s)
        except ValueError:
            return s
```

## Example (from pytudes AdventUtils.ipynb)

```python
import re

def ints(text: str) -> Tuple[int, ...]:
    """A tuple of all the integers in text."""
    return tuple(map(int, re.findall(r'-?[0-9]+', text)))

def positive_ints(text: str) -> Tuple[int, ...]:
    """A tuple of all positive integers in text."""
    return tuple(map(int, re.findall(r'[0-9]+', text)))

def digits(text: str) -> Tuple[int, ...]:
    """A tuple of all single digits in text."""
    return tuple(map(int, re.findall(r'[0-9]', text)))

def words(text: str) -> Tuple[str, ...]:
    """A tuple of all alphabetic words in text."""
    return tuple(re.findall(r'[a-zA-Z]+', text))

def atoms(text: str) -> Tuple:
    """A tuple of all atoms (numbers or identifiers)."""
    return tuple(map(atom, re.findall(r'[+-]?\d+\.?\d*|\w+', text)))

def atom(text: str):
    """Parse text into a single float or int or str."""
    try:
        x = float(text)
        return round(x) if x.is_integer() else x
    except ValueError:
        return text.strip()

# Usage examples
ints("Robot at (3, -5) with speed 10")  # (3, -5, 10)
words("Hello, World! 123")  # ('Hello', 'World')
atoms("x=42, y=3.14, name=foo")  # ('x', 42, 'y', 3.14, 'name', 'foo')
```

## Key Principles
1. **Regex for patterns**: `r'-?[0-9]+'` for signed integers
2. **Return tuples**: Immutable, hashable results
3. **Cascading conversion**: Try int, then float, then string
4. **Negative-aware**: Include `-?` for negative numbers
5. **Reusable utilities**: Same functions for any input