python-aidot-cameras 0.10.2__tar.gz → 0.10.3__tar.gz

{python_aidot_cameras-0.10.2/python_aidot_cameras.egg-info → python_aidot_cameras-0.10.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-aidot-cameras
-Version: 0.10.2
+Version: 0.10.3
 Summary: Control AiDot/Leedarson WiFi lights and cameras (WebRTC streaming, two-way audio, PTZ, controls)
 Author-email: cbrightly <chris.brightly@gmail.com>
 License-Expression: MIT
@@ -17,11 +17,13 @@ Requires-Dist: cryptography>=42.0
 Requires-Dist: pycryptodome>=3.20
 Requires-Dist: dacite>=1.8
 Provides-Extra: webrtc
-Requires-Dist: aiortc>=1.9.0; extra == "webrtc"
-Requires-Dist: aioice<0.12,>=0.9.0; extra == "webrtc"
-Requires-Dist: av; extra == "webrtc"
-Requires-Dist: pylibsrtp; extra == "webrtc"
-Requires-Dist: pyopenssl; extra == "webrtc"
+Requires-Dist: av<18.0.0,>=14.0.0; extra == "webrtc"
+Requires-Dist: aioice<0.12,>=0.10.1; extra == "webrtc"
+Requires-Dist: pylibsrtp>=0.10.0; extra == "webrtc"
+Requires-Dist: pyopenssl>=25.0.0; extra == "webrtc"
+Requires-Dist: cryptography>=44.0.0; extra == "webrtc"
+Requires-Dist: pyee>=13.0.0; extra == "webrtc"
+Requires-Dist: google-crc32c>=1.1; extra == "webrtc"
 Requires-Dist: numpy; extra == "webrtc"
 Requires-Dist: Pillow; extra == "webrtc"
 Dynamic: license-file

python_aidot_cameras-0.10.3/aidot/_vendor/__init__.py

@@ -0,0 +1,2 @@
+"""Vendored third-party packages. See aiortc/ (byte-identical to aiortc
+1.14.0; vendored so HA 2026.7 av==17 is satisfiable, stock aiortc caps av<17)."""

python_aidot_cameras-0.10.3/aidot/_vendor/aiortc/__init__.py

@@ -0,0 +1,100 @@
+# ruff: noqa: F401
+import logging
+
+from .exceptions import InvalidAccessError, InvalidStateError
+from .mediastreams import (
+    AudioStreamTrack,
+    MediaStreamError,
+    MediaStreamTrack,
+    VideoStreamTrack,
+)
+from .rtcconfiguration import RTCBundlePolicy, RTCConfiguration, RTCIceServer
+from .rtcdatachannel import RTCDataChannel, RTCDataChannelParameters
+from .rtcdtlstransport import (
+    RTCCertificate,
+    RTCDtlsFingerprint,
+    RTCDtlsParameters,
+    RTCDtlsTransport,
+)
+from .rtcicetransport import (
+    RTCIceCandidate,
+    RTCIceGatherer,
+    RTCIceParameters,
+    RTCIceTransport,
+)
+from .rtcpeerconnection import RTCPeerConnection
+from .rtcrtpparameters import (
+    RTCRtcpParameters,
+    RTCRtpCapabilities,
+    RTCRtpCodecCapability,
+    RTCRtpCodecParameters,
+    RTCRtpHeaderExtensionCapability,
+    RTCRtpHeaderExtensionParameters,
+    RTCRtpParameters,
+)
+from .rtcrtpreceiver import (
+    RTCRtpContributingSource,
+    RTCRtpReceiver,
+    RTCRtpSynchronizationSource,
+)
+from .rtcrtpsender import RTCRtpSender
+from .rtcrtptransceiver import RTCRtpTransceiver
+from .rtcsctptransport import RTCSctpCapabilities, RTCSctpTransport
+from .rtcsessiondescription import RTCSessionDescription
+from .stats import (
+    RTCInboundRtpStreamStats,
+    RTCOutboundRtpStreamStats,
+    RTCRemoteInboundRtpStreamStats,
+    RTCRemoteOutboundRtpStreamStats,
+    RTCStatsReport,
+    RTCTransportStats,
+)
+
+__version__ = "1.14.0"
+
+# Set default logging handler to avoid "No handler found" warnings.
+logging.getLogger(__name__).addHandler(logging.NullHandler())
+
+__all__ = [
+    "AudioStreamTrack",
+    "InvalidAccessError",
+    "InvalidStateError",
+    "MediaStreamError",
+    "MediaStreamTrack",
+    "RTCBundlePolicy",
+    "RTCCertificate",
+    "RTCConfiguration",
+    "RTCDataChannel",
+    "RTCDataChannelParameters",
+    "RTCDtlsFingerprint",
+    "RTCDtlsParameters",
+    "RTCDtlsTransport",
+    "RTCIceCandidate",
+    "RTCIceGatherer",
+    "RTCIceParameters",
+    "RTCIceServer",
+    "RTCIceTransport",
+    "RTCInboundRtpStreamStats",
+    "RTCOutboundRtpStreamStats",
+    "RTCPeerConnection",
+    "RTCRemoteInboundRtpStreamStats",
+    "RTCRemoteOutboundRtpStreamStats",
+    "RTCRtcpParameters",
+    "RTCRtpCapabilities",
+    "RTCRtpCodecCapability",
+    "RTCRtpCodecParameters",
+    "RTCRtpContributingSource",
+    "RTCRtpHeaderExtensionCapability",
+    "RTCRtpHeaderExtensionParameters",
+    "RTCRtpParameters",
+    "RTCRtpReceiver",
+    "RTCRtpSender",
+    "RTCRtpSynchronizationSource",
+    "RTCRtpTransceiver",
+    "RTCSctpCapabilities",
+    "RTCSctpTransport",
+    "RTCSessionDescription",
+    "RTCStatsReport",
+    "RTCTransportStats",
+    "VideoStreamTrack",
+]

python_aidot_cameras-0.10.3/aidot/_vendor/aiortc/clock.py

@@ -0,0 +1,29 @@
+import datetime
+
+NTP_EPOCH = datetime.datetime(1900, 1, 1, tzinfo=datetime.timezone.utc)
+
+
+def current_datetime() -> datetime.datetime:
+    return datetime.datetime.now(datetime.timezone.utc)
+
+
+def current_ms() -> int:
+    delta = current_datetime() - NTP_EPOCH
+    return int(delta.total_seconds() * 1000)
+
+
+def current_ntp_time() -> int:
+    return datetime_to_ntp(current_datetime())
+
+
+def datetime_from_ntp(ntp: int) -> datetime.datetime:
+    seconds = ntp >> 32
+    microseconds = ((ntp & 0xFFFFFFFF) * 1000000) / (1 << 32)
+    return NTP_EPOCH + datetime.timedelta(seconds=seconds, microseconds=microseconds)
+
+
+def datetime_to_ntp(dt: datetime.datetime) -> int:
+    delta = dt - NTP_EPOCH
+    high = int(delta.total_seconds())
+    low = round((delta.microseconds * (1 << 32)) // 1000000)
+    return (high << 32) | low

python_aidot_cameras-0.10.3/aidot/_vendor/aiortc/codecs/__init__.py

@@ -0,0 +1,190 @@
+from typing import Optional, Union
+
+from ..rtcrtpparameters import (
+    ParametersDict,
+    RTCRtcpFeedback,
+    RTCRtpCapabilities,
+    RTCRtpCodecCapability,
+    RTCRtpCodecParameters,
+    RTCRtpHeaderExtensionCapability,
+    RTCRtpHeaderExtensionParameters,
+)
+from .base import Decoder, Encoder
+from .g711 import PcmaDecoder, PcmaEncoder, PcmuDecoder, PcmuEncoder
+from .g722 import G722Decoder, G722Encoder
+from .h264 import H264Decoder, H264Encoder, h264_depayload
+from .opus import OpusDecoder, OpusEncoder
+from .vpx import Vp8Decoder, Vp8Encoder, vp8_depayload
+
+# The clockrate for G.722 is 8kHz even though the sampling rate is 16kHz.
+# See https://datatracker.ietf.org/doc/html/rfc3551
+G722_CODEC = RTCRtpCodecParameters(
+    mimeType="audio/G722", clockRate=8000, channels=1, payloadType=9
+)
+PCMU_CODEC = RTCRtpCodecParameters(
+    mimeType="audio/PCMU", clockRate=8000, channels=1, payloadType=0
+)
+PCMA_CODEC = RTCRtpCodecParameters(
+    mimeType="audio/PCMA", clockRate=8000, channels=1, payloadType=8
+)
+
+CODECS: dict[str, list[RTCRtpCodecParameters]] = {
+    "audio": [
+        RTCRtpCodecParameters(
+            mimeType="audio/opus", clockRate=48000, channels=2, payloadType=96
+        ),
+        G722_CODEC,
+        PCMU_CODEC,
+        PCMA_CODEC,
+    ],
+    "video": [],
+}
+# Note, the id space for these extensions is shared across media types when BUNDLE
+# is negotiated. If you add a audio- or video-specific extension, make sure it has
+# a unique id.
+HEADER_EXTENSIONS: dict[str, list[RTCRtpHeaderExtensionParameters]] = {
+    "audio": [
+        RTCRtpHeaderExtensionParameters(
+            id=1, uri="urn:ietf:params:rtp-hdrext:sdes:mid"
+        ),
+        RTCRtpHeaderExtensionParameters(
+            id=2, uri="urn:ietf:params:rtp-hdrext:ssrc-audio-level"
+        ),
+    ],
+    "video": [
+        RTCRtpHeaderExtensionParameters(
+            id=1, uri="urn:ietf:params:rtp-hdrext:sdes:mid"
+        ),
+        RTCRtpHeaderExtensionParameters(
+            id=3, uri="http://www.webrtc.org/experiments/rtp-hdrext/abs-send-time"
+        ),
+    ],
+}
+
+
+def init_codecs() -> None:
+    dynamic_pt = 97
+
+    def add_video_codec(
+        mimeType: str, parameters: Optional[ParametersDict] = None
+    ) -> None:
+        nonlocal dynamic_pt
+
+        clockRate = 90000
+        CODECS["video"] += [
+            RTCRtpCodecParameters(
+                mimeType=mimeType,
+                clockRate=clockRate,
+                payloadType=dynamic_pt,
+                rtcpFeedback=[
+                    RTCRtcpFeedback(type="nack"),
+                    RTCRtcpFeedback(type="nack", parameter="pli"),
+                    RTCRtcpFeedback(type="goog-remb"),
+                ],
+                parameters=parameters or {},
+            ),
+            RTCRtpCodecParameters(
+                mimeType="video/rtx",
+                clockRate=clockRate,
+                payloadType=dynamic_pt + 1,
+                parameters={"apt": dynamic_pt},
+            ),
+        ]
+        dynamic_pt += 2
+
+    add_video_codec("video/VP8")
+    for profile_level_id in ("42001f", "42e01f"):
+        add_video_codec(
+            "video/H264",
+            {
+                "level-asymmetry-allowed": "1",
+                "packetization-mode": "1",
+                "profile-level-id": profile_level_id,
+            },
+        )
+
+
+def depayload(codec: RTCRtpCodecParameters, payload: bytes) -> bytes:
+    if codec.name == "VP8":
+        return vp8_depayload(payload)
+    elif codec.name == "H264":
+        return h264_depayload(payload)
+    else:
+        return payload
+
+
+def get_capabilities(kind: str) -> RTCRtpCapabilities:
+    if kind not in CODECS:
+        raise ValueError(f"cannot get capabilities for unknown media {kind}")
+
+    codecs = []
+    rtx_added = False
+    for params in CODECS[kind]:
+        if not is_rtx(params):
+            codecs.append(
+                RTCRtpCodecCapability(
+                    mimeType=params.mimeType,
+                    clockRate=params.clockRate,
+                    channels=params.channels,
+                    parameters=params.parameters,
+                )
+            )
+        elif not rtx_added:
+            # There will only be a single entry in codecs[] for retransmission
+            # via RTX, with sdpFmtpLine not present.
+            codecs.append(
+                RTCRtpCodecCapability(
+                    mimeType=params.mimeType, clockRate=params.clockRate
+                )
+            )
+            rtx_added = True
+
+    headerExtensions = []
+    for extension in HEADER_EXTENSIONS[kind]:
+        headerExtensions.append(RTCRtpHeaderExtensionCapability(uri=extension.uri))
+    return RTCRtpCapabilities(codecs=codecs, headerExtensions=headerExtensions)
+
+
+def get_decoder(codec: RTCRtpCodecParameters) -> Decoder:
+    mimeType = codec.mimeType.lower()
+
+    if mimeType == "audio/g722":
+        return G722Decoder()
+    elif mimeType == "audio/opus":
+        return OpusDecoder()
+    elif mimeType == "audio/pcma":
+        return PcmaDecoder()
+    elif mimeType == "audio/pcmu":
+        return PcmuDecoder()
+    elif mimeType == "video/h264":
+        return H264Decoder()
+    elif mimeType == "video/vp8":
+        return Vp8Decoder()
+    else:
+        raise ValueError(f"No decoder found for MIME type `{mimeType}`")
+
+
+def get_encoder(codec: RTCRtpCodecParameters) -> Encoder:
+    mimeType = codec.mimeType.lower()
+
+    if mimeType == "audio/g722":
+        return G722Encoder()
+    elif mimeType == "audio/opus":
+        return OpusEncoder()
+    elif mimeType == "audio/pcma":
+        return PcmaEncoder()
+    elif mimeType == "audio/pcmu":
+        return PcmuEncoder()
+    elif mimeType == "video/h264":
+        return H264Encoder()
+    elif mimeType == "video/vp8":
+        return Vp8Encoder()
+    else:
+        raise ValueError(f"No encoder found for MIME type `{mimeType}`")
+
+
+def is_rtx(codec: Union[RTCRtpCodecCapability, RTCRtpCodecParameters]) -> bool:
+    return codec.name.lower() == "rtx"
+
+
+init_codecs()

python_aidot_cameras-0.10.3/aidot/_vendor/aiortc/codecs/base.py

@@ -0,0 +1,24 @@
+from abc import ABCMeta, abstractmethod
+
+from av.frame import Frame
+from av.packet import Packet
+
+from ..jitterbuffer import JitterFrame
+
+
+class Decoder(metaclass=ABCMeta):
+    @abstractmethod
+    def decode(self, encoded_frame: JitterFrame) -> list[Frame]:
+        pass  # pragma: no cover
+
+
+class Encoder(metaclass=ABCMeta):
+    @abstractmethod
+    def encode(
+        self, frame: Frame, force_keyframe: bool = False
+    ) -> tuple[list[bytes], int]:
+        pass  # pragma: no cover
+
+    @abstractmethod
+    def pack(self, packet: Packet) -> tuple[list[bytes], int]:
+        pass  # pragma: no cover

python_aidot_cameras-0.10.3/aidot/_vendor/aiortc/codecs/g711.py

@@ -0,0 +1,89 @@
+import fractions
+from typing import Literal, cast
+
+from av import AudioFrame, AudioResampler, CodecContext
+from av.frame import Frame
+from av.packet import Packet
+
+from ..jitterbuffer import JitterFrame
+from ..mediastreams import convert_timebase
+from .base import Decoder, Encoder
+
+SAMPLE_RATE = 8000
+SAMPLE_WIDTH = 2
+SAMPLES_PER_FRAME = 160
+TIME_BASE = fractions.Fraction(1, 8000)
+
+
+class PcmDecoder(Decoder):
+    def __init__(self, codec_name: Literal["pcm_alaw", "pcm_mulaw"]) -> None:
+        self.codec = CodecContext.create(codec_name, "r")
+        self.codec.format = "s16"
+        self.codec.layout = "mono"
+        self.codec.sample_rate = SAMPLE_RATE
+
+    def decode(self, encoded_frame: JitterFrame) -> list[Frame]:
+        packet = Packet(encoded_frame.data)
+        packet.pts = encoded_frame.timestamp
+        packet.time_base = TIME_BASE
+        return cast(list[Frame], self.codec.decode(packet))
+
+
+class PcmEncoder(Encoder):
+    def __init__(self, codec_name: Literal["pcm_alaw", "pcm_mulaw"]) -> None:
+        self.codec = CodecContext.create(codec_name, "w")
+        self.codec.format = "s16"
+        self.codec.layout = "mono"
+        self.codec.sample_rate = SAMPLE_RATE
+        self.codec.time_base = TIME_BASE
+
+        # Create our own resampler to control the frame size.
+        self.resampler = AudioResampler(
+            format="s16",
+            layout="mono",
+            rate=SAMPLE_RATE,
+            frame_size=SAMPLES_PER_FRAME,
+        )
+
+    def encode(
+        self, frame: Frame, force_keyframe: bool = False
+    ) -> tuple[list[bytes], int]:
+        assert isinstance(frame, AudioFrame)
+        assert frame.format.name == "s16"
+        assert frame.layout.name in ["mono", "stereo"]
+
+        # Send frame through resampler and encoder.
+        packets = []
+        for frame in self.resampler.resample(frame):
+            packets += self.codec.encode(frame)
+
+        if packets:
+            # Packets were returned.
+            return [bytes(p) for p in packets], packets[0].pts
+        else:
+            # No packets were returned due to buffering.
+            return [], None
+
+    def pack(self, packet: Packet) -> tuple[list[bytes], int]:
+        timestamp = convert_timebase(packet.pts, packet.time_base, TIME_BASE)
+        return [bytes(packet)], timestamp
+
+
+class PcmaDecoder(PcmDecoder):
+    def __init__(self) -> None:
+        super().__init__("pcm_alaw")
+
+
+class PcmaEncoder(PcmEncoder):
+    def __init__(self) -> None:
+        super().__init__("pcm_alaw")
+
+
+class PcmuDecoder(PcmDecoder):
+    def __init__(self) -> None:
+        super().__init__("pcm_mulaw")
+
+
+class PcmuEncoder(PcmEncoder):
+    def __init__(self) -> None:
+        super().__init__("pcm_mulaw")

python_aidot_cameras-0.10.3/aidot/_vendor/aiortc/codecs/g722.py

@@ -0,0 +1,77 @@
+import fractions
+from typing import Optional, cast
+
+from av import AudioCodecContext, AudioFrame, AudioResampler, CodecContext
+from av.frame import Frame
+from av.packet import Packet
+
+from ..jitterbuffer import JitterFrame
+from ..mediastreams import convert_timebase
+from .base import Decoder, Encoder
+
+SAMPLE_RATE = 16000
+SAMPLE_WIDTH = 2
+SAMPLES_PER_FRAME = 320
+TIME_BASE = fractions.Fraction(1, 16000)
+
+# Even though the sample rate is 16kHz, the clockrate is defined as 8kHz.
+# This is why we have multiplications and divisions by 2 in the code.
+CLOCK_BASE = fractions.Fraction(1, 8000)
+
+
+class G722Decoder(Decoder):
+    def __init__(self) -> None:
+        self.codec = cast(AudioCodecContext, CodecContext.create("g722", "r"))
+        self.codec.format = "s16"
+        self.codec.layout = "mono"
+        self.codec.sample_rate = SAMPLE_RATE
+
+    def decode(self, encoded_frame: JitterFrame) -> list[Frame]:
+        packet = Packet(encoded_frame.data)
+        packet.pts = encoded_frame.timestamp * 2
+        packet.time_base = TIME_BASE
+        return cast(list[Frame], self.codec.decode(packet))
+
+
+class G722Encoder(Encoder):
+    def __init__(self) -> None:
+        self.codec = cast(AudioCodecContext, CodecContext.create("g722", "w"))
+        self.codec.format = "s16"
+        self.codec.layout = "mono"
+        self.codec.sample_rate = SAMPLE_RATE
+        self.codec.time_base = TIME_BASE
+        self.first_pts: Optional[int] = None
+
+        # Create our own resampler to control the frame size.
+        self.resampler = AudioResampler(
+            format="s16",
+            layout="mono",
+            rate=SAMPLE_RATE,
+            frame_size=SAMPLES_PER_FRAME,
+        )
+
+    def encode(
+        self, frame: Frame, force_keyframe: bool = False
+    ) -> tuple[list[bytes], int]:
+        assert isinstance(frame, AudioFrame)
+        assert frame.format.name == "s16"
+        assert frame.layout.name in ["mono", "stereo"]
+
+        # Send frame through resampler and encoder.
+        packets = []
+        for frame in self.resampler.resample(frame):
+            packets += self.codec.encode(frame)
+
+        if packets:
+            # Packets were returned.
+            if self.first_pts is None:
+                self.first_pts = packets[0].pts
+            timestamp = (packets[0].pts - self.first_pts) // 2
+            return [bytes(p) for p in packets], timestamp
+        else:
+            # No packets were returned due to buffering.
+            return [], None
+
+    def pack(self, packet: Packet) -> tuple[list[bytes], int]:
+        timestamp = convert_timebase(packet.pts, packet.time_base, CLOCK_BASE)
+        return [bytes(packet)], timestamp