Qwen3 Coder Next review: not one we'd recommend right now

```python
import re
from typing import Dict, Any


def parse_ini(text: str) -> dict[str, dict[str, str]]:
    lines = text.splitlines()
    sections: dict[str, dict[str, str]] = {}
    current_section: str | None = None
    current_key: str | None = None
    current_value_parts: list[str] = []
    default_section: dict[str, str] = {}
    has_default = False
    
    i = 0
    while i < len(lines):
        line = lines[i]
        stripped_line = line.strip()
        
        # Check for empty lines and comments
        if not stripped_line or stripped_line.startswith(';') or stripped_line.startswith('#'):
            i += 1
            continue
        
        # Check for section header
        section_match = re.match(r'^\s*\[([^\]]+)\]\s*$', stripped_line)
        if section_match:
            section_name = section_match.group(1).strip()
            current_section = section_name
            if section_name == "DEFAULT":
                has_default = True
            else:
                if current_section not in sections:
                    sections[current_section] = {}
            current_key = None
            current_value_parts = []
            i += 1
            continue
        
        # Check for continuation line (starts with whitespace, following a key line)
        if current_key is not None and line and line[0].isspace():
            # Strip and append to current value
            continuation_text = stripped_line
            current_value_parts.append(continuation_text)
            i += 1
            continue
        
        # Process key-value line
        if current_section is None:
            # Key line before any section header
            raise ValueError("Key line appears before any section header")
        
        # Find first = or : to split on
        eq_pos = stripped_line.find('=')
        colon_pos = stripped_line.find(':')
        
        if eq_pos == -1 and colon_pos == -1:
            raise ValueError(f"Malformed line: '{stripped_line}'")
        
        if eq_pos == -1:
            split_pos = colon_pos
        elif colon_pos == -1:
            split_pos = eq_pos
        else:
            split_pos = min(eq_pos, colon_pos)
        
        key_part = stripped_line[:split_pos].strip()
        value_part = stripped_line[split_pos+1:].strip()
        
        if not key_part:
            raise ValueError(f"Malformed line (empty key): '{stripped_line}'")
        
        key = key_part.lower()
        
        # Process inline comments and quotes
        value_with_comment = value_part
        cleaned_value, quote_mode = _process_value(value_with_comment)
        
        current_key = key
        current_value_parts = [cleaned_value]
        
        # Save the section if it's not DEFAULT
        if current_section == "DEFAULT":
            default_section[key] = cleaned_value
        else:
            if current_section not in sections:
                sections[current_section] = {}
            sections[current_section][key] = cleaned_value
        
        i += 1
    
    # Apply DEFAULT section to all other sections
    if has_default:
        for section_name, section_dict in sections.items():
            for key, value in default_section.items():
                if key not in section_dict:
                    section_dict[key] = value
    
    # Handle interpolation (recursive resolution of ${...})
    def interpolate_value(section_name: str, value: str, visited: set) -> str:
        if not value:
            return value
        
        # Track visited references for cycle detection
        if value in visited:
            raise ValueError("Interpolation cycle detected")
        
        visited = visited | {value}
        result = value
        
        # Pattern to find ${...} references
        pattern = re.compile(r'\$\{([^}]+)\}')
        
        # Keep replacing until no more interpolations
        changed = True
        while changed:
            changed = False
            for match in pattern.finditer(result):
                ref = match.group(1)
                
                if ':' in ref:
                    # Cross-section reference: ${section:key}
                    parts = ref.split(':', 1)
                    if len(parts) != 2:
                        raise KeyError(f"Invalid interpolation reference: {ref}")
                    ref_section, ref_key = parts
                    ref_section = ref_section.strip()
                    ref_key = ref_key.strip().lower()
                    
                    # Check if the section exists
                    if ref_section not in sections:
                        raise KeyError(f"Section '{ref_section}' not found in interpolation: {ref}")
                    
                    if ref_key not in sections[ref_section]:
                        # Try DEFAULT section
                        if has_default and ref_key in default_section:
                            replacement = default_section[ref_key]
                        else:
                            raise KeyError(f"Key '{ref_key}' not found in section '{ref_section}' for interpolation: {ref}")
                    else:
                        replacement = sections[ref_section][ref_key]
                else:
                    # Same-section reference: ${key}
                    ref_key = ref.strip().lower()
                    
                    # Check in the current section first
                    if ref_key in sections.get(section_name, {}):
                        replacement = sections[section_name][ref_key]
                    elif has_default and ref_key in default_section:
                        replacement = default_section[ref_key]
                    else:
                        # If this is DEFAULT section itself, no default to inherit
                        if section_name == "DEFAULT":
                            raise KeyError(f"Key '{ref_key}' not found in DEFAULT section for interpolation: {ref}")
                        else:
                            raise KeyError(f"Key '{ref_key}' not found in section '{section_name}' or DEFAULT for interpolation: {ref}")
                
                # Interpolate the replacement if it contains references
                # Avoid recursion on the same value
                inner_visited = visited.copy()
                if replacement not in visited:
                    try:
                        replacement = interpolate_value(section_name, replacement, inner_visited)
                    except ValueError:
                        raise
                
                # Replace in result
                result = result[:match.start()] + replacement + result[match.end():]
                changed = True
                break  # Restart search after each replacement to handle overlapping
        
        return result
    
    # Apply interpolation to all values
    result_sections: dict[str, dict[str, str]] = {}
    
    for section_name, section_dict in sections.items():
        if section_name == "DEFAULT":
            continue  # Skip DEFAULT section
        
        result_sections[section_name] = {}
        visited = set()
        
        for key, value in section_dict.items():
            try:
                interpolated = interpolate_value(section_name, value, visited)
                result_sections[section_name][key] = interpolated
            except (KeyError, ValueError) as e:
                raise e
    
    return result_sections


def _process_value(value_part: str) -> tuple[str, bool]:
    """Process inline comments and quotes according to the rules."""
    if not value_part:
        return "", False
    
    # Check if the value starts with a double quote
    if value_part.startswith('"'):
        # Find the closing quote (handling escaped quotes)
        end_quote_idx = None
        in_escape = False
        for i in range(1, len(value_part)):
            ch = value_part[i]
            if in_escape:
                in_escape = False
            elif ch == '\\':
                in_escape = True
            elif ch == '"':
                end_quote_idx = i
                break
        
        if end_quote_idx is not None:
            # Extract quoted content, remove surrounding quotes
            quoted_content = value_part[1:end_quote_idx]
            # Handle potential continuation to the end of line (no comment stripping needed)
            rest = value_part[end_quote_idx + 1:].strip()
            
            # The quoted value is complete and no comments inside
            # Return the content and a flag indicating it's quoted
            return quoted_content, True
        else:
            # Malformed: unclosed quote - treat as if no quotes
            pass
    
    # Process for inline comments
    # Look for " ;" or " #" (space followed by comment character)
    comment_pos = -1
    in_quote = False
    i = 0
    while i < len(value_part):
        if not in_quote and value_part[i] == '"':
            in_quote = True
        elif in_quote and value_part[i] == '"':
            in_quote = False
        elif not in_quote and value_part[i] == ' ':
            # Look ahead for ; or #
            j = i + 1
            while j < len(value_part) and value_part[j].isspace():
                j += 1
            if j < len(value_part) and value_part[j] in (';', '#'):
                comment_pos = i
                break
        i += 1
    
    if comment_pos >= 0:
        value_part = value_part[:comment_pos]
    
    return value_part.strip(), False
```

```python
import time
from collections import OrderedDict
from typing import Any, Optional, Dict


class TTLCache:
    def __init__(self, capacity: int, ttl: float, clock):
        self.capacity = capacity
        self.ttl = ttl
        self.clock = clock
        self.cache: OrderedDict[Any, float] = OrderedDict()  # key -> (value, expiry_time)
        self._data: OrderedDict[Any, Any] = OrderedDict()   # key -> value
        self.stats_dict: Dict[str, int] = {
            "hits": 0,
            "misses": 0,
            "evictions": 0,
            "expirations": 0
        }

    def _is_expired(self, key: Any) -> bool:
        expiry_time = self.cache[key]
        return self.clock() >= expiry_time

    def _remove_expired_entries(self) -> None:
        """Remove all expired entries from the cache."""
        expired_keys = [key for key in self.cache if self._is_expired(key)]
        for key in expired_keys:
            del self.cache[key]
            del self._data[key]
            self.stats_dict["expirations"] += 1

    def _evict_lru(self) -> None:
        """Evict the least recently used entry."""
        if self._data:
            lru_key = next(iter(self._data))
            del self.cache[lru_key]
            del self._data[lru_key]
            self.stats_dict["evictions"] += 1

    def put(self, key: Any, value: Any) -> None:
        if self.capacity == 0:
            return

        # If key exists, update its value and refresh expiry time and recency
        if key in self._data:
            self._data[key] = value
            self.cache[key] = self.clock() + self.ttl
            # Move to end to mark as most recently used
            self._data.move_to_end(key)
            self.cache.move_to_end(key)
            return

        # New key insertion
        # First, remove all expired entries if cache is full
        if len(self._data) >= self.capacity:
            self._remove_expired_entries()

        # If still full after removing expired entries, evict LRU
        if len(self._data) >= self.capacity:
            self._evict_lru()

        # Insert new entry
        self._data[key] = value
        self.cache[key] = self.clock() + self.ttl

    def get(self, key: Any, default: Any = None) -> Any:
        if self.capacity == 0:
            self.stats_dict["misses"] += 1
            return default

        # If key doesn't exist, return default and count as miss
        if key not in self._data:
            self.stats_dict["misses"] += 1
            return default

        # Check if expired
        if self._is_expired(key):
            del self.cache[key]
            del self._data[key]
            self.stats_dict["expirations"] += 1
            self.stats_dict["misses"] += 1
            return default

        # Not expired: update recency and count as hit
        value = self._data[key]
        # Update expiry time and move to end (most recently used)
        self.cache[key] = self.clock() + self.ttl
        self._data.move_to_end(key)
        self.stats_dict["hits"] += 1
        return value

    def __len__(self) -> int:
        """Return number of entries that are not expired at current time."""
        now = self.clock()
        valid_entries = 0
        for key in self.cache:
            if now < self.cache[key]:
                valid_entries += 1
        return valid_entries

    def stats(self) -> Dict[str, int]:
        return dict(self.stats_dict)
```

```python
import re

def parse_duration(s: str) -> int:
    if not s or not s.strip():
        raise ValueError("Empty or blank string")
    
    s = s.strip()
    total_seconds = 0
    units_found = {'h': False, 'm': False, 's': False}
    prev_unit_order = -1  # -1 means no unit found yet
    
    # Split by whitespace to handle parts that might have spaces between them
    # But we need to be careful to preserve parts like "1h 30m" as separate tokens
    # So we'll use regex to find all matches of number + unit pairs
    pattern = r'(\d+)\s*([hmsHMS])'
    matches = re.findall(pattern, s)
    
    # Check if there are any non-matching parts (like numbers without units or invalid characters)
    # Remove all matches from original string and check if anything remains
    remaining = s
    for match in matches:
        number, unit = match
        # Remove this match (with possible whitespace around it) from remaining
        pattern_to_remove = r'\s*' + re.escape(number) + r'\s*' + re.escape(unit)
        remaining = re.sub(pattern_to_remove, '', remaining, count=1)
    
    if remaining.strip():
        raise ValueError("Invalid characters or format")
    
    # Process each match in order
    for number_str, unit in matches:
        unit_lower = unit.lower()
        
        # Check for non-negative integer (number_str should not be empty)
        if not number_str:
            raise ValueError("Number without unit")
        
        # Convert to integer (no decimals since we matched only \d+)
        value = int(number_str)
        
        # Check unit order and repetition
        unit_order = {'h': 0, 'm': 1, 's': 2}
        
        if units_found[unit_lower]:
            raise ValueError("Repeated unit")
        
        if unit_order[unit_lower] <= prev_unit_order:
            raise ValueError("Units out of order")
        
        # Update state
        units_found[unit_lower] = True
        prev_unit_order = unit_order[unit_lower]
        
        # Add to total
        if unit_lower == 'h':
            total_seconds += value * 3600
        elif unit_lower == 'm':
            total_seconds += value * 60
        elif unit_lower == 's':
            total_seconds += value
    
    # Check if any valid units were found
    if not any(units_found.values()):
        raise ValueError("No valid units found")
    
    return total_seconds
```

```python
def summarize_ranges(nums: list[int]) -> str:
    if not nums:
        return ""
    
    # Sort and remove duplicates
    sorted_nums = sorted(set(nums))
    
    if not sorted_nums:
        return ""
    
    ranges = []
    start = prev = sorted_nums[0]
    
    for num in sorted_nums[1:]:
        if num == prev + 1:
            # Continue the current range
            prev = num
        else:
            # End the current range and start a new one
            if start == prev:
                ranges.append(str(start))
            elif start == prev - 1:
                ranges.extend([str(start), str(prev)])
            else:
                ranges.append(f"{start}..{prev}")
            start = prev = num
    
    # Handle the last range
    if start == prev:
        ranges.append(str(start))
    elif start == prev - 1:
        ranges.extend([str(start), str(prev)])
    else:
        ranges.append(f"{start}..{prev}")
    
    return ",".join(ranges)
```

```python
import re
from typing import Dict, List, Tuple

def top_customers(rows: List[dict], n: int) -> List[Tuple[str, float]]:
    # Dictionary to store customer name (using first valid name) and total amount
    customer_totals: Dict[str, float] = {}
    # Dictionary to map lowercase customer name to the first valid name we've seen
    customer_name_map: Dict[str, str] = {}
    
    for row in rows:
        customer = row.get("customer", "")
        if not customer or not customer.strip():
            continue
        customer = customer.strip()
        
        # Try to parse the amount
        amount_str = row.get("amount", "")
        if not isinstance(amount_str, str):
            continue
            
        # Clean up the amount string: remove spaces
        amount_str = amount_str.strip()
        if not amount_str:
            continue
            
        try:
            # Handle negative amounts
            is_negative = False
            clean_amount = amount_str
            
            # Check for negative sign or minus prefix
            if amount_str.startswith('-'):
                is_negative = True
                clean_amount = amount_str[1:]
            elif amount_str.startswith('-$'):
                is_negative = True
                clean_amount = amount_str[2:]
            elif amount_str.startswith('$-'):
                is_negative = True
                clean_amount = amount_str[2:]
            elif amount_str.startswith('$'):
                clean_amount = amount_str[1:]
            else:
                clean_amount = amount_str
            
            # Remove commas and any remaining whitespace
            clean_amount = clean_amount.replace(',', '').strip()
            
            # Use regex to validate it's a proper number
            # Allow optional sign, digits, optional decimal part
            if not re.match(r'^-?\d+(\.\d+)?$', clean_amount) and not re.match(r'^\d+(\.\d+)?$', clean_amount):
                # Check again if there was a negative sign that we didn't process correctly
                # Try to parse with just the raw string after removing $ and commas
                raw_clean = amount_str.replace('$', '').replace(',', '').strip()
                if not re.match(r'^-?\d+(\.\d+)?$', raw_clean):
                    continue
                clean_amount = raw_clean
            
            amount = float(clean_amount)
            if is_negative:
                amount = -amount
        except (ValueError, TypeError):
            continue
        
        # Normalize customer name for matching (case-insensitive)
        customer_lower = customer.lower()
        
        # If this is the first time we see this customer (case-insensitively),
        # record their canonical name
        if customer_lower not in customer_name_map:
            customer_name_map[customer_lower] = customer
        
        # Add amount to the customer's total
        canonical_name = customer_name_map[customer_lower]
        if canonical_name not in customer_totals:
            customer_totals[canonical_name] = 0.0
        customer_totals[canonical_name] += amount
    
    # Round totals to 2 decimal places
    for name in customer_totals:
        customer_totals[name] = round(customer_totals[name], 2)
    
    # Sort by total descending, then name ascending
    sorted_customers = sorted(customer_totals.items(), key=lambda x: (-x[1], x[0]))
    
    # Return top n customers
    return sorted_customers[:n]
```

```python
import unicodedata
import re

def slugify(title: str, max_len: int = 50) -> str:
    # Step 1: Transliterate accented characters to ASCII and remove other non-ASCII characters
    # Use NFKD normalization to decompose characters, then encode to ASCII ignoring non-ASCII
    normalized = unicodedata.normalize('NFKD', title)
    ascii_str = normalized.encode('ascii', 'ignore').decode('ascii')
    
    # Step 2: Lowercase
    lower_str = ascii_str.lower()
    
    # Step 3: Replace runs of non-alphanumeric characters with single hyphen, strip leading/trailing hyphens
    slug = re.sub(r'[^a-z0-9]+', '-', lower_str).strip('-')
    
    # If max_len is 0 or negative, return empty string
    if max_len <= 0:
        return ''
    
    # Step 4: Handle length limiting
    if len(slug) <= max_len:
        return slug
    
    # Try to find longest prefix of whole words (separated by "-") within max_len
    words = slug.split('-')
    
    # If the first word is longer than max_len, hard-cut it to max_len
    if len(words[0]) > max_len:
        return words[0][:max_len]
    
    # Build prefix by adding words until we exceed max_len
    result_parts = []
    current_len = 0
    
    for i, word in enumerate(words):
        # Calculate length if we add this word (with hyphen if not the first)
        word_len = len(word)
        if i == 0:
            new_len = word_len
        else:
            new_len = current_len + 1 + word_len
        
        if new_len <= max_len:
            result_parts.append(word)
            current_len = new_len
        else:
            break
    
    return '-'.join(result_parts)
```

```python
import threading
from typing import Callable


class TokenBucket:
    def __init__(self, capacity: float, refill_per_sec: float, clock: Callable[[], float]):
        self._capacity = capacity
        self._refill_per_sec = refill_per_sec
        self._clock = clock
        self._tokens = capacity
        self._last_update_time = clock()
        self._lock = threading.Lock()

    def _refill(self) -> None:
        now = self._clock()
        elapsed = now - self._last_update_time
        if elapsed > 0:
            self._tokens = min(self._capacity, self._tokens + elapsed * self._refill_per_sec)
            self._last_update_time = now

    def allow(self, cost: float = 1) -> bool:
        with self._lock:
            self._refill()
            if self._tokens >= cost:
                self._tokens -= cost
                return True
            return False

    @property
    def tokens(self) -> float:
        with self._lock:
            self._refill()
            return self._tokens
```

{
  "outcome": {
    "full_refund": 0.0,
    "partial_refund": 1.0,
    "store_credit": 0.0,
    "nothing": 0.0
  },
  "defective": {
    "true": 0.0,
    "false": 1.0
  }
}

{
  "severity": {"0": 0.0, "1": 0.9, "2": 0.1, "3": 0.0},
  "page": {"true": 0.9, "false": 0.1}
}

{
  "tool": {"calendar": 0.95, "none": 0.03, "email": 0.01, "calculator": 0.005, "web_search": 0.005},
  "confirm": {"true": 0.85, "false": 0.15}
}

{
  "phishing": {
    "true": 0.05,
    "false": 0.95
  },
  "action_needed": {
    "true": 0.98,
    "false": 0.02
  }
}

{
  "slot": {"A": 0.95, "B": 0.0, "C": 0.05, "D": 0.0},
  "raj_last": {"true": 0.0, "false": 1.0}
}

{
  "hardware": {
    "true": 0.95,
    "false": 0.05
  },
  "support": {
    "true": 0.98,
    "false": 0.02
  }
}

{
  "department": {"billing": 0.05, "technical": 0.90, "account": 0.02, "shipping": 0.01, "sales": 0.02},
  "urgency": {"0": 0.0, "1": 0.0, "2": 0.05, "3": 0.95},
  "outage": {"true": 0.98, "false": 0.02}
}

{
  "department": {"billing": 0.95, "technical": 0.02, "account": 0.01, "shipping": 0.01, "sales": 0.01},
  "refund": {"true": 0.99, "false": 0.01},
  "tone": {"calm": 0.90, "frustrated": 0.10}
}

{"policy": {"harassment": 0.95, "none": 0.05, "hate": 0.0, "spam": 0.0, "self_harm": 0.0}, "personal_info": {"true": 1.0, "false": 0.0}}

{
  "tool": {"calendar": 0.95, "email": 0.05, "none": 0.0, "web_search": 0.0, "calculator": 0.0},
  "confirm": {"true": 1.0, "false": 0.0}
}

{
  "doc_type": {"invoice": 1.0, "resume": 0.0, "contract": 0.0, "bank_statement": 0.0, "other": 0.0},
  "missing_due_date": {"true": 1.0, "false": 0.0}
}

{"phishing": {"true": 0.999, "false": 0.001}, "risk": {"0": 0.0005, "1": 0.001, "2": 0.01, "3": 0.9885}}

{
  "data_kind": {"none": 0.0, "contact": 0.0, "financial": 0.0, "government_id": 1.0, "health": 0.0},
  "sensitive": {"true": 1.0, "false": 0.0}
}

{"sentiment": {"positive": 0.0, "neutral": 0.0, "negative": 1.0}, "defect": {"true": 1.0, "false": 0.0}, "recommend": {"true": 0.0, "false": 1.0}}

{
  "year2_price_per_seat_month": 47.25,
  "year3_price_per_seat_month": 49.95,
  "year1_invoice": 48600.0,
  "year2_invoice": 51459.0,
  "addon_months_billed": 6,
  "addon_invoice": 52725.75,
  "year3_invoice": 38665.5,
  "year3_discount_percent": 15.0,
  "total_contract_value": 182250.25,
  "contract_end_date": "2027-02-28"
}

{
  "employee_id": "EMP-20417",
  "destination_city": "Lisbon",
  "trip_start": "2025-02-24",
  "trip_end": "2025-02-27",
  "approved_items": [
    {
      "date": "2025-02-24",
      "category": "airfare",
      "amount_usd": 1184.6
    },
    {
      "date": "2025-02-24",
      "category": "ground_transport",
      "amount_usd": 38.88
    },
    {
      "date": "2025-02-25",
      "category": "meals",
      "amount_usd": 229.39
    },
    {
      "date": "2025-02-26",
      "category": "lodging",
      "amount_usd": 466.56
    },
    {
      "date": "2025-02-27",
      "category": "ground_transport",
      "amount_usd": 44.82
    }
  ],
  "rejected_item_count": 2,
  "per_diem_days": 3,
  "per_diem_usd": 195.0,
  "total_reimbursable_usd": 1155.25,
  "approver_email": "priya.raman@corvane.com"
}

{
  "tenants": ["Marcus Lin", "Sofia Lin"],
  "landlord": "Ridgeline Property Group LLC",
  "zip": "97205",
  "lease_end": "2025-11-30",
  "original_monthly_rent": 2150.0,
  "monthly_rent_from_2025_06_01": 2236.0,
  "late_fee_from_2025_06_01": 111.8,
  "security_deposit": 2150.0,
  "total_pet_deposits": 800.0,
  "total_monthly_payment_july_2025": 2306.0,
  "move_in_payment": 4700.0
}

{
  "ticket_id": "48213",
  "account_id": "ACC-7731",
  "open_issue": "inventory_sync",
  "resolved_issues": ["billing_address", "invoice_pdf"],
  "affected_orders": ["SO-99812", "SO-99820", "SO-99827"],
  "priority": "P1",
  "sla_due_local": "2025-09-12T23:30",
  "sla_due_utc": "2025-09-13T04:30:00Z",
  "reissued_invoice": "INV-2025-0812"
}

{
  "q3_total_usd": 15346,
  "q2_total_usd": 14464,
  "q2_central_originally_reported_usd": 3047,
  "q2_to_q3_change_pct": 6.1,
  "top_region_q3": "East",
  "fastest_growing_region_q1_to_q3": "International",
  "regions_declining_q2_to_q3": ["East"],
  "international_q3_organic_usd": 1731,
  "west_excluding_mountain_q3_usd": 4201
}