aiogotoconnect 0.2.0__py3-none-any.whl

aiogotoconnect/__init__.py

@@ -0,0 +1,23 @@
+from aiogotoconnect.auth import GoToOAuth, TokenProvider
+from aiogotoconnect.exceptions import (
+    GoToApiError,
+    GoToAuthError,
+    GoToCallError,
+    GoToError,
+    GoToSipError,
+)
+from aiogotoconnect.messaging import GoToMessaging
+from aiogotoconnect.sip.call import CallResult, GoToVoice
+
+__all__ = [
+    "CallResult",
+    "GoToApiError",
+    "GoToAuthError",
+    "GoToCallError",
+    "GoToError",
+    "GoToMessaging",
+    "GoToOAuth",
+    "GoToSipError",
+    "GoToVoice",
+    "TokenProvider",
+]

aiogotoconnect/auth.py

@@ -0,0 +1,83 @@
+import asyncio
+import base64
+import time
+from collections.abc import Awaitable, Callable
+
+import aiohttp
+
+from aiogotoconnect.exceptions import GoToAuthError
+
+# Any async callable returning a bearer token. Home Assistant passes its own.
+TokenProvider = Callable[[], Awaitable[str]]
+
+DEFAULT_TOKEN_URL = "https://authentication.logmeininc.com/oauth/token"
+
+# Refresh this many seconds before expiry so a token never expires mid-request.
+REFRESH_MARGIN_SECONDS = 60
+
+
+class GoToOAuth:
+    """Standalone OAuth provider: refresh-token grant with cached access token."""
+
+    def __init__(
+        self,
+        client_id: str,
+        client_secret: str,
+        refresh_token: str,
+        token_url: str = DEFAULT_TOKEN_URL,
+        session: aiohttp.ClientSession | None = None,
+    ):
+        self._client_id = client_id
+        self._client_secret = client_secret
+        self.refresh_token = refresh_token  # GoTo may rotate this on every refresh
+        self._token_url = token_url
+        self._session = session
+        self._access_token: str | None = None
+        self._expires_at = 0.0
+        self._refresh_lock = asyncio.Lock()
+
+    def _needs_refresh(self) -> bool:
+        expiring = time.monotonic() >= self._expires_at - REFRESH_MARGIN_SECONDS
+        return self._access_token is None or expiring
+
+    async def async_get_access_token(self) -> str:
+        if not self._needs_refresh():
+            return self._access_token
+        # Lock + re-check: concurrent callers wait, then reuse the token the first one fetched.
+        # Needed because a rotating refresh_token is single-use.
+        async with self._refresh_lock:
+            if self._needs_refresh():
+                await self._async_refresh()
+        return self._access_token
+
+    async def _async_refresh(self) -> None:
+        credentials = base64.b64encode(f"{self._client_id}:{self._client_secret}".encode()).decode()
+        headers = {"Authorization": f"Basic {credentials}"}
+        form = {"grant_type": "refresh_token", "refresh_token": self.refresh_token}
+
+        if self._session is None:
+            async with aiohttp.ClientSession() as session:
+                payload = await self._async_post_token(session, headers, form)
+        else:
+            payload = await self._async_post_token(self._session, headers, form)
+
+        # Error text is deliberately not included: it could echo a secret.
+        try:
+            access_token = payload["access_token"]
+            expires_in = float(payload["expires_in"])
+        except (KeyError, TypeError, ValueError) as error:
+            raise GoToAuthError("Token response missing access_token or expires_in") from error
+        self._access_token = access_token
+        self.refresh_token = payload.get("refresh_token", self.refresh_token)
+        self._expires_at = time.monotonic() + expires_in
+
+    async def _async_post_token(self, session, headers, form) -> dict:
+        try:
+            async with session.post(self._token_url, headers=headers, data=form) as response:
+                if response.status != 200:
+                    raise GoToAuthError(f"Token refresh failed with HTTP {response.status}")
+                return await response.json()
+        except (aiohttp.ClientError, asyncio.TimeoutError) as error:
+            raise GoToAuthError("Token refresh request failed") from error
+        except ValueError as error:  # JSONDecodeError (non-JSON body)
+            raise GoToAuthError("Token response was not valid JSON") from error

aiogotoconnect/exceptions.py

@@ -0,0 +1,22 @@
+class GoToError(Exception):
+    """Base class for all aiogotoconnect errors."""
+
+
+class GoToAuthError(GoToError):
+    """Credentials were rejected: OAuth token refresh failed, SIP digest credentials refused, or SMS got a 401."""
+
+
+class GoToApiError(GoToError):
+    """A GoTo REST API call returned a non-success HTTP status."""
+
+    def __init__(self, message: str, status: int):
+        super().__init__(message)
+        self.status = status
+
+
+class GoToSipError(GoToError):
+    """SIP registration or signalling failed."""
+
+
+class GoToCallError(GoToSipError):
+    """An outbound call could not be completed."""

aiogotoconnect/messaging.py

@@ -0,0 +1,51 @@
+import asyncio
+
+import aiohttp
+
+from aiogotoconnect.auth import TokenProvider
+from aiogotoconnect.exceptions import GoToApiError, GoToAuthError, GoToError
+
+
+class GoToMessaging:
+    """GoTo Messaging v2 client: send SMS from an owner number to contact numbers."""
+
+    def __init__(
+        self,
+        token_provider: TokenProvider,
+        session: aiohttp.ClientSession | None = None,
+        base_url: str = "https://api.goto.com",
+    ):
+        self._token_provider = token_provider
+        self._session = session
+        self._base_url = base_url
+
+    async def async_send_sms(self, owner_phone: str, contacts: list[str], body: str) -> dict:
+        # GoTo rejects owner == contact with a confusing error, so fail fast here.
+        if owner_phone in contacts:
+            raise ValueError("owner_phone must not also be a contact")
+
+        headers = {"Authorization": f"Bearer {await self._token_provider()}"}
+        payload = {"ownerPhoneNumber": owner_phone, "contactPhoneNumbers": contacts, "body": body}
+        url = f"{self._base_url}/messaging/v1/messages"
+
+        if self._session is None:
+            async with aiohttp.ClientSession() as session:
+                return await self._async_post(session, url, headers, payload)
+        return await self._async_post(self._session, url, headers, payload)
+
+    async def _async_post(self, session, url, headers, payload) -> dict:
+        try:
+            async with session.post(url, headers=headers, json=payload) as response:
+                if response.status == 401:
+                    raise GoToAuthError("SMS send rejected: access token not accepted")
+                # Error text is deliberately not included: it could echo phone numbers or tokens.
+                if response.status >= 400:
+                    raise GoToApiError(f"SMS send failed with HTTP {response.status}", response.status)
+                # Success with no usable body is still success: GoTo returns JSON, but don't rely on it.
+                try:
+                    parsed = await response.json(content_type=None)
+                except ValueError:  # JSONDecodeError: body was not JSON
+                    return {}
+                return {} if parsed is None else parsed  # aiohttp yields None for an empty body
+        except (aiohttp.ClientError, asyncio.TimeoutError) as error:
+            raise GoToError("SMS send request failed") from error

aiogotoconnect/sip/audio.py

@@ -0,0 +1,50 @@
+"""WAV to raw G.711 conversion for the RTP sender.
+
+Input is any PCM WAV (Home Assistant TTS output). Output is headerless a-law
+(PCMA, payload type 8) or mu-law (PCMU) bytes at 8 kHz mono, one byte per sample.
+"""
+
+import io
+import warnings
+import wave
+
+# ponytail: audioop is deprecated on 3.12 (PEP 594) and removed on 3.13, where
+# the audioop-lts dependency provides the same module name. Silence only this
+# import-time DeprecationWarning, so the rest of the suite still fails on warnings.
+with warnings.catch_warnings():
+    warnings.simplefilter("ignore", DeprecationWarning)
+    import audioop
+
+TARGET_RATE = 8000
+CODECS = {"pcma": audioop.lin2alaw, "pcmu": audioop.lin2ulaw}
+
+
+def wav_to_g711(wav_bytes: bytes, codec: str = "pcma") -> bytes:
+    """Convert WAV bytes to 8 kHz mono G.711 (`pcma` or `pcmu`) payload bytes."""
+    encode = CODECS.get(codec)
+    if encode is None:
+        raise ValueError(f"unknown codec {codec!r}; expected 'pcma' or 'pcmu'")
+    try:
+        with wave.open(io.BytesIO(wav_bytes), "rb") as wf:
+            channels = wf.getnchannels()
+            width = wf.getsampwidth()
+            rate = wf.getframerate()
+            frames = wf.readframes(wf.getnframes())
+    except (wave.Error, EOFError) as exc:
+        raise ValueError(f"input is not a readable PCM WAV: {exc}") from exc
+
+    if not frames:
+        raise ValueError("WAV contains no audio frames")  # would otherwise 'play' a silent call
+    if channels > 2:
+        # ponytail: stereo downmix only, multichannel needs a per-channel mixer.
+        raise ValueError(f"unsupported channel count: {channels}")
+    if width == 1:
+        # WAV 8-bit PCM is unsigned; audioop expects signed samples.
+        frames = audioop.bias(frames, 1, 128)
+    if width != 2:
+        frames = audioop.lin2lin(frames, width, 2)
+    if channels == 2:
+        frames = audioop.tomono(frames, 2, 0.5, 0.5)
+    if rate != TARGET_RATE:
+        frames, _ = audioop.ratecv(frames, 2, 1, rate, TARGET_RATE, None)
+    return encode(frames, 2)

aiogotoconnect/sip/call.py

@@ -0,0 +1,361 @@
+"""Outbound SIP call: REGISTER -> INVITE -> play G.711 audio over RTP -> BYE.
+
+# ponytail: per-call REGISTER; persistent registration if call setup latency ever matters
+# ponytail: UDP retransmits are a simple 0.5s-doubling resend until the first response; no full
+#           RFC 3261 timer set (Timer E/G/H) and no re-INVITE/refresh handling.
+"""
+
+import asyncio
+import logging
+import re
+import ssl
+import time
+from dataclasses import dataclass
+
+from aiogotoconnect.exceptions import GoToAuthError, GoToCallError, GoToSipError
+from aiogotoconnect.sip.audio import wav_to_g711
+from aiogotoconnect.sip.messages import (
+    CODEC_PAYLOADS,
+    SipDialog,
+    SipResponse,
+    _check_number,
+    build_ack,
+    build_bye,
+    build_cancel,
+    build_invite,
+    build_register,
+    digest_response,
+)
+from aiogotoconnect.sip.rtp import RtpSender
+from aiogotoconnect.sip.transport import SipTransport, make_transport
+
+log = logging.getLogger(__name__)  # start-lines/status codes only: never headers (auth values)
+
+_REPLY_TIMEOUT = 5.0  # non-INVITE transactions and post-CANCEL/BYE waits
+_GAP_SECONDS = 0.5  # pause between repeats of the audio
+_REFUSALS = {486: "busy", 603: "rejected"}
+
+
+@dataclass
+class CallResult:
+    answered: bool
+    duration: float
+    reason: str  # "completed" | "remote-hangup" | "no-answer" | "busy" | "rejected"
+    # False only when we sent a BYE and the server did not answer it with a 200 (the call may
+    # still be up on the far side). True when no BYE was needed or the BYE was confirmed.
+    bye_confirmed: bool = True
+
+
+def _branch_of(request: bytes) -> str:
+    return re.search(rb"branch=([^;,\s]+)", request).group(1).decode()
+
+
+@dataclass
+class _Leg:
+    """An established dialog (after a 200 OK): what in-dialog requests need."""
+
+    dialog: SipDialog
+    to_tag: str
+    target: str | None  # the 200's Contact URI = request-URI of ACK/BYE
+    routes: list[str]  # Record-Route reversed (RFC 3261 12.1.2)
+    ack: bytes = b""
+    invite_cseq: int = 0
+
+
+def _tag_of(response: SipResponse) -> str:
+    m = re.search(r";\s*tag=([^;>\s]+)", response.get("to", ""))
+    return m.group(1) if m else ""
+
+
+def _ok_for(request: bytes) -> bytes:
+    """A 200 OK for an incoming request: echo Via/From/To/Call-ID/CSeq."""
+    echo = ("via", "from", "to", "call-id", "cseq")
+    lines = request.decode(errors="replace").split("\r\n\r\n")[0].split("\r\n")[1:]
+    kept = [ln for ln in lines if ln.partition(":")[0].strip().lower() in echo]
+    return "\r\n".join(["SIP/2.0 200 OK", *kept, "Content-Length: 0", "", ""]).encode()
+
+
+def _remote_media(sdp: str) -> tuple[str, int]:
+    c = re.search(r"^c=IN IP4 (\S+)", sdp, re.M)
+    m = re.search(r"^m=audio (\d+) ", sdp, re.M)
+    if not (c and m):
+        raise GoToCallError("200 OK carried no usable audio SDP")
+    return c.group(1), int(m.group(1))
+
+
+class _Call:
+    """One call's signalling; owns the transport and RTP socket for its lifetime."""
+
+    def __init__(self, tp: SipTransport, mode: str, username, password, domain, number, rtp):
+        self.tp, self.via, self.username, self.password = tp, mode.upper(), username, password
+        self.domain, self.number, self.rtp = domain, number, rtp
+        self.ip, self.port = tp.local_addr
+        self.common = dict(username=username, domain=domain, local_ip=self.ip,
+                           local_port=self.port, transport=self.via)
+        self.invite_branch = ""
+        self.pending: tuple[SipDialog, str] | None = None  # (dialog, branch) of an INVITE with no final response yet
+
+    async def send(self, data: bytes) -> None:
+        log.debug("SIP -> %s", data.split(b"\r\n", 1)[0][:100].decode(errors="replace"))
+        await self.tp.send(data)
+
+    async def recv(self, timeout: float) -> bytes:
+        raw = await self.tp.receive(timeout)
+        log.debug("SIP <- %s", raw.split(b"\r\n", 1)[0][:100].decode(errors="replace"))
+        return raw
+
+    async def _final(self, method: str, cseq: int, timeout: float,
+                     resend: bytes | None = None) -> SipResponse:
+        """Next final (>=200) response to CSeq `cseq method`; provisionals, strays and requests are skipped.
+
+        `resend` (UDP only): retransmit it at 0.5s, 1s, 2s... until the first response to this
+        transaction arrives. Matching the whole CSeq ignores a stale retransmitted 407.
+        """
+        loop = asyncio.get_running_loop()
+        deadline, delay = loop.time() + timeout, 0.5
+        if self.via != "UDP":
+            resend = None
+        next_resend = loop.time() + delay
+        while True:
+            remaining = max(0.0, deadline - loop.time())
+            wait = min(remaining, max(0.0, next_resend - loop.time())) if resend else remaining
+            try:
+                raw = await self.recv(wait)
+            except asyncio.TimeoutError:
+                if not resend or wait >= remaining:
+                    raise
+                await self.send(resend)
+                delay *= 2
+                next_resend = loop.time() + delay
+                continue
+            if not raw.startswith(b"SIP/2.0"):
+                continue
+            resp = SipResponse.parse(raw)
+            if resp.get("cseq", "").split() != [str(cseq), method]:
+                continue
+            resend = None  # the server has the request
+            if resp.status >= 200:
+                return resp
+
+    def _auth_line(self, resp: SipResponse, method: str, uri: str) -> str:
+        name, header = (("Authorization", "www-authenticate") if resp.status == 401
+                        else ("Proxy-Authorization", "proxy-authenticate"))
+        challenge = resp.get(header)
+        if not challenge:
+            raise GoToSipError(f"{resp.status} response without a digest challenge")
+        return f"{name}: " + digest_response(challenge, method, uri, self.username, self.password)
+
+    async def transact(self, method, uri, dialog, build, timeout) -> SipResponse:
+        """Send, answer one 401/407 challenge, return the final response.
+
+        `build(auth_line)` makes the request bytes. A second challenge means bad credentials:
+        raise rather than loop. Non-2xx finals to INVITE (the 407) are ACKed here.
+        """
+        req = build(None)
+        for attempt in (0, 1):
+            await self.send(req)
+            resp = await self._final(method, dialog.cseq, timeout, resend=req)
+            if method == "INVITE":
+                self.pending = None  # a final response ended it: nothing left to CANCEL
+            if resp.status not in (401, 407):
+                return resp
+            if method == "INVITE":
+                await self.ack_refusal(dialog, resp, _branch_of(req))
+            if attempt:
+                raise GoToAuthError("SIP credentials rejected by server")
+            dialog.cseq += 1
+            req = build(self._auth_line(resp, method, uri))
+            if method == "INVITE":
+                log.debug("INVITE challenged; retrying with credentials")
+
+    async def ack_refusal(self, dialog, resp, branch: str) -> None:
+        """ACK a non-2xx final: same transaction (branch) as the INVITE."""
+        await self.send(build_ack(to_number=self.number, dialog=dialog, to_tag=_tag_of(resp),
+                                  branch=branch, **self.common))
+
+    def leg_from(self, dialog: SipDialog, resp: SipResponse) -> _Leg:
+        contact = re.search(r"<([^>]+)>|(sip:\S+)", resp.get("contact", ""))
+        target = (contact.group(1) or contact.group(2)) if contact else None
+        routes = re.findall(r"<[^>]*>", resp.get("record-route", ""))[::-1]
+        return _Leg(dialog, _tag_of(resp), target, routes)
+
+    async def ack_2xx(self, leg: _Leg) -> None:
+        """2xx ACK: a new transaction (fresh branch) to the Contact, via the route set."""
+        leg.invite_cseq = leg.dialog.cseq
+        leg.ack = build_ack(to_number=self.number, dialog=leg.dialog, to_tag=leg.to_tag,
+                            request_uri=leg.target, routes=leg.routes, **self.common)
+        await self.send(leg.ack)
+
+    def bye(self, leg: _Leg) -> bytes:
+        leg.dialog.cseq += 1
+        return build_bye(to_number=self.number, dialog=leg.dialog, to_tag=leg.to_tag,
+                         request_uri=leg.target, routes=leg.routes, **self.common)
+
+    async def hangup(self, leg: _Leg) -> bool:
+        """BYE and wait for its 200. False (and a warning) if it is refused or never answered."""
+        req = self.bye(leg)
+        await self.send(req)
+        try:
+            resp = await self._final("BYE", leg.dialog.cseq, _REPLY_TIMEOUT, resend=req)
+        except asyncio.TimeoutError:
+            log.warning("BYE got no reply; the far side may still think the call is up")
+            return False
+        if resp.status != 200:
+            log.warning("BYE refused: %s %s", resp.status, resp.reason)
+        return resp.status == 200
+
+    async def cancel_pending(self) -> bool:
+        """CANCEL the INVITE that has no final response yet and settle whatever answers it.
+
+        Returns bye_confirmed. If the 200 raced the CANCEL, the call is up: ACK it, then hang up.
+        """
+        dialog, branch = self.pending
+        self.pending = None
+        await self.send(build_cancel(to_number=self.number, dialog=dialog, branch=branch, **self.common))
+        try:  # the 487 for the INVITE (the 200 for the CANCEL is skipped by CSeq)
+            resp = await self._final("INVITE", dialog.cseq, _REPLY_TIMEOUT)
+        except asyncio.TimeoutError:
+            return True
+        if resp.status == 200:
+            leg = self.leg_from(dialog, resp)
+            await self.ack_2xx(leg)
+            return await self.hangup(leg)
+        await self.ack_refusal(dialog, resp, branch)
+        return True
+
+    async def register(self) -> None:
+        dialog, uri = SipDialog(), f"sip:{self.domain}"
+        resp = await self.transact("REGISTER", uri, dialog, lambda auth: build_register(
+            username=self.username, domain=self.domain, local_ip=self.ip, local_port=self.port,
+            dialog=dialog, auth_header=auth, transport=self.via), _REPLY_TIMEOUT)
+        if resp.status != 200:
+            raise GoToSipError(f"REGISTER failed: {resp.status} {resp.reason}")
+        log.debug("registered")
+
+    async def invite(self, ring_timeout: float, codec: str) -> tuple[SipDialog, SipResponse | None, str, bool]:
+        """Returns (dialog, final response or None on ring timeout, INVITE branch, bye_confirmed)."""
+        dialog = SipDialog()
+
+        def build(auth):
+            req = build_invite(to_number=self.number, media_port=self.rtp.local_port,
+                               dialog=dialog, auth_header=auth, codec=codec, **self.common)
+            self.invite_branch = _branch_of(req)
+            self.pending = (dialog, self.invite_branch)
+            return req
+
+        uri = f"sip:{self.number}@{self.domain}"
+        try:
+            resp = await self.transact("INVITE", uri, dialog, build, ring_timeout)
+        except asyncio.TimeoutError:
+            log.debug("ring timeout; cancelling")
+            return dialog, None, self.invite_branch, await self.cancel_pending()
+        return dialog, resp, self.invite_branch, True
+
+    async def play(self, payload: bytes, dest, repeat: int, stop: asyncio.Event, pt: int) -> None:
+        for n in range(repeat):
+            if n:
+                try:  # the inter-repeat gap, cut short by a remote hangup
+                    await asyncio.wait_for(stop.wait(), _GAP_SECONDS)
+                except asyncio.TimeoutError:
+                    pass
+            if stop.is_set():
+                return
+            await self.rtp.stream(payload, dest, payload_type=pt, stop=stop)
+
+    async def stream_until_done(self, payload: bytes, dest, repeat: int, pt: int, leg: _Leg) -> bool:
+        """Stream audio while watching for the server's BYE. True if the remote hung up.
+
+        A retransmitted 200 to our INVITE means the server missed our ACK: send it again.
+        """
+        stop = asyncio.Event()
+        play = asyncio.create_task(self.play(payload, dest, repeat, stop, pt))
+        hung_up, rx = False, None
+        try:
+            while not play.done():
+                rx = asyncio.create_task(self.recv(3600))
+                await asyncio.wait({rx, play}, return_when=asyncio.FIRST_COMPLETED)
+                if not rx.done():
+                    break  # audio finished; rx is reaped in finally
+                raw = rx.result()
+                if raw.startswith(b"BYE "):
+                    await self.send(_ok_for(raw))
+                    hung_up = True
+                    stop.set()
+                    break
+                if raw.startswith(b"SIP/2.0 200"):
+                    resp = SipResponse.parse(raw)
+                    if resp.get("cseq", "").split() == [str(leg.invite_cseq), "INVITE"]:
+                        await self.send(leg.ack)
+            await play
+        finally:
+            stop.set()
+            for task in (rx, play):  # also runs on outer cancellation: leave no orphan tasks
+                if task is not None and not task.done():
+                    task.cancel()
+            await asyncio.gather(*(t for t in (rx, play) if t is not None), return_exceptions=True)
+        return hung_up
+
+
+class GoToVoice:
+    def __init__(self, username: str, password: str, server: str = "reg.jiveip.net",
+                 proxy: str | None = None, transport: str = "udp", port: int | None = None,
+                 ssl_context: ssl.SSLContext | None = None) -> None:
+        self.username, self.password, self.server = username, password, server
+        self.proxy, self.transport, self.port = proxy, transport, port
+        self.ssl_context = ssl_context  # TLS only; None = verified system CAs
+
+    async def call_and_play(self, number: str, wav_bytes: bytes, *, ring_timeout: float = 25.0,
+                            repeat: int = 1, codec: str = "pcma") -> CallResult:
+        _check_number(number)  # fail before touching the network
+        payload = wav_to_g711(wav_bytes, codec)  # also rejects unknown codecs (ValueError)
+        pt = CODEC_PAYLOADS[codec][0]
+        tp = make_transport(self.proxy or self.server, self.transport, self.port, self.ssl_context)
+        rtp = call = leg = None
+        acked = bye_sent = False
+        try:
+            await tp.connect()
+            rtp = RtpSender()  # bound now so the INVITE's SDP carries the real port
+            call = _Call(tp, self.transport, self.username, self.password, self.server, number, rtp)
+            await call.register()
+            dialog, resp, branch, bye_ok = await call.invite(ring_timeout, codec)
+            if resp is None:
+                return CallResult(False, 0.0, "no-answer", bye_ok)
+            if resp.status in _REFUSALS:
+                await call.ack_refusal(dialog, resp, branch)
+                return CallResult(False, 0.0, _REFUSALS[resp.status])
+            if resp.status != 200:
+                await call.ack_refusal(dialog, resp, branch)
+                raise GoToCallError(f"call failed: {resp.status} {resp.reason}")
+
+            log.debug("answered")
+            leg = call.leg_from(dialog, resp)
+            started = time.monotonic()
+            await call.ack_2xx(leg)
+            acked = True  # dialog is up: from here the finally must hang up on any failure
+            dest = _remote_media(resp.body)
+            log.debug("streaming audio to %s:%s", *dest)
+            hung_up = await call.stream_until_done(payload, dest, repeat, pt, leg)
+            duration = time.monotonic() - started
+            if hung_up:
+                acked = False  # the server already ended the dialog
+                log.debug("remote hangup")
+                return CallResult(True, duration, "remote-hangup")
+            bye_sent = True
+            confirmed = await call.hangup(leg)
+            return CallResult(True, time.monotonic() - started, "completed", confirmed)
+        except OSError as exc:  # TimeoutError, gaierror, ConnectionError, ssl.SSLError ...
+            raise GoToSipError(f"SIP I/O failure: {type(exc).__name__}: {exc}") from exc
+        finally:
+            if acked and not bye_sent:
+                try:  # best-effort hangup so the callee isn't left off-hook; no wait for its 200
+                    await call.send(call.bye(leg))
+                except Exception:
+                    pass
+            elif call is not None and call.pending is not None:
+                try:  # still ringing (e.g. task cancelled): best-effort CANCEL so the phone stops
+                    await call.cancel_pending()
+                except Exception:
+                    pass
+            if rtp:
+                await rtp.close()
+            await tp.close()

aiogotoconnect/sip/messages.py

@@ -0,0 +1,185 @@
+"""Pure SIP message layer: build requests, parse responses, compute digest auth.
+
+No sockets, no state machine. Header structure mirrors the SIPp scenarios
+proven against GoTo production. `auth_header` args are complete header lines
+(e.g. "Proxy-Authorization: Digest ..."), so the caller picks the header name
+from the challenge type (407 -> Proxy-Authorization, 401 -> Authorization).
+"""
+
+import hashlib
+import re
+import secrets
+import uuid
+from collections.abc import Sequence
+from dataclasses import dataclass, field
+
+from aiogotoconnect.exceptions import GoToSipError
+
+CRLF = "\r\n"
+# codec -> (RTP payload type, rtpmap name)
+CODEC_PAYLOADS = {"pcma": (8, "PCMA"), "pcmu": (0, "PCMU")}
+
+
+@dataclass
+class SipResponse:
+    status: int
+    reason: str
+    headers: dict[str, str]  # keys lower-cased; repeated headers joined with ", "
+    body: str
+
+    def get(self, name: str, default: str | None = None) -> str | None:
+        return self.headers.get(name.lower(), default)
+
+    @classmethod
+    def parse(cls, raw: bytes) -> "SipResponse":
+        head, _, body = raw.decode("utf-8", errors="replace").partition(CRLF + CRLF)
+        lines = head.split(CRLF)
+        m = re.fullmatch(r"SIP/2\.0 (\d{3})(?: (.*))?", lines[0])
+        if not m:
+            raise GoToSipError(f"unparseable SIP response: {lines[0][:60]!r}")
+        headers: dict[str, str] = {}
+        for line in lines[1:]:
+            name, sep, value = line.partition(":")
+            if not sep:
+                continue  # ponytail: header line folding not supported; GoTo doesn't fold
+            key = name.strip().lower()
+            value = value.strip()
+            headers[key] = f"{headers[key]}, {value}" if key in headers else value
+        return cls(int(m.group(1)), m.group(2) or "", headers, body)
+
+
+@dataclass
+class SipDialog:
+    """Identifiers for one call. Callers bump `cseq` between transactions."""
+
+    call_id: str = field(default_factory=lambda: uuid.uuid4().hex)
+    from_tag: str = field(default_factory=lambda: secrets.token_hex(4))
+    cseq: int = 1
+
+    def branch(self) -> str:
+        return "z9hG4bK" + secrets.token_hex(8)
+
+
+def _request(method: str, request_uri: str, dialog: SipDialog, username: str, domain: str,
+             local_ip: str, local_port: int, transport: str, to_uri: str, to_tag: str = "",
+             branch: str | None = None, cseq_method: str | None = None, extra: Sequence[str] = (),
+             routes: Sequence[str] = (), body: str = "") -> bytes:
+    # Over TLS the Contact must say so, or the server sends in-dialog requests (its BYE) over UDP.
+    contact_params = ";transport=tls" if transport.upper() == "TLS" else ""
+    lines = [
+        f"{method} {request_uri} SIP/2.0",
+        f"Via: SIP/2.0/{transport} {local_ip}:{local_port};branch={branch or dialog.branch()}",
+        f"From: <sip:{username}@{domain}>;tag={dialog.from_tag}",
+        f"To: <{to_uri}>" + (f";tag={to_tag}" if to_tag else ""),
+        f"Call-ID: {dialog.call_id}",
+        f"CSeq: {dialog.cseq} {cseq_method or method}",
+        *(f"Route: {r}" for r in routes),
+        f"Contact: <sip:{username}@{local_ip}:{local_port}{contact_params}>",
+        "Max-Forwards: 70",
+        *extra,
+        f"Content-Length: {len(body.encode())}",
+    ]
+    # Header-injection guard: no CR/LF/control chars in any header line or URI.
+    if any(ord(c) < 0x20 or ord(c) == 0x7F for line in lines for c in line):
+        raise GoToSipError("control character in SIP header value")
+    return (CRLF.join(lines) + CRLF + CRLF + body).encode()
+
+
+def _check_number(to_number: str) -> str:
+    if not re.fullmatch(r"\+?[0-9*#]{1,32}", to_number):
+        raise ValueError(f"invalid destination number: {to_number!r}")
+    return to_number
+
+
+def build_register(username: str, domain: str, local_ip: str, local_port: int, dialog: SipDialog,
+                   expires: int = 60, auth_header: str | None = None, transport: str = "UDP") -> bytes:
+    return _request("REGISTER", f"sip:{domain}", dialog, username, domain, local_ip, local_port,
+                    transport, f"sip:{username}@{domain}",
+                    extra=[f"Expires: {expires}", *([auth_header] if auth_header else [])])
+
+
+def _sdp(local_ip: str, media_port: int, codec: str = "pcma") -> str:
+    pt, name = CODEC_PAYLOADS[codec]
+    return CRLF.join([
+        "v=0",
+        f"o=- 53655765 2353687637 IN IP4 {local_ip}",
+        "s=GoTo",
+        f"c=IN IP4 {local_ip}",
+        "t=0 0",
+        f"m=audio {media_port} RTP/AVP {pt} 101",
+        f"a=rtpmap:{pt} {name}/8000",
+        "a=ptime:20",
+        "a=sendrecv",
+        "a=rtpmap:101 telephone-event/8000",
+        "a=fmtp:101 0-15",
+        "",
+    ])
+
+
+def build_invite(username: str, domain: str, to_number: str, local_ip: str, local_port: int,
+                 media_port: int, dialog: SipDialog, auth_header: str | None = None,
+                 transport: str = "UDP", codec: str = "pcma") -> bytes:
+    uri = f"sip:{_check_number(to_number)}@{domain}"
+    return _request("INVITE", uri, dialog, username, domain, local_ip, local_port, transport, uri,
+                    extra=[*([auth_header] if auth_header else []), "Content-Type: application/sdp"],
+                    body=_sdp(local_ip, media_port, codec))
+
+
+def build_ack(username: str, domain: str, to_number: str, local_ip: str, local_port: int,
+              dialog: SipDialog, to_tag: str = "", routes: Sequence[str] = (),
+              branch: str | None = None, transport: str = "UDP",
+              request_uri: str | None = None) -> bytes:
+    """Pass the INVITE's `branch` when ACKing a non-2xx; omit it for a 2xx ACK (new transaction).
+    `request_uri` = the 200 OK's Contact URI for a 2xx ACK (RFC 3261 12.2.1.1); To stays the callee."""
+    uri = f"sip:{_check_number(to_number)}@{domain}"
+    return _request("ACK", request_uri or uri, dialog, username, domain, local_ip, local_port,
+                    transport, uri, to_tag=to_tag, branch=branch, routes=routes)
+
+
+def build_bye(username: str, domain: str, to_number: str, local_ip: str, local_port: int,
+              dialog: SipDialog, to_tag: str = "", routes: Sequence[str] = (),
+              transport: str = "UDP", request_uri: str | None = None) -> bytes:
+    """`request_uri` = the 200 OK's Contact URI (in-dialog requests go to the remote target)."""
+    uri = f"sip:{_check_number(to_number)}@{domain}"
+    return _request("BYE", request_uri or uri, dialog, username, domain, local_ip, local_port,
+                    transport, uri, to_tag=to_tag, routes=routes)
+
+
+def build_cancel(username: str, domain: str, to_number: str, local_ip: str, local_port: int,
+                 dialog: SipDialog, branch: str, transport: str = "UDP") -> bytes:
+    """`branch` and dialog.cseq must match the INVITE being cancelled (RFC 3261 9.1)."""
+    uri = f"sip:{_check_number(to_number)}@{domain}"
+    return _request("CANCEL", uri, dialog, username, domain, local_ip, local_port, transport, uri,
+                    branch=branch)
+
+
+def _md5(s: str) -> str:
+    return hashlib.md5(s.encode()).hexdigest()
+
+
+def digest_response(challenge: str, method: str, uri: str, username: str, password: str,
+                    cnonce: str | None = None) -> str:
+    """Answer a WWW-/Proxy-Authenticate challenge; returns "Digest username=..., ..." (value only)."""
+    params = {k.lower(): v1 or v2 for k, v1, v2 in
+              re.findall(r'(\w+)=(?:"([^"]*)"|([^\s,]*))', challenge.partition(" ")[2])}
+    algorithm = params.get("algorithm", "MD5")
+    if algorithm.upper() != "MD5":
+        raise GoToSipError(f"unsupported digest algorithm: {algorithm}")
+    if "realm" not in params or "nonce" not in params:
+        raise GoToSipError("malformed digest challenge: missing realm or nonce")
+    realm, nonce = params["realm"], params["nonce"]
+    ha1 = _md5(f"{username}:{realm}:{password}")
+    ha2 = _md5(f"{method}:{uri}")
+    fields = [f'username="{username}"', f'realm="{realm}"', f'nonce="{nonce}"', f'uri="{uri}"']
+    if "auth" in [q.strip() for q in params.get("qop", "").split(",")]:
+        cnonce = cnonce or secrets.token_hex(8)
+        nc = "00000001"
+        response = _md5(f"{ha1}:{nonce}:{nc}:{cnonce}:auth:{ha2}")
+        tail = ["qop=auth", f"nc={nc}", f'cnonce="{cnonce}"']
+    else:
+        response = _md5(f"{ha1}:{nonce}:{ha2}")
+        tail = []
+    fields += [f'response="{response}"', "algorithm=MD5", *tail]
+    if "opaque" in params:
+        fields.append(f'opaque="{params["opaque"]}"')
+    return "Digest " + ", ".join(fields)

aiogotoconnect/sip/rtp.py

@@ -0,0 +1,51 @@
+"""Paced RTP sender for G.711 payloads (160-byte frames, 20 ms apart)."""
+
+import asyncio
+import random
+import socket
+import struct
+
+FRAME_BYTES = 160
+FRAME_SECONDS = 0.02
+
+
+class RtpSender:
+    def __init__(self, local_port: int = 0) -> None:
+        # Bound synchronously so local_port is known before the INVITE/SDP is built.
+        self._sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
+        self._sock.setblocking(False)
+        self._sock.bind(("0.0.0.0", local_port))
+
+    @property
+    def local_port(self) -> int:
+        return self._sock.getsockname()[1]
+
+    async def stream(
+        self,
+        payload: bytes,
+        dest: tuple[str, int],
+        payload_type: int = 8,
+        stop: asyncio.Event | None = None,
+    ) -> None:
+        loop = asyncio.get_running_loop()
+        seq = random.randrange(0x10000)
+        timestamp = random.randrange(0x100000000)
+        ssrc = random.randrange(0x100000000)
+        start = loop.time()
+        # A trailing partial frame (< 160 bytes) is dropped, not padded: the
+        # right silence byte depends on the codec, and it is under 20 ms of audio.
+        for n in range(len(payload) // FRAME_BYTES):
+            if stop is not None and stop.is_set():
+                return
+            # Marker bit on the first packet only (talkspurt start).
+            pt_byte = payload_type | (0x80 if n == 0 else 0)
+            header = struct.pack("!BBHII", 0x80, pt_byte, seq, timestamp, ssrc)
+            frame = payload[n * FRAME_BYTES : (n + 1) * FRAME_BYTES]
+            await loop.sock_sendto(self._sock, header + frame, dest)
+            seq = (seq + 1) & 0xFFFF
+            timestamp = (timestamp + FRAME_BYTES) & 0xFFFFFFFF
+            # Drift-free pacing: sleep to an absolute target, not a fixed interval.
+            await asyncio.sleep(max(0, start + (n + 1) * FRAME_SECONDS - loop.time()))
+
+    async def close(self) -> None:
+        self._sock.close()

aiogotoconnect/sip/transport.py

@@ -0,0 +1,135 @@
+"""SIP transports: bytes in, bytes out. One datagram (UDP) or one framed message (TLS) per receive."""
+
+from __future__ import annotations
+
+import asyncio
+import re
+import ssl
+from typing import Protocol
+
+from aiogotoconnect.exceptions import GoToSipError
+
+_CONTENT_LENGTH = re.compile(rb"^(?:content-length|l)[ \t]*:[ \t]*(\d+)", re.I | re.M)
+
+
+class SipTransport(Protocol):
+    async def connect(self) -> None: ...
+    async def send(self, data: bytes) -> None: ...
+    async def receive(self, timeout: float) -> bytes: ...
+    async def close(self) -> None: ...
+
+    @property
+    def local_addr(self) -> tuple[str, int]: ...
+
+
+class _UdpProtocol(asyncio.DatagramProtocol):
+    def __init__(self) -> None:
+        self.queue: asyncio.Queue[bytes] = asyncio.Queue()
+
+    def datagram_received(self, data: bytes, addr) -> None:
+        self.queue.put_nowait(data)
+
+
+class UdpTransport:
+    def __init__(self, host: str, port: int = 5060):
+        self.host, self.port = host, port
+        self._transport: asyncio.DatagramTransport | None = None
+        self._protocol: _UdpProtocol | None = None
+
+    async def connect(self) -> None:
+        self._transport, self._protocol = await asyncio.get_running_loop().create_datagram_endpoint(
+            _UdpProtocol, remote_addr=(self.host, self.port)
+        )
+
+    async def send(self, data: bytes) -> None:
+        if self._transport is None:
+            raise GoToSipError("UDP transport not connected")
+        self._transport.sendto(data)
+
+    async def receive(self, timeout: float) -> bytes:
+        if self._protocol is None:
+            raise GoToSipError("UDP transport not connected")
+        return await asyncio.wait_for(self._protocol.queue.get(), timeout)
+
+    async def close(self) -> None:
+        if self._transport is not None:
+            self._transport.close()
+            self._transport = None
+
+    @property
+    def local_addr(self) -> tuple[str, int]:
+        if self._transport is None:
+            raise GoToSipError("UDP transport not connected")
+        return self._transport.get_extra_info("sockname")[:2]
+
+
+class TlsTransport:
+    def __init__(self, host: str, port: int = 5061, ssl_context: ssl.SSLContext | None = None):
+        self.host, self.port = host, port
+        self._ssl = ssl_context or ssl.create_default_context()
+        self._reader: asyncio.StreamReader | None = None
+        self._writer: asyncio.StreamWriter | None = None
+        # Bytes read but not yet returned; kept across calls so a receive timeout
+        # mid-message never loses data.
+        self._buf = b""
+
+    async def connect(self) -> None:
+        self._reader, self._writer = await asyncio.open_connection(
+            self.host, self.port, ssl=self._ssl, server_hostname=self.host
+        )
+
+    async def send(self, data: bytes) -> None:
+        if self._writer is None:
+            raise GoToSipError("TLS transport not connected")
+        self._writer.write(data)
+        await self._writer.drain()
+
+    def _pop_message(self) -> bytes | None:
+        """Return one complete message from the buffer, or None if more bytes are needed."""
+        end = self._buf.find(b"\r\n\r\n")
+        if end < 0:
+            return None
+        head_end = end + 4
+        m = _CONTENT_LENGTH.search(self._buf[:head_end])
+        total = head_end + (int(m.group(1)) if m else 0)
+        if len(self._buf) < total:
+            return None
+        msg, self._buf = self._buf[:total], self._buf[total:]
+        return msg
+
+    async def _read_message(self) -> bytes:
+        while (msg := self._pop_message()) is None:
+            chunk = await self._reader.read(4096)
+            if not chunk:
+                raise GoToSipError("TLS connection closed by peer")
+            self._buf += chunk
+        return msg
+
+    async def receive(self, timeout: float) -> bytes:
+        if self._reader is None:
+            raise GoToSipError("TLS transport not connected")
+        return await asyncio.wait_for(self._read_message(), timeout)
+
+    async def close(self) -> None:
+        if self._writer is not None:
+            self._writer.close()
+            try:
+                await self._writer.wait_closed()
+            except (ssl.SSLError, OSError):
+                pass
+            self._writer = self._reader = None
+
+    @property
+    def local_addr(self) -> tuple[str, int]:
+        if self._writer is None:
+            raise GoToSipError("TLS transport not connected")
+        return self._writer.get_extra_info("sockname")[:2]
+
+
+def make_transport(host: str, mode: str, port: int | None = None,
+                   ssl_context: ssl.SSLContext | None = None) -> SipTransport:
+    if mode == "udp":
+        return UdpTransport(host, port or 5060)
+    if mode == "tls":
+        return TlsTransport(host, port or 5061, ssl_context)
+    raise ValueError(f"unknown SIP transport mode: {mode!r}")

aiogotoconnect-0.2.0.dist-info/METADATA

@@ -0,0 +1,109 @@
+Metadata-Version: 2.4
+Name: aiogotoconnect
+Version: 0.2.0
+Summary: Async Python client for GoTo Connect: SMS via Messaging v2, outbound TTS voice calls via SIP
+License: MIT
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: aiohttp>=3.9
+Requires-Dist: audioop-lts>=0.2; python_version >= "3.13"
+Provides-Extra: dev
+Requires-Dist: pytest; extra == "dev"
+Requires-Dist: pytest-asyncio; extra == "dev"
+Requires-Dist: pytest-aiohttp; extra == "dev"
+Dynamic: license-file
+
+# aiogotoconnect
+
+Async Python client for GoTo Connect: send SMS via the Messaging v2 API and place outbound text-to-speech voice calls over SIP. Pure Python, asyncio only.
+
+Used by [ha-goto](https://github.com/oneofthegeeks/ha-goto), the Home Assistant integration.
+
+Formerly published as `gotoconnect` (v0.1.0); renamed so the unofficial client does not carry the bare product name. The old PyPI name stays claimed but dormant.
+
+## Install
+
+```bash
+pip install aiogotoconnect
+```
+
+Python 3.12+.
+
+## SMS
+
+```python
+import asyncio
+from aiogotoconnect import GoToOAuth, GoToMessaging
+
+async def main():
+    auth = GoToOAuth(client_id="...", client_secret="...", refresh_token="...")
+    sms = GoToMessaging(auth.async_get_access_token)
+    await sms.async_send_sms("+15551230000", ["+15551234567"], "Hello from aiogotoconnect")
+    # GoTo may rotate the refresh token: persist auth.refresh_token after calls.
+
+asyncio.run(main())
+```
+
+`GoToMessaging` takes any async callable returning a bearer token, so a host app (e.g. Home Assistant) can supply its own.
+
+## Voice calls
+
+```python
+import asyncio
+from aiogotoconnect import GoToVoice
+
+async def main():
+    voice = GoToVoice("sip-username", "sip-password")  # server="reg.jiveip.net"
+    with open("message.wav", "rb") as f:  # 16-bit PCM WAV
+        result = await voice.call_and_play("+15551234567", f.read(), ring_timeout=25, repeat=1)
+    print(result)  # CallResult(answered=True, duration=4.2, reason='completed')
+
+asyncio.run(main())
+```
+
+`reason` is one of `completed`, `remote-hangup`, `no-answer`, `busy`, `rejected`. `bye_confirmed` is `False` only when we hung up but the server never answered (or refused) our BYE, so the far side may still think the call is up; it is `True` when no BYE was needed or it was confirmed. Bad SIP credentials raise `GoToAuthError`.
+
+UDP requests are retransmitted (0.5 s, 1 s, 2 s, ...) until the server responds, and the Record-Route set from the answer is honoured on the ACK and BYE. Cancelling the `call_and_play` task hangs up (or CANCELs a ringing call) before the cancellation propagates.
+
+### Logging
+
+Everything logs to `logging.getLogger("aiogotoconnect.sip.call")` at DEBUG: SIP start-lines and status codes plus state changes, never headers or credentials. `examples/make_call.py --verbose` turns it on.
+
+## Exceptions
+
+All library errors derive from `GoToError`:
+
+- `GoToAuthError`: credentials rejected (OAuth refresh failed, SIP digest refused, SMS 401).
+- `GoToApiError`: a REST call returned a non-success status (`.status`).
+- `GoToSipError`: SIP registration/signalling failed, including network failures (timeouts, DNS, TLS errors are wrapped, never raised raw).
+  - `GoToCallError`: the call itself failed (e.g. 4xx/5xx to the INVITE, no usable SDP).
+
+Bad arguments raise plain `ValueError` before any network traffic: an invalid destination number, a WAV that is unreadable, empty or has more than two channels, or an unknown `codec`.
+
+### Create the SIP device in GoTo
+
+1. In GoTo Connect Admin, go to **Devices** -> **Add Device** -> **SIP Device**.
+2. Copy the **SIP Username**, **Password**, and the device's **SIP Server** and
+   **Outbound Proxy**. The registrar is typically `reg.jiveip.net` (the library's
+   default); the outbound proxy is account-specific (e.g.
+   `<account>.jive.rtcfront.net`) — pass it as `proxy=`. Calls proven live against
+   GoTo used both.
+
+### Transport
+
+UDP (port 5060) is the default. TLS (port 5061) is supported: `GoToVoice(..., transport="tls")`. TLS verifies the server certificate with the system CAs; pass `ssl_context=` to override. An outbound `proxy=` host, if set, is the connection target while `server` stays in the SIP URIs.
+
+### Live smoke test
+
+```bash
+GOTO_SIP_USERNAME=... GOTO_SIP_PASSWORD=... python examples/make_call.py --to +15551234567 --wav message.wav --transport tls
+```
+
+## Development
+
+```bash
+python3 -m venv .venv
+.venv/bin/pip install -e '.[dev]'
+.venv/bin/python -m pytest
+```

aiogotoconnect-0.2.0.dist-info/RECORD

@@ -0,0 +1,16 @@
+aiogotoconnect/__init__.py,sha256=I7mw4br-wNp32_s5MnIHLoXHCyEbEehREc2y4kjlgtA,505
+aiogotoconnect/auth.py,sha256=Ouo5Ipcm0ZrXRludMEt3FB4z6Ridx4x1tMc_2LrF6Ew,3494
+aiogotoconnect/exceptions.py,sha256=muMP_hB_E3xnzd_TNK2no_447u0FAtmZGM69iZmjdGQ,614
+aiogotoconnect/messaging.py,sha256=4gKHAPRZXkIYiXi820Ih6eAyhN-eFQ3JoYj29tXkCew,2401
+aiogotoconnect/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+aiogotoconnect/sip/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+aiogotoconnect/sip/audio.py,sha256=N-3G1-fZQ_I6cQu2N7FyOUSztHa0LLq8-EjRY55IGoM,2019
+aiogotoconnect/sip/call.py,sha256=9GxxxbvGc3bu2CZypz7wkZVECkfwfbKIvqwQ3q1Gmec,16686
+aiogotoconnect/sip/messages.py,sha256=Hf3OJx_gKDQ4fD9TOO597TtMYw735sY-VxgJhlpwKm8,8503
+aiogotoconnect/sip/rtp.py,sha256=stcwaqxu8XvkK2bkPk4oLUIaVcmfb3hazOcMfCbdpRQ,1932
+aiogotoconnect/sip/transport.py,sha256=UuquKdtw69IkoMxbBk4G1JgF-ufxGSSelXshzl2muE8,4846
+aiogotoconnect-0.2.0.dist-info/licenses/LICENSE,sha256=_WgsbPtGW6Ljl9O-bBXsB1CXXvLTnHr5A0dJvvAh6bA,1070
+aiogotoconnect-0.2.0.dist-info/METADATA,sha256=c_Ep975j3fn9qJIkmfJLyiCSiw1R-6Izv_9LJu26S1I,4484
+aiogotoconnect-0.2.0.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+aiogotoconnect-0.2.0.dist-info/top_level.txt,sha256=XTlXped6I6vZu_E-uyNF1Ck2dApdrOUhgoXaZ6KWzec,15
+aiogotoconnect-0.2.0.dist-info/RECORD,,

aiogotoconnect-0.2.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (84.0.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

aiogotoconnect-0.2.0.dist-info/licenses/LICENSE

@@ -0,0 +1,18 @@
+MIT License
+
+Copyright (c) 2026 Oneofthegeeks
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and
+associated documentation files (the "Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the
+following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial
+portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT
+LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO
+EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+USE OR OTHER DEALINGS IN THE SOFTWARE.

aiogotoconnect-0.2.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+aiogotoconnect