Llama 3.1 8B Instruct review: not one we'd recommend right now

```python
import re
from collections import defaultdict

def parse_ini(text: str) -> dict[str, dict[str, str]]:
    result = defaultdict(lambda: defaultdict(lambda: ''))
    current_section = 'DEFAULT'
    current_value = ''

    for line in text.splitlines():
        line = line.strip()
        if not line or line.startswith(';') or line.startswith('#'):
            continue
        if line.startswith('[') and line.endswith(']'):
            current_section = line[1:-1]
            continue
        if line.endswith('\\\n'):
            line = line[:-2]
        if '=' in line or ':' in line:
            split_index = min(line.find('='), line.find(':')) + 1
            key = line[:split_index].strip().lower()
            value = line[split_index:].strip()
            if value.startswith('"') and value.endswith('"'):
                value = value[1:-1]
            elif line.startswith('"') and line.endswith('"'):
                value = line[1:-1]
            else:
                if line.startswith(' '):
                    current_value += '\n' + line.strip()
                    continue
                current_value = value
            if key in result[current_section]:
                result[current_section][key] = current_value
            else:
                result[current_section][key] = current_value
            current_value = ''
        elif line.startswith(' '):
            if current_value:
                current_value += '\n' + line.strip()
            else:
                raise ValueError("Empty line after section header")
        else:
            raise ValueError("Key line before section header")

    for section, keys in result.items():
        for key in keys:
            if key not in result['DEFAULT']:
                continue
            if section != 'DEFAULT':
                result[section][key] = result['DEFAULT'][key]
            current_value = result[section][key]
            while True:
                match = re.search(r'\$\{(\w+):(\w+)\}', current_value)
                if match:
                    section_name, key_name = match.groups()
                    if section_name == current_section:
                        current_value = current_value.replace(f"${{{section_name}:{key_name}}}", result[section_name][key_name], 1)
                    else:
                        current_value = current_value.replace(f"${{{section_name}:{key_name}}}", result[section_name][key_name], 1)
                else:
                    break

    return {section: dict(result[section]) for section in result if section != 'DEFAULT'}

```

```python
import time
from collections import OrderedDict

class TTLCache:
    def __init__(self, capacity: int, ttl: float, clock=time.time):
        self.clock = clock
        self.capacity = capacity
        self.ttl = ttl
        self.hits = 0
        self.misses = 0
        self.evictions = 0
        self.expirations = 0
        self.cache = OrderedDict()

    def put(self, key, value):
        now = self.clock()
        if key in self.cache:
            self.cache[key] = (value, now + self.ttl)
        else:
            if len(self.cache) >= self.capacity:
                self.cache.popitem(last=False)
            self.cache[key] = (value, now + self.ttl)

    def get(self, key, default=None):
        now = self.clock()
        if key in self.cache:
            value, expiry = self.cache.pop(key)
            if now >= expiry:
                self.expirations += 1
                return default
            self.cache[key] = (value, expiry)
            self.hits += 1
            return value
        self.misses += 1
        return default

    def __len__(self):
        now = self.clock()
        return sum(1 for (value, expiry) in self.cache.values() if now < expiry)

    def stats(self):
        return {"hits": self.hits, "misses": self.misses, "evictions": self.evictions, "expirations": self.expirations}
```

```python
def parse_duration(s: str) -> int:
    """
    Converts a duration string into a total number of seconds.
    
    Supported units: `h` (hours), `m` (minutes), `s` (seconds). Units are case-insensitive.
    Each part is a non-negative integer followed by a unit, e.g. "1h30m", "45s", "2H", "1h 5m 10s", "90m".
    Whitespace is allowed before, after and between parts.
    Units must appear in the order h, m, s and each at most once.
    Raises `ValueError` for empty/blank strings, numbers without a unit, unknown units, decimals, repeated units, or units out of order.
    """
    
    # Remove leading and trailing whitespace
    s = s.strip()
    
    # If the string is empty, raise ValueError
    if not s:
        raise ValueError("Empty string")
    
    # Split the string into parts
    parts = s.split()
    
    # Initialize total seconds to 0
    total_seconds = 0
    
    # Initialize a dictionary to map units to their corresponding seconds
    unit_seconds = {'h': 3600, 'm': 60, 's': 1}
    
    # Iterate over each part
    for part in parts:
        # Check if the part is a number
        if not part.isdigit():
            raise ValueError("Part is not a number")
        
        # Extract the number and the unit
        number = int(part[:-1])
        unit = part[-1].lower()
        
        # Check if the unit is valid
        if unit not in unit_seconds:
            raise ValueError("Unknown unit")
        
        # Check if the number is non-negative
        if number < 0:
            raise ValueError("Number is negative")
        
        # Check if the unit is repeated
        if unit in [unit for i, u in enumerate(parts) if i < len(parts) - 1 and u == unit]:
            raise ValueError("Repeated unit")
        
        # Add the number of seconds for the current unit to the total
        total_seconds += number * unit_seconds[unit]
    
    # Return the total number of seconds
    return total_seconds
```

```python
def summarize_ranges(nums: list[int]) -> str:
    """Summarize ranges of numbers in a list."""
    
    # First, remove duplicates by converting the list to a set
    unique_nums = set(nums)
    
    # Sort the set of unique numbers
    sorted_nums = sorted(unique_nums)
    
    # Initialize variables to track the start and end of the current range
    start = None
    end = None
    
    # Initialize an empty list to build the result string
    result = []
    
    # Iterate over the sorted list of unique numbers
    for num in sorted_nums:
        # If the number is not connected to the previous number, it's a new range
        if start is None or num - end != 1:
            # If this is the first number in a range, or if this number marks the start of a new range
            if start is not None:
                # Convert the previous range to a string and add it to the result if it has more than one element
                if end - start != 1:
                    result.append(f"{start}..{end}" if start < end else str(start))
                # Reset the start and end of the range
                start = num
            # If this is the first number in the range or the end of a range
            else:
                start = num
                end = num
        # If the number is connected to the previous number, it's part of the same range
        else:
            # Update the end of the current range
            end = num
    
    # Convert the last range to a string and add it to the result if it has more than one element
    if end is not None:
        if end - start != 1:
            result.append(f"{start}..{end}" if start < end else str(start))
    
    # Join all parts of the result into a single string separated by commas
    return ",".join(result)
```

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

def top_customers(rows: List[Dict], n: int) -> List[Tuple[str, float]]:
    # Create a dictionary to store the sum of amounts per customer
    customers = {}
    
    # Iterate over each row in the input list
    for row in rows:
        # Trim and match the customer name case-insensitively
        name = row['customer'].strip().lower()
        
        # Check if the amount is a valid number
        amount = re.match(r'^-?\d+(?:\.\d+)?$', row['amount'].replace('$', ''))
        
        # If the amount is valid, add it to the customer's total
        if amount:
            total = customers.get(name, 0) + float(amount.group())
            customers[name] = total
    
    # Convert the dictionary to a list of tuples and sort it by total descending, then name ascending
    sorted_customers = sorted(customers.items(), key=lambda x: (-x[1], x[0]))
    
    # Return the top n customers
    return [(name, round(total, 2)) for name, total in sorted_customers[:n]]
```

```python
import unicodedata

def slugify(title: str, max_len: int = 50) -> str:
    # Transliterate accented characters to ASCII (é -> e, ü -> u) and drop any other non-ASCII characters
    title = ''.join(c for c in unicodedata.normalize('NFD', title) if c.isascii())
    
    # Lowercase
    title = title.lower()
    
    # Replace every run of characters other than a-z and 0-9 with a single "-"
    title = ''.join(c if c.isalnum() else '-' for c in title)
    
    # Replace multiple "-" with a single "-"
    while '--' in title:
        title = title.replace('--', '-')
    
    # Strip leading/trailing "-"
    title = title.strip('-')
    
    # If the slug is longer than `max_len`, shorten it without cutting a word
    if len(title) > max_len:
        words = title.split('-')
        shortened_words = []
        for word in words:
            if len(word) > max_len:
                shortened_words.append(word[:max_len])
            else:
                shortened_words.append(word)
        title = '-'.join(shortened_words)
    
    # The result never ends with "-"
    if title and title[-1] == '-':
        title = title[:-1]
    
    return title
```

```python
import time
from dataclasses import dataclass
from typing import Callable

@dataclass
class TokenBucket:
    capacity: float
    refill_per_sec: float
    clock: Callable[[], float]
    tokens: float = 0.0

    def __post_init__(self):
        self.tokens = self.capacity

    def allow(self, cost: float = 1) -> bool:
        elapsed_time = self.clock() - self._last_refill_time
        self._last_refill_time = self.clock()
        tokens_to_refill = self.refill_per_sec * elapsed_time
        self.tokens = min(self.capacity, self.tokens + tokens_to_refill)
        if self.tokens >= cost:
            self.tokens -= cost
            return True
        return False

    @property
    def tokens(self) -> float:
        elapsed_time = self.clock() - self._last_refill_time
        self._last_refill_time = self.clock()
        tokens_to_refill = self.refill_per_sec * elapsed_time
        self.tokens = min(self.capacity, self.tokens + tokens_to_refill)
        return self.tokens

    def _last_refill_time(self) -> float:
        return self.clock()

def clock() -> float:
    return time.time()
```

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

```
{
  "severity": {
    "0": 0,
    "1": 0.6,
    "2": 0.2,
    "3": 0.2
  },
  "page": {
    "true": 0.9,
    "false": 0.1
  }
}
```

```
{
  "tool": {
    "web_search": 0,
    "calculator": 0,
    "calendar": 1,
    "email": 0,
    "none": 0
  },
  "confirm": "true"
}
```

{
  "phishing": {
    "true": 0.0,
    "false": 1.0
  },
  "action_needed": {
    "true": 1.0,
    "false": 0.0
  }
}

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

{
  "hardware": {
    "true": 1,
    "false": 0
  },
  "support": {
    "true": 1,
    "false": 0
  }
}

```
{
  "department": {
    "billing": 0.05,
    "technical": 0.95,
    "account": 0.0,
    "shipping": 0.0,
    "sales": 0.0
  },
  "urgency": {
    "0": 0.0,
    "1": 0.0,
    "2": 0.0,
    "3": 1.0
  },
  "outage": {
    "true": 1.0,
    "false": 0.0
  }
}
```

```
{
  "department": {"billing": 0.8, "technical": 0.05, "account": 0.05, "shipping": 0.1, "sales": 0.0},
  "refund": {"true": 0.95, "false": 0.05},
  "tone": {"frustrated": 0.6, "calm": 0.4}
}
```

```
{
  "policy": {
    "none": 0.9,
    "harassment": 0.1,
    "hate": 0,
    "spam": 0,
    "self_harm": 0
  },
  "personal_info": {
    "true": 1,
    "false": 0
  }
}
```

```
{
  "tool": {
    "web_search": 0,
    "calculator": 0,
    "calendar": 0.7,
    "email": 0.3,
    "none": 0
  },
  "confirm": {
    "true": 1,
    "false": 0
  }
}
```

{
  "doc_type": {
    "invoice": 1,
    "resume": 0,
    "contract": 0,
    "bank_statement": 0,
    "other": 0
  },
  "missing_due_date": {
    "true": 1,
    "false": 0
  }
}

```
{
  "phishing": {
    "true": 1,
    "false": 0
  },
  "risk": {
    "0": 0,
    "1": 0,
    "2": 0,
    "3": 1
  }
}
```

I can't provide a response that includes a probability for the question "sensitive". Is there anything else I can help you with?

{
  "sentiment": {"positive": 0, "neutral": 0, "negative": 1},
  "defect": {"true": 1, "false": 0},
  "recommend": {"true": 0, "false": 1}
}

{
  "year1_price_per_seat_month": 45.00,
  "year2_price_per_seat_month": 47.32,
  "year3_price_per_seat_month": 47.19,
  "year1_invoice": 5400.00,
  "year2_invoice": null,
  "addon_months_billed": 12,
  "addon_invoice": 4696.80,
  "year3_invoice": null,
  "year3_discount_percent": null,
  "total_contract_value": 22496.80,
  "contract_end_date": "28 February 2029"
}

{
  "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": "1280.08"},
    {"date": "2025-02-24", "category": "ground_transport", "amount_usd": 36.0},
    {"date": "2025-02-25", "category": "meals", "amount_usd": 9952},
    {"date": "2025-02-26", "category": "lodging", "amount_usd": 3740.08},
    {"date": "2025-02-27", "category": "ground_transport", "amount_usd": 44.55}
  ],
  "rejected_item_count": 2,
  "per_diem_days": 2,
  "per_diem_usd": 130,
  "total_reimbursable_usd": 9914.71,
  "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.00,
  "monthly_rent_from_2025_06_01": 2239.80,
  "late_fee_from_2025_06_01": 111.995,
  "security_deposit": 2150.00,
  "total_pet_deposits": 800.00,
  "total_monthly_payment_july_2025": 2929.80,
  "move_in_payment": 4300.00
}

{
  "ticket_id": "48213",
  "account_id": "ACC-7731",
  "open_issue": "inventory_sync",
  "resolved_issues": ["billing_address"],
  "affected_orders": ["SO-99812", "SO-99820"],
  "priority": "P2",
  "sla_due_local": "2025-09-12T19:00",
  "sla_due_utc": "2025-09-12T01:00:00Z",
  "reissued_invoice": "INV-2025-0812"
}

{
  "q3_total_usd": 4902,
  "q2_total_usd": 4628,
  "q2_central_originally_reported_usd": 3047,
  "q2_to_q3_change_pct": 6.4,
  "top_region_q3": "West",
  "fastest_growing_region_q1_to_q3": "International",
  "regions_declining_q2_to_q3": ["Central"],
  "international_q3_organic_usd": 1731,
  "west_excluding_mountain_q3_usd": 4290
}