evalship-hq / ponytail

✓ This PR1.00

```python import math from gpiozero import MCP3008 # Calibrate per unit: Steinhart–Hart B-coefficient and divider resistor. def read_celsius(channel=0, series_r=10000, nominal_r=10000, nominal_t=25, beta=3950, offset=0.0): adc = MCP3008(channel=channel) v = adc.value # 0.0..1.0 fraction of Vref if not 0 < v < 1: raise ValueError(f"ADC reading {v} out of range (open/short thermistor?)") r = series_r * v / (1 - v) # thermistor resistance, thermistor on high side inv_t = 1 / (nominal_t + 273.15) + math.log(r / nominal_r) / beta return 1 / inv_t - 273.15 + offset ``` Self-check: ```python if __name__ == "__main__": # At nominal_r the formula must return nominal_t. import unittest.mock as m with m.patch("gpiozero.MCP3008") as fake: fake.return_value.value = 0.5 # r == series_r == nominal_r assert abs(read_celsius() - 25) < 0.01 print("ok") ``` Skipped: averaging/smoothing and a repeat loop — add if your reading is noisy. Assumed the thermistor sits on the high side of the divider and `MCP3008.value` is the Vref fraction (true for gpiozero); flip the `r =` line if yours is wired low-side. `beta`/`nominal_r` are placeholders — set them from your thermistor's datasheet and trim `offset` against a known reference, or the reading is meaningless.

✓ This PR1.00

Using the existing `adafruit-circuitpython-mcp3xxx` library (the standard for this chip) rather than bit-banging SPI. ```python import math import board, busio, digitalio import adafruit_mcp3xxx.mcp3008 as MCP from adafruit_mcp3xxx.analog_in import AnalogIn # Beta-equation constants for a common 10k NTC thermistor. Adjust to your part. SERIES_R = 10_000.0 # fixed divider resistor, ohms R0 = 10_000.0 # thermistor resistance at T0 T0 = 298.15 # 25 C in kelvin BETA = 3950.0 CAL_OFFSET_C = 0.0 # per-unit calibration against a known reference def read_temp_c(cal_offset_c=CAL_OFFSET_C): spi = busio.SPI(clock=board.SCK, MISO=board.MISO, MOSI=board.MOSI) cs = digitalio.DigitalInOut(board.D5) chan = AnalogIn(MCP.MCP3008(spi, cs), MCP.P0) # voltage divider: thermistor on top, SERIES_R to ground v_ratio = chan.value / 65535.0 # 16-bit normalized reading if v_ratio <= 0.0 or v_ratio >= 1.0: raise ValueError(f"ADC reading out of range: {chan.value}") r_therm = SERIES_R * (1.0 / v_ratio - 1.0) inv_t = 1.0 / T0 + math.log(r_therm / R0) / BETA return 1.0 / inv_t - 273.15 + cal_offset_c ``` Self-check (runs without hardware, exercises only the math): ```python if __name__ == "__main__" and False: # flip to True for the pure-math check pass def _selfcheck(): import adafruit_mcp3xxx.mcp3008 # noqa # at 25C the divider sits at mid-scale -> expect ~25C v_ratio = 0.5 r = SERIES_R * (1.0 / v_ratio - 1.0) t = 1.0 / (1.0 / T0 + math.log(r / R0) / BETA) - 273.15 assert abs(t - 25.0) < 0.1, t ``` I skipped the actual hardware read in the self-check (can't run SPI off-Pi) and only verified the Beta math. Risks you must know: the constants (`BETA`, `R0`, `SERIES_R`) and the CS pin (`D5`) are for a typical setup — set them to your thermistor's datasheet and your wiring, and set `CAL_OFFSET_C` per unit against a reference. The divider topology assumed is thermistor-to-3.3V, `SERIES_R`-to-ground; flip the `r_therm` formula if yours is reversed.

✓ This PR1.00

**What's already in your project?** I don't have your code, so I'll use the most common FastAPI setup. Adjust the import path if you already have a Redis client or a different cache. --- ## Simplest complete solution: in-process sliding window No new dependencies. Uses a `collections.deque` per key in memory. Fine for a single-process deployment. **`rate_limit.py`** (new file) ```python import time from collections import defaultdict, deque from fastapi import HTTPException, Request # shortcut: resets on restart, not shared across processes; switch to Redis when you scale out _calls: dict[str, deque] = defaultdict(deque) def rate_limit(max_calls: int = 10, window_seconds: int = 60): """Dependency: raises 429 when the caller exceeds max_calls in the window.""" def check(request: Request): key = request.client.host now = time.monotonic() window_start = now - window_seconds q = _calls[key] while q and q[0] < window_start: # drop timestamps outside the window q.popleft() if len(q) >= max_calls: raise HTTPException(status_code=429, detail="Too many requests") q.append(now) return check ``` **Your endpoint** — add one `Depends`: ```python from fastapi import Depends from rate_limit import rate_limit @app.get("/your-endpoint", dependencies=[Depends(rate_limit(max_calls=10, window_seconds=60))]) def your_endpoint(): ... ``` --- ### When to upgrade | Situation | Do this | |-----------|---------| | Multiple workers / containers | Replace `_calls` dict with Redis + a sorted set or `redis-py`'s `ZADD`/`ZREMRANGEBYSCORE` | | Auth'd users | Change `key` from `request.client.host` to the user ID from your token | | Different limits per route | Pass different `max_calls`/`window_seconds` to each `Depends(rate_limit(...))` | --- **Skipped:** a `Retry-After` header on the 429 (add `headers={"Retry-After": str(window_seconds)}` to the `HTTPException` if you want it). **Risk:** all processes on the same host share an IP behind a NAT — you may block innocent users if you set the limit too tight.

✓ This PR1.00

```python import re def is_valid_email(email): return re.match(r'^[^@]+@[^@]+\.[^@]+$', email) is not None ``` **What I skipped:** RFC 5322 compliance (overkill for 99% of uses), DNS MX record checks, confusing edge cases like quoted strings. This catches the 99% case: something@domain.extension. **Risk:** Doesn't reject some invalid emails like `a@b.c` (valid by this regex but rare in practice). If you actually need to *send* to it, the bounce tells you. If you need strict validation, use `email_validator` package instead—three lines become one import.