nidaqlib.channels¶

def __post_init__(self) -> None:
    """Validate the voltage range."""
    ChannelSpec.__post_init__(self)
    if self.min_val >= self.max_val:
        raise NIDaqValidationError(
            f"min_val must be < max_val for {self.display_name!r}; "
            f"got {self.min_val!r} >= {self.max_val!r}"
        )

def __post_init__(self) -> None:
    """Validate the output and safety ranges."""
    ChannelSpec.__post_init__(self)
    if self.min_val >= self.max_val:
        raise NIDaqValidationError(
            f"min_val must be < max_val for {self.display_name!r}; "
            f"got {self.min_val!r} >= {self.max_val!r}"
        )
    lo = self.effective_safe_min
    hi = self.effective_safe_max
    if lo > hi:
        raise NIDaqValidationError(
            f"safe_min must be <= safe_max for {self.display_name!r}; got {lo!r} > {hi!r}"
        )
    if lo < self.min_val or hi > self.max_val:
        raise NIDaqValidationError(
            f"safe range [{lo}, {hi}] must stay inside device range "
            f"[{self.min_val}, {self.max_val}] for {self.display_name!r}"
        )

def __post_init__(self) -> None:
    """Validate and freeze common channel metadata."""
    if not self.physical_channel:
        raise NIDaqValidationError("physical_channel must be a non-empty string")
    if self.name is not None and not self.name:
        raise NIDaqValidationError("name must be non-empty when provided")
    object.__setattr__(self, "metadata", MappingProxyType(dict(self.metadata)))

@classmethod
def from_dict(cls, data: Mapping[str, Any]) -> Self:
    """Deserialise from a dict produced by :meth:`to_dict`.

    On the base class, this dispatches to the registered subclass for the
    ``kind`` discriminator. On a concrete subclass, this validates that
    ``kind`` matches and constructs the dataclass directly.

    Args:
        data: Mapping carrying the ``kind`` discriminator and field values.

    Raises:
        NIDaqValidationError: ``kind`` is missing, unknown, or does not
            match the concrete class.
    """
    kind = data.get("kind")
    if cls is ChannelSpec:
        if not isinstance(kind, str):
            raise NIDaqValidationError(
                f"channel spec dict missing 'kind' discriminator (got {kind!r})"
            )
        target = _CHANNEL_REGISTRY.get(kind)
        if target is None:
            raise NIDaqValidationError(f"unknown channel kind {kind!r}")
        # Mypy can't see that the registered class returns Self here; the
        # dispatch is dynamic by design, so cast at the boundary.
        return target.from_dict(data)  # type: ignore[return-value]
    if kind != cls.kind:
        raise NIDaqValidationError(f"kind mismatch: expected {cls.kind!r}, got {kind!r}")
    payload = {k: v for k, v in data.items() if k != "kind"}
    return cls(**payload)

def to_dict(self) -> dict[str, Any]:
    """Serialise to a JSON/TOML-friendly dict, including ``kind``.

    Returns:
        A dict carrying ``kind`` plus every dataclass field. Mappings are
        copied to plain ``dict`` so the result is JSON-encodable.
    """
    payload: dict[str, Any] = {}
    for spec in dataclasses.fields(self):
        value = getattr(self, spec.name)
        if isinstance(value, Mapping):
            value = dict(cast("Mapping[str, Any]", value))
        payload[spec.name] = value
    payload["kind"] = self.kind
    return payload

def __post_init__(self) -> None:
    """Validate common channel metadata."""
    ChannelSpec.__post_init__(self)

@classmethod
def from_dict(cls, data: Mapping[str, Any]) -> Self:
    """Deserialise, restoring :class:`Edge` from its string value."""
    kind = data.get("kind")
    if kind != cls.kind:
        raise NIDaqValidationError(f"kind mismatch: expected {cls.kind!r}, got {kind!r}")
    payload = {k: v for k, v in data.items() if k != "kind"}
    try:
        payload["edge"] = Edge(payload.get("edge", Edge.RISING.value))
    except ValueError as exc:
        raise NIDaqValidationError(f"unknown Edge {payload.get('edge')!r}") from exc
    return cls(**payload)

def to_dict(self) -> dict[str, Any]:
    """Serialise; encode :class:`Edge` to its string value."""
    payload = ChannelSpec.to_dict(self)
    payload["edge"] = self.edge.value
    return payload

def __post_init__(self) -> None:
    """Validate the expected frequency range."""
    ChannelSpec.__post_init__(self)
    if self.min_val <= 0.0:
        raise NIDaqValidationError(f"min_val must be > 0 for {self.display_name!r}")
    if self.min_val >= self.max_val:
        raise NIDaqValidationError(
            f"min_val must be < max_val for {self.display_name!r}; "
            f"got {self.min_val!r} >= {self.max_val!r}"
        )

@classmethod
def from_dict(cls, data: Mapping[str, Any]) -> Self:
    """Deserialise, restoring :class:`Edge` from its string value."""
    kind = data.get("kind")
    if kind != cls.kind:
        raise NIDaqValidationError(f"kind mismatch: expected {cls.kind!r}, got {kind!r}")
    payload = {k: v for k, v in data.items() if k != "kind"}
    try:
        payload["edge"] = Edge(payload.get("edge", Edge.RISING.value))
    except ValueError as exc:
        raise NIDaqValidationError(f"unknown Edge {payload.get('edge')!r}") from exc
    return cls(**payload)

def to_dict(self) -> dict[str, Any]:
    """Serialise; encode :class:`Edge` to its string value."""
    payload = ChannelSpec.to_dict(self)
    payload["edge"] = self.edge.value
    return payload

def __post_init__(self) -> None:
    """Validate the expected period range."""
    ChannelSpec.__post_init__(self)
    if self.min_val <= 0.0:
        raise NIDaqValidationError(f"min_val must be > 0 for {self.display_name!r}")
    if self.min_val >= self.max_val:
        raise NIDaqValidationError(
            f"min_val must be < max_val for {self.display_name!r}; "
            f"got {self.min_val!r} >= {self.max_val!r}"
        )

@classmethod
def from_dict(cls, data: Mapping[str, Any]) -> Self:
    """Deserialise, restoring :class:`Edge` from its string value."""
    kind = data.get("kind")
    if kind != cls.kind:
        raise NIDaqValidationError(f"kind mismatch: expected {cls.kind!r}, got {kind!r}")
    payload = {k: v for k, v in data.items() if k != "kind"}
    try:
        payload["edge"] = Edge(payload.get("edge", Edge.RISING.value))
    except ValueError as exc:
        raise NIDaqValidationError(f"unknown Edge {payload.get('edge')!r}") from exc
    return cls(**payload)

def to_dict(self) -> dict[str, Any]:
    """Serialise; encode :class:`Edge` to its string value."""
    payload = ChannelSpec.to_dict(self)
    payload["edge"] = self.edge.value
    return payload

def __post_init__(self) -> None:
    """Validate pulse-train parameters."""
    ChannelSpec.__post_init__(self)
    if self.frequency <= 0.0:
        raise NIDaqValidationError(f"frequency must be > 0 for {self.display_name!r}")
    if not 0.0 < self.duty_cycle < 1.0:
        raise NIDaqValidationError(
            f"duty_cycle must be in (0.0, 1.0) for {self.display_name!r}; "
            f"got {self.duty_cycle!r}"
        )
    if self.initial_delay < 0.0:
        raise NIDaqValidationError(f"initial_delay must be >= 0 for {self.display_name!r}")

def __post_init__(self) -> None:
    """Validate pulse tick parameters."""
    ChannelSpec.__post_init__(self)
    if self.high_ticks <= 0 or self.low_ticks <= 0:
        raise NIDaqValidationError(
            f"high_ticks and low_ticks must be > 0 for {self.display_name!r}"
        )
    if self.initial_delay < 0:
        raise NIDaqValidationError(f"initial_delay must be >= 0 for {self.display_name!r}")

def __post_init__(self) -> None:
    """Validate pulse timing parameters."""
    ChannelSpec.__post_init__(self)
    if self.high_time <= 0.0 or self.low_time <= 0.0:
        raise NIDaqValidationError(
            f"high_time and low_time must be > 0 for {self.display_name!r}"
        )
    if self.initial_delay < 0.0:
        raise NIDaqValidationError(f"initial_delay must be >= 0 for {self.display_name!r}")

def __post_init__(self) -> None:
    """Validate the temperature range."""
    ChannelSpec.__post_init__(self)
    if self.min_val >= self.max_val:
        raise NIDaqValidationError(
            f"min_val must be < max_val for {self.display_name!r}; "
            f"got {self.min_val!r} >= {self.max_val!r}"
        )

@classmethod
def from_dict(cls, data: Mapping[str, Any]) -> Self:
    """Reconstruct, restoring enum members from their ``.value`` ints."""
    kind = data.get("kind")
    if kind != cls.kind:
        raise NIDaqValidationError(f"kind mismatch: expected {cls.kind!r}, got {kind!r}")
    from nidaqmx.constants import (  # noqa: PLC0415
        CJCSource,
        TemperatureUnits,
        ThermocoupleType,
    )

    payload = {k: v for k, v in data.items() if k != "kind"}
    try:
        payload["thermocouple_type"] = ThermocoupleType(payload["thermocouple_type"])
    except (KeyError, ValueError) as exc:
        raise NIDaqValidationError(
            f"unknown ThermocoupleType {payload.get('thermocouple_type')!r}"
        ) from exc
    if payload.get("cjc_source") is not None:
        try:
            payload["cjc_source"] = CJCSource(payload["cjc_source"])
        except ValueError as exc:
            raise NIDaqValidationError(
                f"unknown CJCSource {payload.get('cjc_source')!r}"
            ) from exc
    units_raw = payload.get("units", TemperatureUnits.DEG_C.value)
    try:
        payload["units"] = TemperatureUnits(units_raw)
    except ValueError as exc:
        raise NIDaqValidationError(f"unknown TemperatureUnits {units_raw!r}") from exc
    return cls(**payload)

def to_dict(self) -> dict[str, Any]:
    """Serialise via the enums' ``.value`` so the payload is JSON-encodable.

    ``nidaqmx.constants`` enums do not inherit from :class:`int`, so we
    record ``.value`` (an int) and reconstruct the enum on
    :meth:`from_dict`.
    """
    # Direct call (not super()) — the @dataclass(slots=True) decorator
    # rewrites the class, which leaves super()'s __class__ cell pointing
    # at a now-unrelated class object.
    payload = ChannelSpec.to_dict(self)
    payload["thermocouple_type"] = self.thermocouple_type.value
    payload["cjc_source"] = self.cjc_source.value if self.cjc_source is not None else None
    payload["units"] = self.units.value
    return payload