Bump Python min version to 3.11

Author: EvieePy

pyproject.toml

@@ -8,13 +8,12 @@ authors = [{ name = "PythonistaGuild" }]
 dynamic = ["dependencies", "version"]
 description = "A fully asynchronous and modern Python wrapper around the Twitch API."
 readme = "README.md"
-requires-python = ">=3.10"
+requires-python = ">=3.11"
 classifiers = [
     "License :: OSI Approved :: MIT License",
     "Intended Audience :: Developers",
     "Natural Language :: English",
     "Operating System :: OS Independent",
-    "Programming Language :: Python :: 3.10",
     "Programming Language :: Python :: 3.11",
     "Programming Language :: Python :: 3.12",
     "Topic :: Internet",
@@ -104,4 +103,4 @@ useLibraryCodeForTypes = true
 typeCheckingMode = "strict"
 reportImportCycles = false
 reportPrivateUsage = false
-pythonVersion = "3.10"
+pythonVersion = "3.11"

requirements.txt

@@ -1,4 +1 @@
-aiohttp>=3.9.1,<4
-typing_extensions>=4.1.0
-backports.datetime_fromisoformat>=2.0.1 ; python_version < "3.11"
-async-timeout ; python_version < "3.11"
+aiohttp>=3.9.1,<4

twitchio/client.py

@@ -27,7 +27,7 @@
 import asyncio
 import logging
 from collections import defaultdict
-from typing import TYPE_CHECKING, Any, Literal
+from typing import TYPE_CHECKING, Any, Literal, Self, Unpack
 
 from .authentication import ManagedHTTPClient, Scopes
 from .conduits import Conduit, ConduitPool
@@ -48,7 +48,6 @@
     from collections.abc import Awaitable, Callable, Coroutine
 
     import aiohttp
-    from typing_extensions import Self, Unpack
 
     from .authentication import ClientCredentialsPayload, ValidateTokenPayload
     from .http import HTTPAsyncIterator

twitchio/conduits/pool.py

@@ -26,24 +26,22 @@
 
 import logging
 from types import MappingProxyType
-from typing import TYPE_CHECKING
+from typing import TYPE_CHECKING, Self
 
 from twitchio.eventsub.enums import ShardStatus, TransportMethod
 from twitchio.types_.conduits import ShardData
 
 from ..utils import parse_timestamp
-from .websockets import Websocket
 
 
 if TYPE_CHECKING:
     import datetime
     from collections.abc import Mapping
 
-    from typing_extensions import Self
-
     from ..client import Client
     from ..ext.commands import Bot
     from ..types_.conduits import ConduitData, ShardData, ShardTransport
+    from .websockets import Websocket
 
 
 logger: logging.Logger = logging.getLogger(__name__)
@@ -136,40 +134,3 @@ def __init__(self, *, client: Client | Bot) -> None:
     @property
     def conduits(self) -> Mapping[str, Conduit]:
         return MappingProxyType(self._conduits)  # thanks lilly
-
-    async def create_conduit(self, shard_count: int, buffer: bool = False) -> list[Conduit]:
-        buffer_: int = min(50, max(int(shard_count * 0.1), 1)) if buffer else shard_count
-
-        real_count: int = min(shard_count + buffer_, 20_000)
-        if shard_count > 20_000:
-            logger.warning('"shard_count" parameter for "create_conduit" exceeds 20,000. Reducing count to 20,000.')
-
-        # TODO: Handle 429 for 5 Conduits...
-        conduits: list[Conduit] = await self._client._create_conduit(real_count)
-        for conduit in conduits:
-            self._conduits[conduit.id] = conduit
-
-        return conduits
-
-    async def fetch_conduits(self) -> Mapping[str, Conduit]:
-        data = await self._client._http.get_conduits()
-        mapping: dict[str, Conduit] = {}
-
-        for payload in data["data"]:
-            conduit = Conduit(data=payload, pool=self)
-            mapping[conduit.id] = conduit
-
-        self._conduits = mapping
-        return MappingProxyType(mapping)
-
-    async def test(self) -> None:
-        await self.fetch_conduits()
-
-        for id_, conduit in self._conduits.items():
-            shards: list[Shard] = await (await self._client._http.get_conduit_shards(id_))
-            start: int = len(shards)
-
-            for n in range(start, conduit._shard_count):
-                websocket: Websocket = Websocket(id=n)
-                await websocket.connect()
-                break

twitchio/conduits/websockets.py

@@ -40,7 +40,7 @@
     WelcomeMessage,
     WelcomePayload,
 )
-from ..utils import _from_json, a_timeout  # type: ignore
+from ..utils import _from_json  # type: ignore
 
 
 logger: logging.Logger = logging.getLogger(__name__)
@@ -82,23 +82,24 @@ def connected(self) -> bool:
     def id(self) -> str:
         return self._id
 
-    async def connect(self) -> None:
-        url: str = f"{WSS}?keepalive_timeout_seconds={self._keep_alive_timeout}"
+    async def connect(self, *, reconnect_url: str | None = None) -> None:
+        url: str = reconnect_url or f"{WSS}?keepalive_timeout_seconds={self._keep_alive_timeout}"
 
         if self.connected:
-            logger.warning("Trying to connect to an already running conduit websocket with ID: %s.", self._session_id)
+            logger.warning("Trying to connect to an already running eventsub websocket with ID: %s.", self._session_id)
             return
 
         if not self._session:
             self._session = aiohttp.ClientSession()
 
         self._ready.clear()
-
         self._socket = await self._session.ws_connect(url, heartbeat=15.0)
-        self._listen_task = asyncio.create_task(self._listen())
+
+        if not self._listen_task:
+            self._listen_task = asyncio.create_task(self._listen())
 
         try:
-            async with a_timeout(10):
+            async with asyncio.timeout(10):
                 await self._ready.wait()
         except TimeoutError:
             raise WebsocketTimeoutException
@@ -124,22 +125,22 @@ async def _listen(self) -> None:
             type_: aiohttp.WSMsgType = message.type
             if type_ in (aiohttp.WSMsgType.CLOSED, aiohttp.WSMsgType.CLOSE, aiohttp.WSMsgType.CLOSING):
                 logger.debug(
-                    "Received close message [%s] on conduit websocket: %s",
+                    "Received close message [%s] on eventsub websocket: %s",
                     self._socket.close_code,
                     self._session_id,
                 )
                 return await self.close()
 
             if type_ is not aiohttp.WSMsgType.TEXT:
-                logger.debug("Received unknown message from conduit websocket: %s", self._session_id)
+                logger.debug("Received unknown message from eventsub websocket: %s", self._session_id)
                 continue
 
             self._last_keepalive = datetime.datetime.now()
 
             try:
                 data: WebsocketMessages = cast(WebsocketMessages, _from_json(message.data))
             except Exception:
-                logger.warning("Unable to parse JSON in conduit websocket: %s", self._session_id)
+                logger.warning("Unable to parse JSON in eventsub websocket: %s", self._session_id)
                 continue
 
             metadata: MetaData = data["metadata"]
@@ -150,31 +151,31 @@ async def _listen(self) -> None:
                 await self._process_welcome(welcome_data)
 
             elif message_type == "session_reconnect":
-                logger.debug('Received "session_reconnect" message from conduit websocket: %s', self._session_id)
+                logger.debug('Received "session_reconnect" message from eventsub websocket: %s', self._session_id)
                 reconnect_data: ReconnectMessage = cast(ReconnectMessage, data)
                 await self._process_reconnect(reconnect_data)
 
             elif message_type == "session_keepalive":
-                logger.debug('Received "session_keepalive" message from conduit websocket: %s', self._session_id)
+                logger.debug('Received "session_keepalive" message from eventsub websocket: %s', self._session_id)
 
             elif message_type == "revocation":
-                logger.debug('Received "revocation" message from conduit websocket: %s', self._session_id)
+                logger.debug('Received "revocation" message from eventsub websocket: %s', self._session_id)
 
                 revocation_data: RevocationMessage = cast(RevocationMessage, data)
                 await self._process_revocation(revocation_data)
 
             elif message_type == "notification":
-                logger.debug('Received "notification" message from conduit websocket: %s', self._session_id)
+                logger.debug('Received "notification" message from eventsub websocket: %s', self._session_id)
 
                 notification_data: NotificationMessage = cast(NotificationMessage, data)
                 await self._process_notification(notification_data)
 
             else:
-                logger.warning("Received an unknown message type in conduit websocket: %s", self._session_id)
+                logger.warning("Received an unknown message type in eventsub websocket: %s", self._session_id)
 
     async def _process_keepalive(self) -> None:
         assert self._last_keepalive
-        logger.debug("Started keep_alive task on conduit websocket: %s", self._session_id)
+        logger.debug("Started keep_alive task on eventsub websocket: %s", self._session_id)
 
         while True:
             await asyncio.sleep(self._keep_alive_timeout)
@@ -188,9 +189,11 @@ async def _process_welcome(self, data: WelcomeMessage) -> None:
         self._session_id = payload["session"]["id"]
         self._ready.set()
 
-        logger.debug('Received "session_welcome" message from conduit websocket: %s', self._session_id)
+        logger.debug('Received "session_welcome" message from eventsub websocket: %s', self._session_id)
 
-    async def _process_reconnect(self, data: ReconnectMessage) -> None: ...
+    async def _process_reconnect(self, data: ReconnectMessage) -> None:
+        logger.info("Attempting to reconnect eventsub websocket: '%s'", self._id)
+        await self.connect(reconnect_url=data["payload"]["session"]["reconnect_url"])
 
     async def _process_revocation(self, data: RevocationMessage) -> None: ...
 
@@ -201,18 +204,18 @@ async def close(self) -> None:
             try:
                 await self._socket.close()
             except Exception:
-                ...
+                pass
 
         if self._session:
             try:
                 await self._session.close()
             except Exception:
-                ...
+                pass
 
         if self._listen_task:
             try:
                 self._listen_task.cancel()
             except Exception:
-                ...
+                pass
 
-        logger.debug("Successfully closed conduit websocket: %s", self._session_id)
+        logger.debug("Successfully closed eventsub websocket: %s", self._session_id)

twitchio/eventsub/payloads.py

@@ -24,12 +24,10 @@
 
 from __future__ import annotations
 
-from typing import TYPE_CHECKING, Any, ClassVar, Literal
+from typing import TYPE_CHECKING, Any, ClassVar, Literal, Unpack
 
 
 if TYPE_CHECKING:
-    from typing_extensions import Unpack
-
     from ..types_.conduits import Condition
 
 

twitchio/http.py

@@ -31,7 +31,7 @@
 import urllib.parse
 from collections import deque
 from collections.abc import AsyncIterator, Awaitable, Callable
-from typing import TYPE_CHECKING, Any, ClassVar, Generic, Literal, TypeAlias, TypeVar
+from typing import TYPE_CHECKING, Any, ClassVar, Generic, Literal, Self, TypeAlias, TypeVar, Unpack
 
 import aiohttp
 
@@ -63,8 +63,6 @@
 if TYPE_CHECKING:
     from collections.abc import Generator, Sequence
 
-    from typing_extensions import Self, Unpack
-
     from .assets import Asset
     from .models.channel_points import CustomReward
     from .models.moderation import AutomodCheckMessage, AutomodSettings
@@ -1938,7 +1936,7 @@ async def post_channel_stream_schedule_segment(
         _start_time = (
             start_time.isoformat()
             if start_time.tzinfo is not None
-            else start_time.replace(tzinfo=datetime.timezone.utc).isoformat()
+            else start_time.replace(tzinfo=datetime.UTC).isoformat()
         )
 
         data = {
@@ -1976,7 +1974,7 @@ async def patch_channel_stream_schedule_segment(
             _start_time = (
                 start_time.isoformat()
                 if start_time.tzinfo is not None
-                else start_time.replace(tzinfo=datetime.timezone.utc).isoformat()
+                else start_time.replace(tzinfo=datetime.UTC).isoformat()
             )
             data["start_time"] = _start_time
         if category_id is not None:

twitchio/types_/conduits.py

@@ -22,9 +22,7 @@
 SOFTWARE.
 """
 
-from typing import Any, Literal, TypeAlias, TypedDict
-
-from typing_extensions import Never, NotRequired
+from typing import Any, Literal, Never, NotRequired, TypeAlias, TypedDict
 
 
 class ShardTransport(TypedDict):

twitchio/types_/responses.py

@@ -24,8 +24,6 @@
 
 from typing import Any, Generic, Literal, TypeAlias, TypedDict, TypeVar
 
-from typing_extensions import TypedDict as TypedDictExt
-
 from .conduits import ConduitData, ShardData
 
 
@@ -87,7 +85,7 @@
 T = TypeVar("T")
 
 
-class Payload(TypedDictExt, Generic[T]):
+class Payload(TypedDict, Generic[T]):
     data: list[T]
 
 

twitchio/user.py

@@ -68,7 +68,7 @@
     )
     from .models.polls import Poll
     from .models.predictions import Prediction
-    from .models.schedule import Schedule
+    from .models.schedule import Schedule  # noqa: TCH004
     from .models.streams import Stream, StreamMarker, VideoMarkers
     from .models.subscriptions import BroadcasterSubscriptions, UserSubscription
     from .models.teams import ChannelTeam

twitchio/utils.py

@@ -7,26 +7,17 @@
 import pathlib
 import struct
 import sys
-from datetime import datetime, timezone
-from typing import TYPE_CHECKING, Any
+from datetime import UTC, datetime
+from typing import TYPE_CHECKING, Any, Self
 from urllib.parse import quote
 
 
 if TYPE_CHECKING:
     from collections.abc import Generator
 
-    from typing_extensions import Self
-
     from .types_.colours import Colours
 
 
-try:
-    from backports.datetime_fromisoformat import MonkeyPatch  # type: ignore
-
-    MonkeyPatch.patch_fromisoformat()  # type: ignore
-except ImportError:
-    pass
-
 try:
     import orjson  # type: ignore
 
@@ -35,15 +26,6 @@
     _from_json = json.loads
 
 
-try:
-    from asyncio.timeouts import _timeout  # type: ignore
-except ImportError:
-    from async_timeout import timeout as _timeout  # type: ignore
-
-
-a_timeout = _timeout  # type: ignore
-
-
 __all__ = ("_from_json", "setup_logging", "ColourFormatter", "ColorFormatter", "parse_timestamp", "url_encode_datetime")
 
 
@@ -436,6 +418,6 @@ def url_encode_datetime(dt: datetime) -> str:
     str
         The URL encoded parsed datetime object.
     """
-    formatted_dt = dt.replace(tzinfo=timezone.utc).isoformat() if dt.tzinfo is None else dt.isoformat()
+    formatted_dt = dt.replace(tzinfo=UTC).isoformat() if dt.tzinfo is None else dt.isoformat()
 
     return quote(formatted_dt)