PyPlumIO 0.5.5__py3-none-any.whl → 0.5.7__py3-none-any.whl

pyplumio/frames/__init__.py

@@ -25,7 +25,7 @@ ECONET_VERSION: Final = 5
 struct_header = struct.Struct("<BH4B")
 
 if TYPE_CHECKING:
-    from pyplumio.devices import Addressable
+    from pyplumio.devices import AddressableDevice
 
 
 def bcc(data: bytes) -> int:
@@ -82,23 +82,22 @@ class Frame(ABC):
         "sender",
         "sender_type",
         "econet_version",
-        "frame_type",
         "_message",
         "_data",
     )
 
-    recipient: DeviceType | Addressable | int
-    sender: DeviceType | Addressable | int
+    recipient: DeviceType | AddressableDevice | int
+    sender: DeviceType | AddressableDevice | int
     sender_type: int
     econet_version: int
-    frame_type: ClassVar[int]
+    frame_type: ClassVar[FrameType | int]
     _message: bytearray | None
     _data: EventDataType | None
 
     def __init__(
         self,
-        recipient: DeviceType | Addressable | int = DeviceType.ALL,
-        sender: DeviceType | Addressable | int = DeviceType.ECONET,
+        recipient: DeviceType | AddressableDevice | int = DeviceType.ALL,
+        sender: DeviceType | AddressableDevice | int = DeviceType.ECONET,
         sender_type: int = ECONET_TYPE,
         econet_version: int = ECONET_VERSION,
         message: bytearray | None = None,
@@ -244,6 +243,8 @@ class Frame(ABC):
 class Request(Frame):
     """Represents a request."""
 
+    __slots__ = ()
+
     def create_message(self, data: EventDataType) -> bytearray:
         """Create a frame message."""
         return bytearray()
@@ -260,6 +261,8 @@ class Request(Frame):
 class Response(Frame):
     """Represents a response."""
 
+    __slots__ = ()
+
     def create_message(self, data: EventDataType) -> bytearray:
         """Create a frame message."""
         return bytearray()
@@ -271,3 +274,5 @@ class Response(Frame):
 
 class Message(Response):
     """Represents a message."""
+
+    __slots__ = ()

pyplumio/frames/messages.py

@@ -34,7 +34,9 @@ from pyplumio.structures.thermostat_sensors import ThermostatSensorsStructure
 class RegulatorDataMessage(Message):
     """Represents a regulator data message."""
 
-    frame_type: ClassVar[int] = FrameType.MESSAGE_REGULATOR_DATA
+    __slots__ = ()
+
+    frame_type: ClassVar[FrameType | int] = FrameType.MESSAGE_REGULATOR_DATA
 
     def decode_message(self, message: bytearray) -> EventDataType:
         """Decode a frame message."""
@@ -45,7 +47,9 @@ class RegulatorDataMessage(Message):
 class SensorDataMessage(Message):
     """Represents a sensor data message."""
 
-    frame_type: ClassVar[int] = FrameType.MESSAGE_SENSOR_DATA
+    __slots__ = ()
+
+    frame_type: ClassVar[FrameType | int] = FrameType.MESSAGE_SENSOR_DATA
 
     def decode_message(self, message: bytearray) -> EventDataType:
         """Decode a frame message."""

pyplumio/frames/requests.py

@@ -22,7 +22,9 @@ from pyplumio.structures.schedules import SchedulesStructure
 class ProgramVersionRequest(Request):
     """Represents a program version request."""
 
-    frame_type: ClassVar[int] = FrameType.REQUEST_PROGRAM_VERSION
+    __slots__ = ()
+
+    frame_type: ClassVar[FrameType | int] = FrameType.REQUEST_PROGRAM_VERSION
 
     def response(self, **kwargs) -> Response | None:
         """Return a response frame."""
@@ -32,7 +34,9 @@ class ProgramVersionRequest(Request):
 class CheckDeviceRequest(Request):
     """Represents a check device request."""
 
-    frame_type: ClassVar[int] = FrameType.REQUEST_CHECK_DEVICE
+    __slots__ = ()
+
+    frame_type: ClassVar[FrameType | int] = FrameType.REQUEST_CHECK_DEVICE
 
     def response(self, **kwargs) -> Response | None:
         """Return a response frame."""
@@ -42,13 +46,17 @@ class CheckDeviceRequest(Request):
 class UIDRequest(Request):
     """Represents an UID request."""
 
-    frame_type: ClassVar[int] = FrameType.REQUEST_UID
+    __slots__ = ()
+
+    frame_type: ClassVar[FrameType | int] = FrameType.REQUEST_UID
 
 
 class PasswordRequest(Request):
     """Represents a password request."""
 
-    frame_type: ClassVar[int] = FrameType.REQUEST_PASSWORD
+    __slots__ = ()
+
+    frame_type: ClassVar[FrameType | int] = FrameType.REQUEST_PASSWORD
 
 
 class EcomaxParametersRequest(Request):
@@ -57,7 +65,9 @@ class EcomaxParametersRequest(Request):
     Contains number of parameters and index of the first parameter.
     """
 
-    frame_type: ClassVar[int] = FrameType.REQUEST_ECOMAX_PARAMETERS
+    __slots__ = ()
+
+    frame_type: ClassVar[FrameType | int] = FrameType.REQUEST_ECOMAX_PARAMETERS
 
     def create_message(self, data: EventDataType) -> bytearray:
         """Create a frame message."""
@@ -71,7 +81,9 @@ class MixerParametersRequest(Request):
     parameter.
     """
 
-    frame_type: ClassVar[int] = FrameType.REQUEST_MIXER_PARAMETERS
+    __slots__ = ()
+
+    frame_type: ClassVar[FrameType | int] = FrameType.REQUEST_MIXER_PARAMETERS
 
     def create_message(self, data: EventDataType) -> bytearray:
         """Create a frame message."""
@@ -85,17 +97,21 @@ class ThermostatParametersRequest(Request):
     parameter.
     """
 
-    frame_type: ClassVar[int] = FrameType.REQUEST_THERMOSTAT_PARAMETERS
+    __slots__ = ()
+
+    frame_type: ClassVar[FrameType | int] = FrameType.REQUEST_THERMOSTAT_PARAMETERS
 
     def create_message(self, data: EventDataType) -> bytearray:
         """Create a frame message."""
         return bytearray([data.get(ATTR_COUNT, 255), data.get(ATTR_INDEX, 0)])
 
 
-class DataSchemaRequest(Request):
-    """Represents data schema request."""
+class RegulatorDataSchemaRequest(Request):
+    """Represents regulator data schema request."""
 
-    frame_type: ClassVar[int] = FrameType.REQUEST_DATA_SCHEMA
+    __slots__ = ()
+
+    frame_type: ClassVar[FrameType | int] = FrameType.REQUEST_REGULATOR_DATA_SCHEMA
 
 
 class SetEcomaxParameterRequest(Request):
@@ -104,7 +120,9 @@ class SetEcomaxParameterRequest(Request):
     Contains parameter index and new value.
     """
 
-    frame_type: ClassVar[int] = FrameType.REQUEST_SET_ECOMAX_PARAMETER
+    __slots__ = ()
+
+    frame_type: ClassVar[FrameType | int] = FrameType.REQUEST_SET_ECOMAX_PARAMETER
 
     def create_message(self, data: EventDataType) -> bytearray:
         """Create a frame message."""
@@ -120,7 +138,9 @@ class SetMixerParameterRequest(Request):
     Contains parameter index, new value and mixer index.
     """
 
-    frame_type: ClassVar[int] = FrameType.REQUEST_SET_MIXER_PARAMETER
+    __slots__ = ()
+
+    frame_type: ClassVar[FrameType | int] = FrameType.REQUEST_SET_MIXER_PARAMETER
 
     def create_message(self, data: EventDataType) -> bytearray:
         """Create a frame message."""
@@ -146,7 +166,9 @@ class SetThermostatParameterRequest(Request):
     and for the third thermostat is 24 (2 * 12).
     """
 
-    frame_type: ClassVar[int] = FrameType.REQUEST_SET_THERMOSTAT_PARAMETER
+    __slots__ = ()
+
+    frame_type: ClassVar[FrameType | int] = FrameType.REQUEST_SET_THERMOSTAT_PARAMETER
 
     def create_message(self, data: EventDataType) -> bytearray:
         """Create a frame message."""
@@ -167,7 +189,9 @@ class EcomaxControlRequest(Request):
     be turned off, 1 - means that it should be turned on.
     """
 
-    frame_type: ClassVar[int] = FrameType.REQUEST_ECOMAX_CONTROL
+    __slots__ = ()
+
+    frame_type: ClassVar[FrameType | int] = FrameType.REQUEST_ECOMAX_CONTROL
 
     def create_message(self, data: EventDataType) -> bytearray:
         """Create a frame message."""
@@ -184,7 +208,9 @@ class StartMasterRequest(Request):
     periodic messages.
     """
 
-    frame_type: ClassVar[int] = FrameType.REQUEST_START_MASTER
+    __slots__ = ()
+
+    frame_type: ClassVar[FrameType | int] = FrameType.REQUEST_START_MASTER
 
 
 class StopMasterRequest(Request):
@@ -194,7 +220,9 @@ class StopMasterRequest(Request):
     periodic messages.
     """
 
-    frame_type: ClassVar[int] = FrameType.REQUEST_STOP_MASTER
+    __slots__ = ()
+
+    frame_type: ClassVar[FrameType | int] = FrameType.REQUEST_STOP_MASTER
 
 
 class AlertsRequest(Request):
@@ -204,7 +232,9 @@ class AlertsRequest(Request):
     alert.
     """
 
-    frame_type: ClassVar[int] = FrameType.REQUEST_ALERTS
+    __slots__ = ()
+
+    frame_type: ClassVar[FrameType | int] = FrameType.REQUEST_ALERTS
 
     def create_message(self, data: EventDataType) -> bytearray:
         """Create a frame message."""
@@ -215,13 +245,17 @@ class AlertsRequest(Request):
 class SchedulesRequest(Request):
     """Represents a schedules request."""
 
-    frame_type: ClassVar[int] = FrameType.REQUEST_SCHEDULES
+    __slots__ = ()
+
+    frame_type: ClassVar[FrameType | int] = FrameType.REQUEST_SCHEDULES
 
 
 class SetScheduleRequest(Request):
     """Represents a request to set a schedule."""
 
-    frame_type: ClassVar[int] = FrameType.REQUEST_SET_SCHEDULE
+    __slots__ = ()
+
+    frame_type: ClassVar[FrameType | int] = FrameType.REQUEST_SET_SCHEDULE
 
     def create_message(self, data: EventDataType) -> bytearray:
         """Create a frame message."""

pyplumio/frames/responses.py

@@ -7,12 +7,12 @@ from pyplumio.const import ATTR_PASSWORD, FrameType
 from pyplumio.frames import Response
 from pyplumio.helpers.typing import EventDataType
 from pyplumio.structures.alerts import AlertsStructure
-from pyplumio.structures.data_schema import DataSchemaStructure
 from pyplumio.structures.ecomax_parameters import EcomaxParametersStructure
 from pyplumio.structures.mixer_parameters import MixerParametersStructure
 from pyplumio.structures.network_info import NetworkInfoStructure
 from pyplumio.structures.product_info import ProductInfoStructure
 from pyplumio.structures.program_version import ProgramVersionStructure
+from pyplumio.structures.regulator_data_schema import RegulatorDataSchemaStructure
 from pyplumio.structures.schedules import SchedulesStructure
 from pyplumio.structures.thermostat_parameters import ThermostatParametersStructure
 
@@ -23,7 +23,9 @@ class ProgramVersionResponse(Response):
     Contains software version info.
     """
 
-    frame_type: ClassVar[int] = FrameType.RESPONSE_PROGRAM_VERSION
+    __slots__ = ()
+
+    frame_type: ClassVar[FrameType | int] = FrameType.RESPONSE_PROGRAM_VERSION
 
     def create_message(self, data: EventDataType) -> bytearray:
         """Create a frame message."""
@@ -40,7 +42,9 @@ class DeviceAvailableResponse(Response):
     Contains network information and status.
     """
 
-    frame_type: ClassVar[int] = FrameType.RESPONSE_DEVICE_AVAILABLE
+    __slots__ = ()
+
+    frame_type: ClassVar[FrameType | int] = FrameType.RESPONSE_DEVICE_AVAILABLE
 
     def create_message(self, data: EventDataType) -> bytearray:
         """Create a frame message."""
@@ -57,7 +61,9 @@ class UIDResponse(Response):
     Contains product info and product UID.
     """
 
-    frame_type: ClassVar[int] = FrameType.RESPONSE_UID
+    __slots__ = ()
+
+    frame_type: ClassVar[FrameType | int] = FrameType.RESPONSE_UID
 
     def create_message(self, data: EventDataType) -> bytearray:
         """Create a frame message."""
@@ -74,7 +80,9 @@ class PasswordResponse(Response):
     Contains device service password as plaintext.
     """
 
-    frame_type: ClassVar[int] = FrameType.RESPONSE_PASSWORD
+    __slots__ = ()
+
+    frame_type: ClassVar[FrameType | int] = FrameType.RESPONSE_PASSWORD
 
     def decode_message(self, message: bytearray) -> EventDataType:
         """Decode a frame message."""
@@ -88,7 +96,9 @@ class EcomaxParametersResponse(Response):
     Contains editable ecoMAX parameters.
     """
 
-    frame_type: ClassVar[int] = FrameType.RESPONSE_ECOMAX_PARAMETERS
+    __slots__ = ()
+
+    frame_type: ClassVar[FrameType | int] = FrameType.RESPONSE_ECOMAX_PARAMETERS
 
     def decode_message(self, message: bytearray) -> EventDataType:
         """Decode a frame message."""
@@ -101,7 +111,9 @@ class MixerParametersResponse(Response):
     Contains editable mixer parameters.
     """
 
-    frame_type: ClassVar[int] = FrameType.RESPONSE_MIXER_PARAMETERS
+    __slots__ = ()
+
+    frame_type: ClassVar[FrameType | int] = FrameType.RESPONSE_MIXER_PARAMETERS
 
     def decode_message(self, message: bytearray) -> EventDataType:
         """Decode a frame message."""
@@ -114,25 +126,29 @@ class ThermostatParametersResponse(Response):
     Contains editable thermostat parameters.
     """
 
-    frame_type: ClassVar[int] = FrameType.RESPONSE_THERMOSTAT_PARAMETERS
+    __slots__ = ()
+
+    frame_type: ClassVar[FrameType | int] = FrameType.RESPONSE_THERMOSTAT_PARAMETERS
 
     def decode_message(self, message: bytearray) -> EventDataType:
         """Decode a frame message."""
         return ThermostatParametersStructure(self).decode(message)[0]
 
 
-class DataSchemaResponse(Response):
-    """Represents a data schema response.
+class RegulatorDataSchemaResponse(Response):
+    """Represents a regulator data schema response.
 
     Contains schema, that describes structure of ecoMAX regulator data
     message.
     """
 
-    frame_type: ClassVar[int] = FrameType.RESPONSE_DATA_SCHEMA
+    __slots__ = ()
+
+    frame_type: ClassVar[FrameType | int] = FrameType.RESPONSE_REGULATOR_DATA_SCHEMA
 
     def decode_message(self, message: bytearray) -> EventDataType:
         """Decode a frame message."""
-        return DataSchemaStructure(self).decode(message)[0]
+        return RegulatorDataSchemaStructure(self).decode(message)[0]
 
 
 class SetEcomaxParameterResponse(Response):
@@ -142,7 +158,9 @@ class SetEcomaxParameterResponse(Response):
     successfully set.
     """
 
-    frame_type: ClassVar[int] = FrameType.RESPONSE_SET_ECOMAX_PARAMETER
+    __slots__ = ()
+
+    frame_type: ClassVar[FrameType | int] = FrameType.RESPONSE_SET_ECOMAX_PARAMETER
 
 
 class SetMixerParameterResponse(Response):
@@ -152,7 +170,9 @@ class SetMixerParameterResponse(Response):
     successfully set.
     """
 
-    frame_type: ClassVar[int] = FrameType.RESPONSE_SET_MIXER_PARAMETER
+    __slots__ = ()
+
+    frame_type: ClassVar[FrameType | int] = FrameType.RESPONSE_SET_MIXER_PARAMETER
 
 
 class SetThermostatParameterResponse(Response):
@@ -162,7 +182,9 @@ class SetThermostatParameterResponse(Response):
     successfully set.
     """
 
-    frame_type: ClassVar[int] = FrameType.RESPONSE_SET_THERMOSTAT_PARAMETER
+    __slots__ = ()
+
+    frame_type: ClassVar[FrameType | int] = FrameType.RESPONSE_SET_THERMOSTAT_PARAMETER
 
 
 class EcomaxControlResponse(Response):
@@ -172,13 +194,17 @@ class EcomaxControlResponse(Response):
     successfully processed.
     """
 
-    frame_type: ClassVar[int] = FrameType.RESPONSE_ECOMAX_CONTROL
+    __slots__ = ()
+
+    frame_type: ClassVar[FrameType | int] = FrameType.RESPONSE_ECOMAX_CONTROL
 
 
 class AlertsResponse(Response):
     """Represents response to a device alerts request."""
 
-    frame_type: ClassVar[int] = FrameType.RESPONSE_ALERTS
+    __slots__ = ()
+
+    frame_type: ClassVar[FrameType | int] = FrameType.RESPONSE_ALERTS
 
     def decode_message(self, message: bytearray) -> EventDataType:
         """Decode a frame message."""
@@ -188,7 +214,9 @@ class AlertsResponse(Response):
 class SchedulesResponse(Response):
     """Represents response to a device schedules request."""
 
-    frame_type: ClassVar[int] = FrameType.RESPONSE_SCHEDULES
+    __slots__ = ()
+
+    frame_type: ClassVar[FrameType | int] = FrameType.RESPONSE_SCHEDULES
 
     def decode_message(self, message: bytearray) -> EventDataType:
         """Decode a frame message."""

pyplumio/helpers/data_types.py

@@ -68,6 +68,8 @@ class DataType(ABC):
 class Undefined(DataType):
     """Represents an undefined."""
 
+    __slots__ = ()
+
     def pack(self) -> bytes:
         """Pack the data."""
         return bytes()
@@ -122,6 +124,8 @@ class BitArray(DataType):
 class IPv4(DataType):
     """Represents an IPv4 address."""
 
+    __slots__ = ()
+
     @property
     def size(self) -> int:
         """A data size."""
@@ -139,6 +143,8 @@ class IPv4(DataType):
 class IPv6(DataType):
     """Represents an IPv6 address."""
 
+    __slots__ = ()
+
     @property
     def size(self) -> int:
         """A data size."""
@@ -156,6 +162,8 @@ class IPv6(DataType):
 class String(DataType):
     """Represents a null terminated string."""
 
+    __slots__ = ()
+
     def __init__(self, value: Any = ""):
         """Initialize a new null terminated string data type."""
         super().__init__(value)
@@ -174,6 +182,8 @@ class String(DataType):
 class VarBytes(DataType):
     """Represents a variable length bytes."""
 
+    __slots__ = ()
+
     def __init__(self, value: Any = b""):
         """Initialize a new variable length bytes data type."""
         super().__init__(value)
@@ -192,6 +202,8 @@ class VarBytes(DataType):
 class VarString(VarBytes):
     """Represents a variable length string."""
 
+    __slots__ = ()
+
     def pack(self) -> bytes:
         """Pack the data."""
         return UnsignedChar(self.size - 1).to_bytes() + self.value.encode()
@@ -207,7 +219,7 @@ class BuiltInDataType(DataType, ABC):
     struct module.
     """
 
-    __slots__ = ("_struct",)
+    __slots__ = ()
 
     _struct: ClassVar[struct.Struct]
 
@@ -228,60 +240,79 @@ class BuiltInDataType(DataType, ABC):
 class SignedChar(BuiltInDataType):
     """Represents a signed char."""
 
+    __slots__ = ()
+
     _struct: ClassVar[struct.Struct] = struct.Struct("<b")
 
 
 class UnsignedChar(BuiltInDataType):
     """Represents an unsigned char."""
 
+    __slots__ = ()
+
     _struct: ClassVar[struct.Struct] = struct.Struct("<B")
 
 
 class Short(BuiltInDataType):
     """Represents a 16 bit integer."""
 
+    __slots__ = ()
+
     _struct: ClassVar[struct.Struct] = struct.Struct("<h")
 
 
 class UnsignedShort(BuiltInDataType):
     """Represents an unsigned 16 bit integer."""
 
+    __slots__ = ()
+
     _struct: ClassVar[struct.Struct] = struct.Struct("<H")
 
 
 class Int(BuiltInDataType):
     """Represents a 32 bit integer."""
 
+    __slots__ = ()
+
     _struct: ClassVar[struct.Struct] = struct.Struct("<i")
 
 
 class UnsignedInt(BuiltInDataType):
     """Represents a unsigned 32 bit integer."""
 
+    __slots__ = ()
+
     _struct: ClassVar[struct.Struct] = struct.Struct("<I")
 
 
 class Float(BuiltInDataType):
     """Represents a float."""
 
+    __slots__ = ()
+
     _struct: ClassVar[struct.Struct] = struct.Struct("<f")
 
 
 class Double(BuiltInDataType):
     """Represents a double."""
 
+    __slots__ = ()
+
     _struct: ClassVar[struct.Struct] = struct.Struct("<d")
 
 
 class Int64(BuiltInDataType):
     """Represents a 64 bit signed integer."""
 
+    __slots__ = ()
+
     _struct: ClassVar[struct.Struct] = struct.Struct("<q")
 
 
 class UInt64(BuiltInDataType):
     """Represents a 64 bit unsigned integer."""
 
+    __slots__ = ()
     _struct: ClassVar[struct.Struct] = struct.Struct("<Q")
 
 

pyplumio/helpers/event_manager.py

@@ -10,8 +10,6 @@ from pyplumio.helpers.typing import EventCallbackType, EventDataType
 class EventManager(TaskManager):
     """Represents an event manager."""
 
-    __slots__ = ("data", "_events", "_callbacks")
-
     data: EventDataType
     _events: dict[str | int, asyncio.Event]
     _callbacks: dict[str | int, list[EventCallbackType]]
@@ -31,31 +29,74 @@ class EventManager(TaskManager):
             raise AttributeError from e
 
     async def wait_for(self, name: str | int, timeout: float | None = None) -> None:
-        """Wait for the value to become available."""
+        """Wait for the value to become available.
+
+        :param name: Event name or ID
+        :type name: str | int
+        :param timeout: Wait this amount of seconds for a data to
+            become available, defaults to `None`
+        :type timeout: float, optional
+        :raise asyncio.TimeoutError: when waiting past specified timeout
+        """
         if name not in self.data:
             await asyncio.wait_for(self.create_event(name).wait(), timeout=timeout)
 
     async def get(self, name: str | int, timeout: float | None = None):
-        """Get the value."""
+        """Get the value by name.
+
+        :param name: Event name or ID
+        :type name: str | int
+        :param timeout: Wait this amount of seconds for a data to
+            become available, defaults to `None`
+        :type timeout: float, optional
+        :return: An event data
+        :raise asyncio.TimeoutError: when waiting past specified timeout
+        """
         await self.wait_for(name, timeout=timeout)
         return self.data[name]
 
     def get_nowait(self, name: str | int, default=None):
-        """Get the value without waiting."""
+        """Get the value by name without waiting.
+
+        If value is not available, default value will be
+        returned instead.
+
+        :param name: Event name or ID
+        :type name: str | int
+        :param default: default value to return if data is unavailable,
+            defaults to `None`
+        :type default: Any, optional
+        :return: An event data
+        """
         try:
             return self.data[name]
         except KeyError:
             return default
 
     def subscribe(self, name: str | int, callback: EventCallbackType) -> None:
-        """Subscribe a callback to the event."""
+        """Subscribe a callback to the event.
+
+        :param name: Event name or ID
+        :type name: str
+        :param callback: A coroutine callback function, that will be
+            awaited on the with the event data as an argument.
+        :type callback: Callable[[Any], Awaitable[Any]]
+        """
         if name not in self._callbacks:
             self._callbacks[name] = []
 
         self._callbacks[name].append(callback)
 
     def subscribe_once(self, name: str | int, callback: EventCallbackType) -> None:
-        """Subscribe a callback to the single event."""
+        """Subscribe a callback to the event once. Callback will be
+        unsubscribed after single event.
+
+        :param name: Event name or ID
+        :type name: str
+        :param callback: A coroutine callback function, that will be
+            awaited on the with the event data as an argument.
+        :type callback: Callable[[Any], Awaitable[Any]]
+        """
 
         async def _callback(value):
             """Unsubscribe callback from the event and calls it."""
@@ -65,7 +106,15 @@ class EventManager(TaskManager):
         self.subscribe(name, _callback)
 
     def unsubscribe(self, name: str | int, callback: EventCallbackType) -> None:
-        """Usubscribe a callback from the event."""
+        """Usubscribe a callback from the event.
+
+        :param name: Event name or ID
+        :type name: str
+        :param callback: A coroutine callback function, previously
+            subscribed to an event using ``subscribe()`` or
+            ``subscribe_once()`` methods.
+        :type callback: Callable[[Any], Awaitable[Any]]
+        """
         if name in self._callbacks and callback in self._callbacks[name]:
             self._callbacks[name].remove(callback)