dualsense-py 0.3.0__py3-none-any.whl

dualsense_py/__init__.py

@@ -0,0 +1,7 @@
+from .dual_sense_controller import DualSenseController
+from .utils import get_all_controllers, get_all_dual_sense_controllers, get_all_xbox_360_controllers
+
+try:
+    from ._version import __version__
+except ImportError:
+    __version__ = "0.0.0.dev0"

dualsense_py/_version.py

@@ -0,0 +1,24 @@
+# file generated by vcs-versioning
+# don't change, don't track in version control
+from __future__ import annotations
+
+__all__ = [
+    "__version__",
+    "__version_tuple__",
+    "version",
+    "version_tuple",
+    "__commit_id__",
+    "commit_id",
+]
+
+version: str
+__version__: str
+__version_tuple__: tuple[int | str, ...]
+version_tuple: tuple[int | str, ...]
+commit_id: str | None
+__commit_id__: str | None
+
+__version__ = version = '0.3.0'
+__version_tuple__ = version_tuple = (0, 3, 0)
+
+__commit_id__ = commit_id = 'gfde1784d8'

dualsense_py/backends/__init__.py

@@ -0,0 +1,3 @@
+from .backend import DeviceInfo
+from .hidapi.hidapi_backend import HidAPIBackend
+from .sdl3.sdl3_backend import SDL3Backend

dualsense_py/backends/backend.py

@@ -0,0 +1,67 @@
+from __future__ import annotations
+from abc import ABC, abstractmethod
+from typing import Generic, TypeVar, Any, Type
+
+
+from .device_infos import DeviceInfo
+
+
+_DeviceInfoType = TypeVar("_DeviceInfoType", bound=DeviceInfo[Any, Any])
+
+
+class Backend(ABC, Generic[_DeviceInfoType]):
+    """
+    Abstract base class for backend implementations.
+    """
+
+    ActiveBackend: Type[Backend[Any]] | None = None
+
+    @staticmethod
+    @abstractmethod
+    def _get_available_devices() -> list[_DeviceInfoType]:
+        """
+        Open a connection to the device at the specified path.
+        """
+
+    @staticmethod
+    @abstractmethod
+    def _init() -> Type[Backend[_DeviceInfoType]]:
+        pass
+
+    @staticmethod
+    @abstractmethod
+    def _quit() -> None:
+        pass
+
+    __slots__ = ( )
+
+    @classmethod
+    def init(cls) -> None:
+        """
+        Initialize the backend.
+        """
+        if cls == Backend:
+            raise TypeError("Cannot initialize the base Backend class directly.")
+
+        Backend.ActiveBackend = cls._init()
+
+    @staticmethod
+    def get_available_devices() -> list[_DeviceInfoType]:
+        """
+        Open a connection to the device at the specified path.
+        """
+        if Backend.ActiveBackend is None:
+            raise TypeError("Cannot call get_available_devices() without initializing the backend.")
+
+        return Backend.ActiveBackend._get_available_devices()
+
+    @staticmethod
+    def quit() -> None:
+        """
+        Close the backend.
+        """
+        if Backend.ActiveBackend is None:
+            return
+
+        Backend.ActiveBackend._quit()
+        Backend.ActiveBackend = None

dualsense_py/backends/device_infos.py

@@ -0,0 +1,270 @@
+from __future__ import annotations
+import time
+from abc import abstractmethod
+from typing import Generic, TypeVar, Final
+
+
+from ..readable_value import ReadableValue, ButtonValue
+from ..states import (
+    Accelerometer,
+    Battery,
+    Gyroscope,
+    JoyStick,
+    Orientation,
+    TouchFinger,
+    TriggerFeedback
+)
+ID = TypeVar("ID")
+T = TypeVar("T")
+
+
+class DeviceInfo(Generic[ID, T]):
+    """
+    Class to hold device information.
+    """
+    
+    """def __init__(self, id: ID, orig_device_info: T):
+        self.id: ID = id
+        self.orig_device_info: T = orig_device_info"""
+
+    @abstractmethod
+    def open(self):
+        """
+        Open a connection to the device at the specified path.
+        """
+
+    @abstractmethod
+    def close(self):
+        """
+        Close the connection to the device.
+        """
+
+    @abstractmethod
+    def _read(self):
+        """
+        Read data from the device.
+        """
+
+    @abstractmethod
+    def write(self):
+        """
+        Write data to the device.
+        """
+
+    @abstractmethod
+    def set_led(self, r: int, g: int, b: int) -> None:
+        """
+        Set the LED color of the device.
+        """
+
+    __slots__ = (
+        "_orig_device_info",
+        "_read_time",
+        "_last_read_time",
+        "_square",
+        "_cross",
+        "_circle",
+        "_triangle",
+        "_dpad_up",
+        "_dpad_right",
+        "_dpad_down",
+        "_dpad_left",
+        "_l1",
+        "_r1",
+        "_l2",
+        "_r2",
+        "_share",
+        "_options",
+        "_l3",
+        "_r3",
+        "_ps",
+        "_touch",
+        "_mikrophone",
+        "_left_joy_stick",
+        "_right_joy_stick",
+        "_l2_trigger",
+        "_r2_trigger",
+        "_accelerometer",
+        "_gyroscope",
+        "_battery",
+        "_touch_finger_1",
+        "_touch_finger_2",
+        "_left_trigger_feedback",
+        "_right_trigger_feedback",
+        "_orientation",
+    )
+
+    def __init__(self, orig_device_info: T):
+        self._orig_device_info: Final[T] = orig_device_info
+        self._read_time: float = 0.0
+        self._last_read_time: float = 0.0
+
+        self._square: Final[ButtonValue] = ButtonValue()
+        self._cross: Final[ButtonValue] = ButtonValue()
+        self._circle: Final[ButtonValue] = ButtonValue()
+        self._triangle: Final[ButtonValue] = ButtonValue()
+        self._dpad_up: Final[ButtonValue] = ButtonValue()
+        self._dpad_right: Final[ButtonValue] = ButtonValue()
+        self._dpad_down: Final[ButtonValue] = ButtonValue()
+        self._dpad_left: Final[ButtonValue] = ButtonValue()
+        self._l1: Final[ButtonValue] = ButtonValue()
+        self._r1: Final[ButtonValue] = ButtonValue()
+        self._l2: Final[ButtonValue] = ButtonValue()
+        self._r2: Final[ButtonValue] = ButtonValue()
+        self._share: Final[ButtonValue] = ButtonValue()
+        self._options: Final[ButtonValue] = ButtonValue()
+        self._l3: Final[ButtonValue] = ButtonValue()
+        self._r3: Final[ButtonValue] = ButtonValue()
+        self._ps: Final[ButtonValue] = ButtonValue()
+        self._touch: Final[ButtonValue] = ButtonValue()
+        self._mikrophone: Final[ButtonValue] = ButtonValue()
+        self._left_joy_stick: Final[ReadableValue[JoyStick]] = ReadableValue[JoyStick](JoyStick())
+        self._right_joy_stick: Final[ReadableValue[JoyStick]] = ReadableValue[JoyStick](JoyStick())
+        self._l2_trigger: Final[ReadableValue[float]] = ReadableValue[float](0.0)
+        self._r2_trigger: Final[ReadableValue[float]] = ReadableValue[float](0.0)
+        self._accelerometer: Final[ReadableValue[Accelerometer]] = ReadableValue[Accelerometer](Accelerometer())
+        self._gyroscope: Final[ReadableValue[Gyroscope]] = ReadableValue[Gyroscope](Gyroscope())
+        self._battery: Final[ReadableValue[Battery]] = ReadableValue[Battery](Battery())
+        self._touch_finger_1: Final[ReadableValue[TouchFinger]] = ReadableValue[TouchFinger](TouchFinger())
+        self._touch_finger_2: Final[ReadableValue[TouchFinger]] = ReadableValue[TouchFinger](TouchFinger())
+        self._left_trigger_feedback: Final[ReadableValue[TriggerFeedback]] = ReadableValue[TriggerFeedback](TriggerFeedback())
+        self._right_trigger_feedback: Final[ReadableValue[TriggerFeedback]] = ReadableValue[TriggerFeedback](TriggerFeedback())
+        self._orientation: Final[ReadableValue[Orientation]] = ReadableValue[Orientation](Orientation())
+
+    def before_start(self):
+        """
+        Initialize the backend with the device information.
+        """
+        pass
+
+    def read(self):
+        """
+        Read data from the device.
+        """
+        self._read_time = time.perf_counter() * 1000.0
+        self._read()
+        self._last_read_time = self._read_time
+
+    @property
+    def square(self) -> ButtonValue:
+        return self._square
+
+    @property
+    def cross(self) -> ButtonValue:
+        return self._cross
+
+    @property
+    def circle(self) -> ButtonValue:
+        return self._circle
+
+    @property
+    def triangle(self) -> ButtonValue:
+        return self._triangle
+
+    @property
+    def dpad_up(self) -> ButtonValue:
+        return self._dpad_up
+
+    @property
+    def dpad_right(self) -> ButtonValue:
+        return self._dpad_right
+
+    @property
+    def dpad_down(self) -> ButtonValue:
+        return self._dpad_down
+
+    @property
+    def dpad_left(self) -> ButtonValue:
+        return self._dpad_left
+
+    @property
+    def l1(self) -> ButtonValue:
+        return self._l1
+
+    @property
+    def r1(self) -> ButtonValue:
+        return self._r1
+
+    @property
+    def l2(self) -> ButtonValue:
+        return self._l2
+
+    @property
+    def r2(self) -> ButtonValue:
+        return self._r2
+
+    @property
+    def share(self) -> ButtonValue:
+        return self._share
+
+    @property
+    def options(self) -> ButtonValue:
+        return self._options
+
+    @property
+    def l3(self) -> ButtonValue:
+        return self._l3
+
+    @property
+    def r3(self) -> ButtonValue:
+        return self._r3
+
+    @property
+    def ps(self) -> ButtonValue:
+        return self._ps
+
+    @property
+    def touch(self) -> ButtonValue:
+        return self._touch
+
+    @property
+    def mikrophone(self) -> ButtonValue:
+        return self._mikrophone
+
+    @property
+    def left_joy_stick(self) -> ReadableValue[JoyStick]:
+        return self._left_joy_stick
+
+    @property
+    def right_joy_stick(self) -> ReadableValue[JoyStick]:
+        return self._right_joy_stick
+
+    @property
+    def l2_trigger(self) -> ReadableValue[float]:
+        return self._l2_trigger
+
+    @property
+    def r2_trigger(self) -> ReadableValue[float]:
+        return self._r2_trigger
+
+    @property
+    def accelerometer(self) -> ReadableValue[Accelerometer]:
+        return self._accelerometer
+
+    @property
+    def gyroscope(self) -> ReadableValue[Gyroscope]:
+        return self._gyroscope
+
+    @property
+    def battery(self) -> ReadableValue[Battery]:
+        return self._battery
+
+    @property
+    def touch_finger_1(self) -> ReadableValue[TouchFinger]:
+        return self._touch_finger_1
+
+    @property
+    def touch_finger_2(self) -> ReadableValue[TouchFinger]:
+        return self._touch_finger_2
+
+    @property
+    def left_trigger_feedback(self) -> ReadableValue[TriggerFeedback]:
+        return self._left_trigger_feedback
+
+    @property
+    def right_trigger_feedback(self) -> ReadableValue[TriggerFeedback]:
+        return self._right_trigger_feedback
+
+    @property
+    def orientation(self) -> ReadableValue[Orientation]:
+        return self._orientation

dualsense_py/backends/hidapi/hidapi_backend.py

@@ -0,0 +1,25 @@
+from __future__ import annotations
+from typing import Type
+
+from hidapi_py import get_all_device_infos
+
+from .hidapi_device_info import HIDAPIDeviceInfo
+from ..backend import Backend
+
+
+SONY_VENDOR_ID: int = 0x054C
+DS_PRODUCT_ID: int = 0x0CE6
+
+
+class HidAPIBackend(Backend[HIDAPIDeviceInfo]):
+    @staticmethod
+    def _get_available_devices() -> list[HIDAPIDeviceInfo]:
+        return [HIDAPIDeviceInfo(hid_device_info) for hid_device_info in get_all_device_infos(SONY_VENDOR_ID, DS_PRODUCT_ID)]
+
+    @staticmethod
+    def _init() -> Type[HidAPIBackend]:
+        return HidAPIBackend
+
+    @staticmethod
+    def _quit() -> None:
+        pass

dualsense_py/backends/hidapi/hidapi_device_info.py

@@ -0,0 +1,113 @@
+from __future__ import annotations
+from typing import Final
+
+from hidapi_py import HidDeviceInfo, HidDevice
+
+from ..backend import DeviceInfo
+from .in_report import (
+    InReport,
+    Usb01InReport,
+    Bt01InReport,
+    Bt31InReport,
+    InReportLength,
+    InvalidInReportLengthException,
+)
+from .out_report import OutReport, Usb01OutReport, Bt01OutReport, Bt31OutReport
+from ...mapping import (
+    uint8_value_mapping,
+    uint8_bit_to_bool,
+    create_battery,
+    create_touch_finger,
+    uint8_to_float,
+    create_accelerometer,
+    create_gyroscope,
+    create_trigger_feedback,
+    create_orientation,
+    create_joy_stick,
+)
+
+
+class HIDAPIDeviceInfo(DeviceInfo[str, HidDeviceInfo]):
+    __slots__ = (
+        "_hid_device",
+        "__in_report",
+        "__out_report",
+    )
+
+    def __init__(self, hid_device_info: HidDeviceInfo):
+        super().__init__(hid_device_info)
+        self._hid_device: Final[HidDevice] = HidDevice(hid_device_info.path)
+        self.__in_report: InReport | None = None
+        self.__out_report: OutReport | None = None
+
+    def before_start(self):
+        data = self._hid_device.read()
+
+        match len(data):
+            case InReportLength.USB_01:
+                self.__in_report = Usb01InReport()
+                self.__out_report = Usb01OutReport()
+            case InReportLength.BT_31:
+                self.__in_report = Bt31InReport()
+                self.__out_report = Bt31OutReport()
+            case InReportLength.BT_01:
+                self.__in_report = Bt01InReport()
+                self.__out_report = Bt01OutReport()
+            case _:
+                raise InvalidInReportLengthException
+
+    def open(self):
+        self._hid_device.open()
+
+    def close(self):
+        self._hid_device.close()
+
+    def _read(self):
+        if self.__in_report is None:
+            return
+
+        self._hid_device.read(self.__in_report.data)
+
+        self._square.set_value(uint8_bit_to_bool(self.__in_report.buttons_0, InReport.SQUARE_BIT))
+        self._cross.set_value(uint8_bit_to_bool(self.__in_report.buttons_0, InReport.CROSS_BIT))
+        self._circle.set_value(uint8_bit_to_bool(self.__in_report.buttons_0, InReport.CIRCLE_BIT))
+        self._triangle.set_value(uint8_bit_to_bool(self.__in_report.buttons_0, InReport.TRIANGLE_BIT))
+
+        for readable_value, value in zip(
+            [self._dpad_up, self._dpad_right, self._dpad_down, self._dpad_left],
+            uint8_value_mapping(self.__in_report.buttons_0 & 0b1111, InReport.DPAD_MAPPING)
+        ):
+            readable_value.set_value(value)
+
+        self._l1.set_value(uint8_bit_to_bool(self.__in_report.buttons_1, InReport.L1_BIT))
+        self._r1.set_value(uint8_bit_to_bool(self.__in_report.buttons_1, InReport.R1_BIT))
+        self._l2.set_value(uint8_bit_to_bool(self.__in_report.buttons_1, InReport.L2_BIT))
+        self._r2.set_value(uint8_bit_to_bool(self.__in_report.buttons_1, InReport.R2_BIT))
+        self._share.set_value(uint8_bit_to_bool(self.__in_report.buttons_1, InReport.SHARE_BIT))
+        self._options.set_value(uint8_bit_to_bool(self.__in_report.buttons_1, InReport.OPTIONS_BIT))
+        self._l3.set_value(uint8_bit_to_bool(self.__in_report.buttons_1, InReport.L3_BIT))
+        self._r3.set_value(uint8_bit_to_bool(self.__in_report.buttons_1, InReport.R3_BIT))
+        self._ps.set_value(uint8_bit_to_bool(self.__in_report.buttons_2, InReport.PS_BIT))
+        self._touch.set_value(uint8_bit_to_bool(self.__in_report.buttons_2, InReport.TOUCH_BIT))
+        self._mikrophone.set_value(uint8_bit_to_bool(self.__in_report.buttons_2, InReport.MIKROPHONE_BIT))
+        self._left_joy_stick.set_value(create_joy_stick(self.__in_report.axes_0, self.__in_report.axes_1))
+        self._right_joy_stick.set_value(create_joy_stick(self.__in_report.axes_2, self.__in_report.axes_3))
+        self._l2_trigger.set_value(uint8_to_float(self.__in_report.axes_4, (0.0, 1.0)))
+        self._r2_trigger.set_value(uint8_to_float(self.__in_report.axes_5, (0.0, 1.0)))
+        self._accelerometer.set_value(create_accelerometer(x_0=self.__in_report.accel_x_0, x_1=self.__in_report.accel_x_1, y_0=self.__in_report.accel_y_0, y_1=self.__in_report.accel_y_1, z_0=self.__in_report.accel_z_0, z_1=self.__in_report.accel_z_1))
+        self._gyroscope.set_value(create_gyroscope(x_0=self.__in_report.gyro_x_0, x_1=self.__in_report.gyro_x_1, y_0=self.__in_report.gyro_y_0, y_1=self.__in_report.gyro_y_1, z_0=self.__in_report.gyro_z_0, z_1=self.__in_report.gyro_z_1))
+        self._battery.set_value(create_battery(self.__in_report.battery_0, self.__in_report.battery_1))
+        self._touch_finger_1.set_value(create_touch_finger(self.__in_report.touch_1_0, self.__in_report.touch_1_1, self.__in_report.touch_1_2, self.__in_report.touch_1_3))
+        self._touch_finger_2.set_value(create_touch_finger(self.__in_report.touch_2_0, self.__in_report.touch_2_1, self.__in_report.touch_2_2, self.__in_report.touch_2_3))
+        self._left_trigger_feedback.set_value(create_trigger_feedback(self.__in_report.left_trigger_feedback))
+        self._right_trigger_feedback.set_value(create_trigger_feedback(self.__in_report.right_trigger_feedback))
+        self._orientation.set_value(create_orientation(self._orientation.value, self._accelerometer.value, self._gyroscope.value, (self._read_time - self._last_read_time) if self._last_read_time else 0.0))
+
+    def write(self):
+        """
+        Write data to the device.
+        """
+        pass
+
+    def set_led(self, r: int, g: int, b: int) -> None:
+        pass

dualsense_py/backends/hidapi/in_report/__init__.py

@@ -0,0 +1,6 @@
+from .in_report import InReport, BytesLike
+from .bt_01_in_report import Bt01InReport
+from .bt_31_in_report import Bt31InReport
+from .usb_01_in_report import Usb01InReport
+from .enums import InReportLength
+from .exceptions import AbstractBaseException, InvalidDeviceIndexException, InvalidInReportLengthException, NoDeviceDetectedException

dualsense_py/backends/hidapi/in_report/bt_01_in_report.py

@@ -0,0 +1,11 @@
+from .in_report import InReport, BytesLike
+from .enums import InReportLength
+
+
+class Bt01InReport(InReport):
+    def __init__(self, data: BytesLike = bytearray(InReportLength.BT_01)):
+        super().__init__({
+            "axes_0": 0, "axes_1": 1, "axes_2": 2, "axes_3": 3,
+            "buttons_0": 4, "buttons_1": 5, "buttons_2": 6,
+            "axes_4": 7, "axes_5": 8
+        }, data=data)

dualsense_py/backends/hidapi/in_report/bt_31_in_report.py

@@ -0,0 +1,25 @@
+from .in_report import InReport, BytesLike
+from .enums import InReportLength
+
+
+# ??? byte 0
+# ??? byte 7?
+# ??? byte 11
+# ??? bytes 28-32
+# ??? byte 41
+# ??? bytes 44-52
+# ??? bytes 55-76
+class Bt31InReport(InReport):
+
+    def __init__(self, data: BytesLike = bytearray(InReportLength.BT_31)):
+        super().__init__({
+            "axes_0": 1, "axes_1": 2, "axes_2": 3, "axes_3": 4, "axes_4": 5, "axes_5": 6,
+            "buttons_0": 8, "buttons_1": 9, "buttons_2": 10,
+            "timestamp_0": 12, "timestamp_1": 13, "timestamp_2": 14, "timestamp_3": 15,
+            "gyro_x_0": 16, "gyro_x_1": 17, "gyro_y_0": 18, "gyro_y_1": 19, "gyro_z_0": 20, "gyro_z_1": 21,
+            "accel_x_0": 22, "accel_x_1": 23, "accel_y_0": 24, "accel_y_1": 25, "accel_z_0": 26, "accel_z_1": 27,
+            "touch_1_0": 33, "touch_1_1": 34, "touch_1_2": 35, "touch_1_3": 36,
+            "touch_2_0": 37, "touch_2_1": 38, "touch_2_2": 39, "touch_2_3": 40,
+            "right_trigger_feedback": 42, "left_trigger_feedback": 43,
+            "battery_0": 53, "battery_1": 54,
+        }, data=data)

dualsense_py/backends/hidapi/in_report/enums.py

@@ -0,0 +1,8 @@
+from enum import Enum
+
+
+class InReportLength(int, Enum):
+    DUMMY = 100
+    USB_01 = 64
+    BT_31 = 78
+    BT_01 = 10

dualsense_py/backends/hidapi/in_report/exceptions.py

@@ -0,0 +1,21 @@
+from abc import ABC
+
+
+class AbstractBaseException(ABC, Exception):
+    def __init__(self, msg: str):
+        super().__init__(msg)
+
+
+class NoDeviceDetectedException(AbstractBaseException):
+    def __init__(self):
+        super().__init__('No DualSense device detected')
+
+
+class InvalidDeviceIndexException(AbstractBaseException):
+    def __init__(self, idx: int):
+        super().__init__(f'Invalid DualSense device index given {idx}')
+
+
+class InvalidInReportLengthException(AbstractBaseException):
+    def __init__(self):
+        super().__init__(f'Invalid connection type')