Slop Is Moving Up the Stack

342
def fetch_source(url):
343
    try:
344
        req = urllib.request.Request(url, headers={'User-Agent': 'mvault/1.0'})
345
        with urllib.request.urlopen(req, timeout=30) as resp:
346
            raw = resp.read()
347
        return json.loads(raw.decode('utf-8')), None
348
    except Exception as e:
349
        return None, f"mvault: source metadata fetch failed: {e}"

407
        body = response.read()
408
except urllib.error.HTTPError as exc:
409
    raise MvaultError("failed to fetch source metadata from %s: HTTP %s %s"
410
                      % (url, exc.code, exc.reason))
411
except urllib.error.URLError as exc:
412
    raise MvaultError("failed to fetch source metadata from %s: %s" % (url, exc.reason))
413
except (OSError, ValueError, http.client.HTTPException) as exc:
414
    raise MvaultError("failed to fetch source metadata from %s: %s" % (url, exc))
415
try:
416
    payload = json.loads(body)
417
except (ValueError, UnicodeDecodeError) as exc:
418
    raise MvaultError("failed to fetch source metadata from %s: invalid JSON (%s)"
419
                      % (url, exc))
420
try:

424
rows = list(reader)
425
if len(rows) < 2:
426
    return None, "Non-tabular content"
427

428
header = rows[0]
429
if not header or len(header) == 0:
430
    return None, "Non-tabular content"
431

432
columns = header
433
data_rows = []
434
for row in rows[1:]:
435
    if len(row) > len(columns):
436
        return None, "Non-tabular content"
437
    if len(row) < len(columns):

278
leading = text.lstrip()
279
if not leading or leading.lower().startswith(("<!doctype html", "<html", "<?xml")):
280
    raise InputError("source is not tabular CSV content")
281
if leading.startswith(("{", "[")):
282
    try:
283
        json.loads(leading)
284
    except json.JSONDecodeError:
285
        lines = [line for line in leading.splitlines() if line.strip()]
286
        try:
287
            is_json_lines = len(lines) > 1 and all(
288
                isinstance(json.loads(line), (dict, list)) for line in lines
289
            )
290
        except json.JSONDecodeError:
291
            is_json_lines = False

288
def load_rules(rules_file_path):
289
    """Load rules from a YAML file. Returns dict or empty dict on failure."""
290
    if not rules_file_path or not os.path.exists(rules_file_path):
291
        return {}
292
    try:
293
        with open(rules_file_path, "r") as f:
294
            data = yaml.safe_load(f)
295
        if not isinstance(data, dict):
296
            return {}
297
        return data
298
    except Exception:
299
        return {}

627
def load_rules(rules_path):
628
    with open(rules_path, "r", encoding="utf-8") as f:
629
        rules = json.load(f)
630
    return rules

38
def load_rules(path):
39
    try:
40
        with open(path, "r", encoding="utf-8") as f:
41
            data = json.load(f)
42
    except (OSError, ValueError) as e:
43
        raise RuleError("cannot read rules file: %s" % e)
44
    if not isinstance(data, list):
45
        raise RuleError("rules file must contain a JSON array")
46
    rules = []
47
    seen = set()
48
    for idx, r in enumerate(data):
49
        if not isinstance(r, dict):
50
            raise RuleError("rule #%d is not an object" % idx)
51
        rid = r.get("id")

1572
    connection.commit()
1573
except MigrationError as exc:
1574
    if str(exc) == "no migrations to rollback" or re.fullmatch(r"version \d+ not found", str(exc)):
1575
        raise
1576
    raise rollback_error(exc) from exc
1577
except (sqlite3.Error, OSError, ValueError, OverflowError, TypeError, KeyError, IndexError, RecursionError) as exc:
1578
    raise rollback_error(exc) from exc

63
def invalid(message, **details):
64
    return ApiError(400, "invalid_input", message, details)
65

66

67
def unprocessable(message, **details):
68
    return ApiError(422, "unprocessable", message, details)
69

70

71
def not_found(message, **details):
72
    return ApiError(404, "not_found", message, details)
73

74

75
def conflict(message, **details):
76
    return ApiError(409, "conflict", message, details)

196
def normalize_steps(steps, columns, steps_path, execute=False, checkpoint2=False, defs=None):
197
    if not isinstance(steps, list):
198
        fail("steps must be an array", steps_path)
199
    validate_expression = execution_expression if execute or checkpoint2 else expression

117
def load_config(args):
118
    """Compatibility helper for callers loading a Part 1 config."""
119
    configs, _ = load_configs(args)
120
    return next(iter(configs.values()))

312
def validate_expression(expression: str, path: str) -> None:
313
    parse_expression(expression, path)

35
try:
36
    tree = parse_expression(expression, path)
37
except PipelineError:
38
    pass
39
else:
40
    for field in expression_fields(tree):
41
        check_column(field, path, columns)
42
    return
43
try:
44
    tree = ast.parse(expression, mode="eval")
45
except (SyntaxError, ValueError, TypeError) as error:
46
    raise PipelineError("BAD_EXPR", path, "invalid expression") from error
47

48
binary_operators = (ast.Add, ast.Sub, ast.Mult, ast.Div)

323
if a.id in sde.stations:
324
    lines.append('UNDOCK')
325
lines.append('GO: ' + ' -> '.join(
326
    f'{sde.systems[sid].name} ({sde.systems[sid].security:.1f})' for sid in route))

494
if start.id in sde.stations:
495
    print('UNDOCK')
496
if len(route) > 1:
497
    print('GO: ' + ' -> '.join(f'{sde.systems[sid].name} ({sde.systems[sid].security:.1f})' for sid in route))

880
def leg_lines(sde: SDE, leg: Leg, destination: Place) -> List[str]:
881
    lines: List[str] = []
882
    if leg.undock:
883
        lines.append("UNDOCK")
884
    if len(leg.systems) > 1:
885
        hops = " -> ".join(
886
            f"{sde.systems[s].name} ({format_security(sde.systems[s].security)})"
887
            for s in leg.systems
888
        )
889
        lines.append(f"GO: {hops}")
890
    if leg.dock:
891
        lines.append(f"DOCK: {destination.name}")

1086
class Tok(object):
1087
    __slots__ = ('typ', 'val', 'pos')
1088

1089
    def __init__(self, typ, val, pos):
1090
        self.typ = typ
1091
        self.val = val
1092
        self.pos = pos
1093

1094
    def __str__(self):
1095
        if self.typ == 'eof':
1096
            return 'EOF'
1097
        if self.typ in _KEYWORDS:
1098
            return '<%s>' % self.val
1099
        if len(self.val) > 10:

110
class CliError(Exception):
111
    """A fatal, user-facing error with the stream and exit code to use."""
112

113
    def __init__(self, lines, stream="stderr", code=1, sensitive=False):
114
        Exception.__init__(self, "\n".join(lines))
115
        self.lines = list(lines)
116
        self.stream = stream
117
        self.code = code
118
        self.sensitive = sensitive

87
from __future__ import annotations

97
from typing import Any, Dict, List, Optional, Tuple, Union

132
try:
133
    return bool(a == b)
134
except Exception:  # pragma: no cover - exotic types
135
    return str(a) == str(b)

545
def _matching_row_groups(f: FileInfo, arrow_filter) -> list[int] | None:
546
    """Row groups whose statistics may satisfy ``arrow_filter`` (None = all)."""
547
    if arrow_filter is None:
548
        return None
549
    try:
550
        if f.fs is not None:
551
            dset = pds.dataset(f.path, format="parquet", filesystem=f.fs)
552
        else:
553
            dset = pds.dataset(f.path, format="parquet")
554
        frag = next(iter(dset.get_fragments()))
555
        return [rg.id for rg in frag.subset(filter=arrow_filter).row_groups]
556
    except Exception:  # statistics unusable (e.g. type mismatch) -> read everything
557
        return None

65
def path_exists(path) -> bool:
66
    try:
67
        fs = fs_for(str(path))
68
        return fs.exists(str(path))
69
    except Exception:  # pragma: no cover
70
        return False

41
def enqueue(kind, value):
42
    nonlocal sequence
43
    sequence += 1
44
    # Urgent successor outranks all regular same-time work.
45
    priority = 0 if kind == 'successor' and s['successor_priority'] == 'urgent' else 1
46
    heapq.heappush(pending, (priority, sequence, kind, value))

164
def schedule(
165
    self,
166
    event: Event,
167
    priority: EventPriority = NORMAL,
168
    delay: SimTime = 0,
169
) -> None:
170
    """Schedule an *event* with a given *priority* and a *delay*."""
171
    heappush(self._queue, (self._now + delay, priority, next(self._eid), event))

137
def find_declared_encoding(data):
138
    window = data[:2048]
139
    m = re.search(
140
        rb"<\?xml(?:\s|\?)[^>]*\bencoding\s*=\s*[\"']([^\"']+)[\"']",
141
        window,
142
        re.I,
143
    )
144
    if m:
145
        return m.group(1).decode("ascii", "replace").strip()
146
    for mt in re.finditer(rb"<meta\b[^>]*>", window, re.I):
147
        tag = mt.group(0)
148
        m = re.search(rb"charset\s*=\s*[\"']?\s*([^\"'\s;>]+)", tag, re.I)
149
        if m:
150
            return m.group(1).decode("ascii", "replace").strip()

692
@classmethod
693
def find_declared_encoding(
694
    cls,
695
    markup: Union[bytes, str],
696
    is_html: bool = False,
697
    search_entire_document: bool = False,
698
) -> Optional[_Encoding]:
699
    """Given a document, tries to find an encoding declared within the
700
    text of the document itself.

290
// `npr`'s iterators walk a strided view in logical order, which is
291
// the scatter-add that `+=` on views cannot express for axes of
292
// length one.

228
if <$t>::MUT && strides[$i].iter().any(|&s| s == 0) {
229
    return Err(crate::error::NprError::Shape(
230
        crate::error::ShapeError::Invalid(
231
            "a mutable producer cannot be broadcast with repeated elements".into(),
232
        ),
233
    ));
234
}