enginehall 2.0.0__py3-none-any.whl

pcba/components.py

@@ -0,0 +1,323 @@
+"""Component requirements: what a part needs from the circuit around it.
+
+Data, not code. The shipped file `pcba/data/components/generic.json` holds generic, invented
+entries (a 3.3 V MCU, an LDO, a 5 V logic gate, an I2C sensor) so the rules have something to
+check against; a project adds its own files through `[components] databases` in
+`pcba-requirements.toml`. The schema is `schemas/components.schema.json`:
+
+    {
+      "schema_version": 1,
+      "parts": [
+        {
+          "id": "generic-ldo-3v3",
+          "kind": "ic",                       # ic | capacitor | resistor | other
+          "description": "...",
+          "match": {"mpn": [...], "value": [...], "lib_id": ["regex", ...]},
+          "supplies": [{"pins": ["VIN"], "operating": [2.5, 16.0], "absolute": [-0.3, 18.0]}],
+          "grounds": ["GND"],
+          "inputs":  [{"pins": ["EN"], "vil_max": 0.4, "vih_min": 1.2, "max": 18.0}],
+          "outputs": [{"pins": ["VOUT"], "voh_min": 3.2, "vol_max": 0.1, "kind": "push_pull"}],
+          "required": [{"pin": "EN", "requires": "not_floating"},
+                       {"pin": "VOUT", "requires": "capacitor_to_ground", "value": "1u"}]
+        }
+      ]
+    }
+
+Pin names are regular expressions matched against the whole pin name. Voltages are volts;
+input and output levels hold at the part's nominal supply. `requires` is one of
+`capacitor_to_ground`, `not_floating`, `pull_up`, `pull_down`, `connected`. A part is matched
+by `[components] assign` first, then by its MPN property, its value, and its library id.
+A part with no entry is reported as "not checked: no component data", never as passing.
+"""
+
+from __future__ import annotations
+
+import dataclasses
+import json
+import re
+from importlib import resources
+from pathlib import Path
+
+from pcba.model.design import Component
+
+SCHEMA_VERSION = 1
+REQUIRES = ("capacitor_to_ground", "not_floating", "pull_up", "pull_down", "connected")
+MPN_FIELDS = ("MPN", "Manufacturer Part Number", "Manufacturer_Part_Number", "MPN#", "PartNumber", "Part Number")
+
+
+class ComponentDataError(ValueError):
+    """A component database file is malformed."""
+
+
+@dataclasses.dataclass(frozen=True, slots=True)
+class Supply:
+    pins: tuple[str, ...]
+    operating: tuple[float, float]
+    absolute: tuple[float, float] | None
+
+
+@dataclasses.dataclass(frozen=True, slots=True)
+class Level:
+    pins: tuple[str, ...]
+    low: float | None          # vil_max for an input, vol_max for an output
+    high: float | None         # vih_min for an input, voh_min for an output
+    limit: float | None = None  # an input's absolute maximum voltage
+    kind: str = "push_pull"     # outputs: push_pull | open_drain
+
+
+@dataclasses.dataclass(frozen=True, slots=True)
+class Required:
+    pin: str
+    requires: str
+    value: str | None = None
+
+
+@dataclasses.dataclass(frozen=True, slots=True)
+class Part:
+    id: str
+    kind: str
+    description: str
+    source: str
+    mpn: tuple[str, ...] = ()
+    values: tuple[str, ...] = ()
+    lib_ids: tuple[str, ...] = ()
+    supplies: tuple[Supply, ...] = ()
+    grounds: tuple[str, ...] = ()
+    inputs: tuple[Level, ...] = ()
+    outputs: tuple[Level, ...] = ()
+    required: tuple[Required, ...] = ()
+
+
+def pin_matches(patterns: tuple[str, ...] | str, name: str) -> bool:
+    if isinstance(patterns, str):
+        patterns = (patterns,)
+    return any(re.fullmatch(p, name or "") for p in patterns)
+
+
+def _strings(value, where: str) -> tuple[str, ...]:
+    if value is None:
+        return ()
+    if isinstance(value, str):
+        value = [value]
+    if not isinstance(value, list) or any(not isinstance(v, str) or not v for v in value):
+        raise ComponentDataError(f"{where} must be a list of strings")
+    for pattern in value:
+        try:
+            re.compile(pattern)
+        except re.error as exc:
+            raise ComponentDataError(f"{where}: invalid pattern {pattern!r}: {exc}") from exc
+    return tuple(value)
+
+
+def _pair(value, where: str) -> tuple[float, float]:
+    if (not isinstance(value, list) or len(value) != 2
+            or any(isinstance(v, bool) or not isinstance(v, (int, float)) for v in value) or value[0] > value[1]):
+        raise ComponentDataError(f"{where} must be [low, high]")
+    return float(value[0]), float(value[1])
+
+
+def _optional(table: dict, key: str, where: str) -> float | None:
+    value = table.get(key)
+    if value is None:
+        return None
+    if isinstance(value, bool) or not isinstance(value, (int, float)):
+        raise ComponentDataError(f"{where}.{key} must be a number")
+    return float(value)
+
+
+def _keys(table: dict, allowed: set[str], where: str) -> None:
+    extra = sorted(set(table) - allowed)
+    if extra:
+        raise ComponentDataError(f"unknown fields in {where}: {', '.join(extra)}")
+
+
+def parse(payload: dict, source: str) -> list[Part]:
+    if not isinstance(payload, dict) or payload.get("schema_version") != SCHEMA_VERSION:
+        raise ComponentDataError(f"{source}: schema_version must be {SCHEMA_VERSION}")
+    _keys(payload, {"schema_version", "description", "parts"}, source)
+    parts = payload.get("parts")
+    if not isinstance(parts, list):
+        raise ComponentDataError(f"{source}: parts must be a list")
+    out = []
+    for index, raw in enumerate(parts):
+        where = f"{source} parts[{index}]"
+        if not isinstance(raw, dict):
+            raise ComponentDataError(f"{where} must be an object")
+        _keys(raw, {"id", "kind", "description", "match", "supplies", "grounds", "inputs", "outputs", "required"},
+              where)
+        if not isinstance(raw.get("id"), str) or not raw["id"]:
+            raise ComponentDataError(f"{where}.id is required")
+        kind = raw.get("kind", "ic")
+        if kind not in ("ic", "capacitor", "resistor", "other"):
+            raise ComponentDataError(f"{where}.kind must be ic, capacitor, resistor or other")
+        match = raw.get("match", {})
+        if not isinstance(match, dict):
+            raise ComponentDataError(f"{where}.match must be an object")
+        _keys(match, {"mpn", "value", "lib_id"}, f"{where}.match")
+        supplies = []
+        for i, s in enumerate(raw.get("supplies", [])):
+            w = f"{where}.supplies[{i}]"
+            _keys(s, {"pins", "operating", "absolute"}, w)
+            supplies.append(Supply(_strings(s.get("pins"), f"{w}.pins"), _pair(s.get("operating"), f"{w}.operating"),
+                                   _pair(s["absolute"], f"{w}.absolute") if "absolute" in s else None))
+        inputs = []
+        for i, s in enumerate(raw.get("inputs", [])):
+            w = f"{where}.inputs[{i}]"
+            _keys(s, {"pins", "vil_max", "vih_min", "max"}, w)
+            inputs.append(Level(_strings(s.get("pins"), f"{w}.pins"), _optional(s, "vil_max", w),
+                                _optional(s, "vih_min", w), _optional(s, "max", w)))
+        outputs = []
+        for i, s in enumerate(raw.get("outputs", [])):
+            w = f"{where}.outputs[{i}]"
+            _keys(s, {"pins", "vol_max", "voh_min", "kind"}, w)
+            kind_out = s.get("kind", "push_pull")
+            if kind_out not in ("push_pull", "open_drain"):
+                raise ComponentDataError(f"{w}.kind must be push_pull or open_drain")
+            outputs.append(Level(_strings(s.get("pins"), f"{w}.pins"), _optional(s, "vol_max", w),
+                                 _optional(s, "voh_min", w), kind=kind_out))
+        required = []
+        for i, s in enumerate(raw.get("required", [])):
+            w = f"{where}.required[{i}]"
+            _keys(s, {"pin", "requires", "value"}, w)
+            if s.get("requires") not in REQUIRES:
+                raise ComponentDataError(f"{w}.requires must be one of {', '.join(REQUIRES)}")
+            _strings(s.get("pin"), f"{w}.pin")
+            required.append(Required(s["pin"], s["requires"], s.get("value")))
+        out.append(Part(
+            id=raw["id"], kind=kind, description=str(raw.get("description", "")), source=source,
+            mpn=_strings(match.get("mpn"), f"{where}.match.mpn"),
+            values=_strings(match.get("value"), f"{where}.match.value"),
+            lib_ids=_strings(match.get("lib_id"), f"{where}.match.lib_id"),
+            supplies=tuple(supplies), grounds=_strings(raw.get("grounds"), f"{where}.grounds"),
+            inputs=tuple(inputs), outputs=tuple(outputs), required=tuple(required),
+        ))
+    return out
+
+
+@dataclasses.dataclass(slots=True)
+class Library:
+    parts: list[Part] = dataclasses.field(default_factory=list)
+    sources: list[str] = dataclasses.field(default_factory=list)
+    assign: dict[str, str] = dataclasses.field(default_factory=dict)
+
+    def by_id(self, part_id: str) -> Part | None:
+        # A project file loaded after the shipped one overrides an entry with the same id.
+        return next((p for p in reversed(self.parts) if p.id == part_id), None)
+
+    def match(self, component: Component) -> tuple[Part, str] | None:
+        """(part, how it matched) for a placed component, or None."""
+        assigned = self.assign.get(component.ref)
+        if assigned:
+            part = self.by_id(assigned)
+            return (part, f"assigned to {assigned} in the requirements file") if part else None
+        mpn = next((component.properties[f] for f in MPN_FIELDS if component.properties.get(f)), None)
+        for part in reversed(self.parts):
+            if mpn and any(mpn.upper() == m.upper() for m in part.mpn):
+                return part, f"MPN {mpn}"
+        for part in reversed(self.parts):
+            if component.value and any(component.value.upper() == v.upper() for v in part.values):
+                return part, f"value {component.value}"
+        for part in reversed(self.parts):
+            if any(re.fullmatch(p, component.lib_id) for p in part.lib_ids):
+                return part, f"library symbol {component.lib_id}"
+        return None
+
+
+def builtin_files() -> list[tuple[str, str]]:
+    """(name, text) of the shipped component files."""
+    folder = resources.files("pcba") / "data" / "components"
+    return sorted((item.name, item.read_text(encoding="utf-8")) for item in folder.iterdir()
+                  if item.name.endswith(".json"))
+
+
+def load(extra: tuple[Path, ...] = (), assign: dict[str, str] | None = None) -> Library:
+    library = Library(assign=dict(assign or {}))
+    for name, text in builtin_files():
+        library.parts += parse(json.loads(text), f"pcba/data/components/{name}")
+        library.sources.append(f"pcba/data/components/{name}")
+    for path in extra:
+        try:
+            payload = json.loads(Path(path).read_text(encoding="utf-8"))
+        except (OSError, ValueError) as exc:
+            raise ComponentDataError(f"cannot read component data {path}: {exc}") from exc
+        library.parts += parse(payload, str(path))
+        library.sources.append(str(path))
+    unknown = sorted(ref for ref, part_id in library.assign.items() if library.by_id(part_id) is None)
+    if unknown:
+        raise ComponentDataError("components.assign names unknown ids for " + ", ".join(unknown))
+    return library
+
+
+# --- values ------------------------------------------------------------------------------------
+
+_SI = {"p": 1e-12, "n": 1e-9, "u": 1e-6, "µ": 1e-6, "μ": 1e-6, "m": 1e-3, "k": 1e3, "K": 1e3, "M": 1e6,
+       "G": 1e9, "R": 1.0, "r": 1.0, "": 1.0}
+_VALUE = re.compile(r"^\s*(\d+(?:[.,]\d+)?)\s*([pnuµμmkKMGRr]?)(\d*)\s*(?:F|Ω|ohm|Ohm|H)?\b", re.U)
+
+
+def parse_value(text: str | None) -> float | None:
+    """`100n` -> 1e-7, `4k7` -> 4700, `0R1` -> 0.1, `2.2uF` -> 2.2e-6, `10k 1%` -> 10000."""
+    if not text:
+        return None
+    match = _VALUE.match(text.replace(",", "."))
+    if not match:
+        return None
+    whole, prefix, decimals = match.groups()
+    number = float(f"{whole}.{decimals}") if decimals and "." not in whole else float(whole)
+    return number * _SI[prefix]
+
+
+_RATING = re.compile(r"(?<![\w.])(\d+(?:[.,]\d+)?)\s*V(?:DC)?\b", re.I)
+_POWER = re.compile(r"(?<![\w.])(?:(\d+)/(\d+)|(\d+(?:[.,]\d+)?)\s*(m?))\s*W\b")
+VOLTAGE_FIELDS = ("Voltage", "Rated Voltage", "Voltage Rating", "VoltageRating", "Rating", "V")
+POWER_FIELDS = ("Power", "Power Rating", "PowerRating", "Rated Power")
+DIELECTRIC_FIELDS = ("Dielectric", "Type", "Technology", "Material")
+
+
+def rated_voltage(component: Component) -> tuple[float, str] | None:
+    """(rating in volts, where it was read) from a voltage field or the value text."""
+    for field in VOLTAGE_FIELDS:
+        text = component.properties.get(field)
+        if text:
+            match = _RATING.search(text) or re.fullmatch(r"\s*(\d+(?:[.,]\d+)?)\s*", text)
+            if match:
+                return float(match.group(1).replace(",", ".")), f"{field} = {text!r}"
+    match = _RATING.search(component.value or "")
+    if match:
+        return float(match.group(1).replace(",", ".")), f"value {component.value!r}"
+    return None
+
+
+def rated_power(component: Component) -> tuple[float, str] | None:
+    for field in POWER_FIELDS:
+        text = component.properties.get(field)
+        if text:
+            match = _POWER.search(text)
+            if match:
+                return _watts(match), f"{field} = {text!r}"
+    match = _POWER.search(component.value or "")
+    if match:
+        return _watts(match), f"value {component.value!r}"
+    return None
+
+
+def _watts(match: re.Match) -> float:
+    if match.group(1):
+        return float(match.group(1)) / float(match.group(2))
+    value = float(match.group(3).replace(",", "."))
+    return value / 1000 if match.group(4) else value
+
+
+def capacitor_class(component: Component) -> str:
+    """ceramic | electrolytic | tantalum | film | polymer, from fields, value and symbol."""
+    text = " ".join([component.value, component.lib_id, component.footprint]
+                    + [component.properties.get(f, "") for f in DIELECTRIC_FIELDS]).upper()
+    if "TANT" in text:
+        return "tantalum"
+    if "POLYMER" in text:
+        return "polymer"
+    if re.search(r"ELEC|C_POLARIZED|CP_ELEC|\bCP\b|:CP\b|CPOL|ALU", text):
+        return "electrolytic"
+    if re.search(r"\bFILM\b|MKP|MKT|X2|Y2", text):
+        return "film"
+    return "ceramic"

pcba/config.py

@@ -0,0 +1,180 @@
+"""Optional project configuration for repositories with more than one review target."""
+
+from __future__ import annotations
+
+import dataclasses
+import tomllib
+from pathlib import Path
+from typing import Any
+
+CONFIG_NAME = "pcba-studio.toml"
+
+
+class ProjectConfigError(ValueError):
+    """The optional project configuration is malformed or ambiguous."""
+
+
+@dataclasses.dataclass(frozen=True, slots=True)
+class Target:
+    name: str
+    part: str | None = None
+    schematic_component: str | None = None
+    ioc: str | None = None
+    schematic_dir: str | None = None
+    firmware_roots: tuple[str, ...] | None = None
+    kicad_project: str | None = None
+
+
+@dataclasses.dataclass(frozen=True, slots=True)
+class ProjectConfig:
+    path: Path
+    default_target: str | None
+    targets: dict[str, Target]
+
+
+@dataclasses.dataclass(frozen=True, slots=True)
+class SelectedTarget:
+    name: str
+    part: str | None
+    schematic_component: str | None
+    ioc: Path | None
+    schematic_dir: Path | None
+    firmware_roots: tuple[Path, ...] | None
+    kicad_project: Path | None = None
+
+
+def _optional_string(table: dict[str, Any], key: str, target: str) -> str | None:
+    value = table.get(key)
+    if value is None:
+        return None
+    if not isinstance(value, str) or not value.strip():
+        raise ProjectConfigError(f"targets.{target}.{key} must be a non-empty string")
+    return value
+
+
+def load(root: Path | str) -> ProjectConfig | None:
+    path = Path(root).resolve() / CONFIG_NAME
+    if not path.exists():
+        return None
+    try:
+        payload = tomllib.loads(path.read_text(encoding="utf-8"))
+    except OSError as exc:
+        raise ProjectConfigError(f"cannot read {path}: {exc}") from exc
+    except UnicodeDecodeError as exc:
+        raise ProjectConfigError(f"{path} is not UTF-8: {exc}") from exc
+    except tomllib.TOMLDecodeError as exc:
+        raise ProjectConfigError(f"invalid TOML in {path}: {exc}") from exc
+
+    unknown = sorted(set(payload) - {"version", "default_target", "targets"})
+    if unknown:
+        raise ProjectConfigError(f"unknown project config fields: {', '.join(unknown)}")
+    if payload.get("version") != 1:
+        raise ProjectConfigError("pcba-studio.toml version must be 1")
+    default = payload.get("default_target")
+    if default is not None and (not isinstance(default, str) or not default.strip()):
+        raise ProjectConfigError("default_target must be a non-empty string")
+    raw_targets = payload.get("targets")
+    if not isinstance(raw_targets, dict) or not raw_targets:
+        raise ProjectConfigError("pcba-studio.toml must define at least one [targets.NAME]")
+
+    targets: dict[str, Target] = {}
+    allowed = {"part", "ioc", "schematic_dir", "firmware_roots", "schematic_component", "kicad_project"}
+    for name, raw in raw_targets.items():
+        if not isinstance(name, str) or not name.strip() or not isinstance(raw, dict):
+            raise ProjectConfigError("every target must be a named TOML table")
+        unknown = sorted(set(raw) - allowed)
+        if unknown:
+            raise ProjectConfigError(f"unknown fields in target {name}: {', '.join(unknown)}")
+        roots = raw.get("firmware_roots")
+        if roots is not None and (
+            not isinstance(roots, list)
+            or any(not isinstance(value, str) or not value.strip() for value in roots)
+        ):
+            raise ProjectConfigError(f"targets.{name}.firmware_roots must be a string array")
+        targets[name] = Target(
+            name=name,
+            part=_optional_string(raw, "part", name),
+            schematic_component=_optional_string(raw, "schematic_component", name),
+            ioc=_optional_string(raw, "ioc", name),
+            schematic_dir=_optional_string(raw, "schematic_dir", name),
+            firmware_roots=tuple(roots) if roots is not None else None,
+            kicad_project=_optional_string(raw, "kicad_project", name),
+        )
+    if default is not None and default not in targets:
+        raise ProjectConfigError(f"default_target {default!r} is not defined")
+    return ProjectConfig(path=path, default_target=default, targets=targets)
+
+
+def _resolve(root: Path, value: str, label: str) -> Path:
+    candidate = (root / value).resolve()
+    try:
+        candidate.relative_to(root)
+    except ValueError as exc:
+        raise ProjectConfigError(f"{label} must stay inside the project: {value}") from exc
+    return candidate
+
+
+def select(root: Path | str, name: str | None = None) -> SelectedTarget | None:
+    project_root = Path(root).resolve()
+    config = load(project_root)
+    if config is None:
+        if name:
+            raise ProjectConfigError(f"--target requires {CONFIG_NAME} in {project_root}")
+        return None
+
+    selected_name = name or config.default_target
+    if selected_name is None:
+        if len(config.targets) == 1:
+            selected_name = next(iter(config.targets))
+        else:
+            available = ", ".join(sorted(config.targets))
+            raise ProjectConfigError(
+                f"several targets are configured ({available}); pass --target or set default_target"
+            )
+    try:
+        target = config.targets[selected_name]
+    except KeyError as exc:
+        available = ", ".join(sorted(config.targets))
+        raise ProjectConfigError(
+            f"unknown target {selected_name!r}; available targets: {available}"
+        ) from exc
+
+    ioc = _resolve(project_root, target.ioc, f"targets.{selected_name}.ioc") if target.ioc else None
+    schematic = (
+        _resolve(project_root, target.schematic_dir, f"targets.{selected_name}.schematic_dir")
+        if target.schematic_dir
+        else None
+    )
+    firmware = (
+        tuple(
+            _resolve(project_root, value, f"targets.{selected_name}.firmware_roots")
+            for value in target.firmware_roots
+        )
+        if target.firmware_roots is not None
+        else None
+    )
+    kicad_project = (
+        _resolve(project_root, target.kicad_project, f"targets.{selected_name}.kicad_project")
+        if target.kicad_project
+        else None
+    )
+    if kicad_project and not kicad_project.exists():
+        raise ProjectConfigError(f"configured KiCad project does not exist: {kicad_project}")
+    if ioc and not ioc.is_file():
+        raise ProjectConfigError(f"configured .ioc does not exist: {ioc}")
+    if schematic and not schematic.is_dir():
+        raise ProjectConfigError(f"configured schematic directory does not exist: {schematic}")
+    for firmware_root in firmware or ():
+        if not firmware_root.is_dir() or not (firmware_root / "Core" / "Src").is_dir():
+            raise ProjectConfigError(
+                f"configured firmware root has no Core/Src directory: {firmware_root}"
+            )
+    return SelectedTarget(
+        name=selected_name,
+        part=target.part,
+        schematic_component=target.schematic_component,
+        ioc=ioc,
+        schematic_dir=schematic,
+        firmware_roots=firmware,
+        kicad_project=kicad_project,
+    )

pcba/data/components/generic.json

@@ -0,0 +1,61 @@
+{
+  "schema_version": 1,
+  "description": "Generic, invented component requirements shipped with EngineHall. They stand for typical parts, not for any manufacturer's product: use them as examples and assign them explicitly ([components] assign in pcba-requirements.toml). Add real parts in a project file with the same schema.",
+  "parts": [
+    {
+      "id": "generic-mcu-3v3",
+      "kind": "ic",
+      "description": "Generic 3.3 V microcontroller: 1.7 to 3.6 V supply, CMOS I/O, reset pin needing a 100 nF capacitor.",
+      "match": {"value": ["GENERIC_MCU_3V3"]},
+      "supplies": [{"pins": ["VDD[A-Z0-9_]*", "VDDA"], "operating": [1.7, 3.6], "absolute": [-0.3, 4.0]}],
+      "grounds": ["VSS[A-Z0-9_]*", "GND"],
+      "inputs": [{"pins": ["P[A-Z]\\d{1,2}.*"], "vil_max": 0.99, "vih_min": 2.31, "max": 4.0}],
+      "outputs": [{"pins": ["P[A-Z]\\d{1,2}.*"], "vol_max": 0.4, "voh_min": 2.9, "kind": "push_pull"}],
+      "required": [
+        {"pin": "NRST", "requires": "capacitor_to_ground", "value": "100n"},
+        {"pin": "VDD[A-Z0-9_]*", "requires": "capacitor_to_ground"}
+      ]
+    },
+    {
+      "id": "generic-ldo-3v3",
+      "kind": "ic",
+      "description": "Generic 3.3 V low-dropout regulator: 2.5 to 16 V input, enable input that must not float.",
+      "match": {"value": ["GENERIC_LDO_3V3"]},
+      "supplies": [{"pins": ["VIN"], "operating": [2.5, 16.0], "absolute": [-0.3, 18.0]}],
+      "grounds": ["GND"],
+      "inputs": [{"pins": ["EN"], "vil_max": 0.4, "vih_min": 1.2, "max": 18.0}],
+      "outputs": [{"pins": ["VOUT"], "vol_max": 0.1, "voh_min": 3.2, "kind": "push_pull"}],
+      "required": [
+        {"pin": "EN", "requires": "not_floating"},
+        {"pin": "VIN", "requires": "capacitor_to_ground"},
+        {"pin": "VOUT", "requires": "capacitor_to_ground", "value": "1u"}
+      ]
+    },
+    {
+      "id": "generic-logic-5v",
+      "kind": "ic",
+      "description": "Generic 5 V logic buffer: 4.5 to 5.5 V supply, TTL-level inputs, 5 V push-pull outputs.",
+      "match": {"value": ["GENERIC_BUF_5V"]},
+      "supplies": [{"pins": ["VCC"], "operating": [4.5, 5.5], "absolute": [-0.5, 7.0]}],
+      "grounds": ["GND"],
+      "inputs": [{"pins": ["A\\d*"], "vil_max": 0.8, "vih_min": 2.0, "max": 7.0}],
+      "outputs": [{"pins": ["Y\\d*"], "vol_max": 0.4, "voh_min": 4.4, "kind": "push_pull"}],
+      "required": [{"pin": "VCC", "requires": "capacitor_to_ground"}]
+    },
+    {
+      "id": "generic-i2c-sensor-3v3",
+      "kind": "ic",
+      "description": "Generic I2C sensor: 1.8 to 3.6 V supply, open-drain SDA, inputs not 5 V tolerant.",
+      "match": {"value": ["GENERIC_I2C_SENSOR"]},
+      "supplies": [{"pins": ["VDD"], "operating": [1.8, 3.6], "absolute": [-0.3, 4.0]}],
+      "grounds": ["GND"],
+      "inputs": [{"pins": ["SCL", "SDA"], "vil_max": 0.54, "vih_min": 1.26, "max": 4.0}],
+      "outputs": [{"pins": ["SDA"], "vol_max": 0.4, "kind": "open_drain"}],
+      "required": [
+        {"pin": "SDA", "requires": "pull_up"},
+        {"pin": "SCL", "requires": "pull_up"},
+        {"pin": "VDD", "requires": "capacitor_to_ground"}
+      ]
+    }
+  ]
+}