homeassistant 2025.6.3__py3-none-any.whl → 2025.7.0b0__py3-none-any.whl

homeassistant/components/playstation_network/coordinator.py

@@ -0,0 +1,74 @@
+"""Coordinator for the PlayStation Network Integration."""
+
+from __future__ import annotations
+
+from datetime import timedelta
+import logging
+
+from psnawp_api.core.psnawp_exceptions import (
+    PSNAWPAuthenticationError,
+    PSNAWPServerError,
+)
+from psnawp_api.models.user import User
+
+from homeassistant.config_entries import ConfigEntry
+from homeassistant.core import HomeAssistant
+from homeassistant.exceptions import ConfigEntryAuthFailed
+from homeassistant.helpers.update_coordinator import DataUpdateCoordinator, UpdateFailed
+
+from .const import DOMAIN
+from .helpers import PlaystationNetwork, PlaystationNetworkData
+
+_LOGGER = logging.getLogger(__name__)
+
+type PlaystationNetworkConfigEntry = ConfigEntry[PlaystationNetworkCoordinator]
+
+
+class PlaystationNetworkCoordinator(DataUpdateCoordinator[PlaystationNetworkData]):
+    """Data update coordinator for PSN."""
+
+    config_entry: PlaystationNetworkConfigEntry
+    user: User
+
+    def __init__(
+        self,
+        hass: HomeAssistant,
+        psn: PlaystationNetwork,
+        config_entry: PlaystationNetworkConfigEntry,
+    ) -> None:
+        """Initialize the Coordinator."""
+        super().__init__(
+            hass,
+            name=DOMAIN,
+            logger=_LOGGER,
+            config_entry=config_entry,
+            update_interval=timedelta(seconds=30),
+        )
+
+        self.psn = psn
+
+    async def _async_setup(self) -> None:
+        """Set up the coordinator."""
+
+        try:
+            self.user = await self.psn.get_user()
+        except PSNAWPAuthenticationError as error:
+            raise ConfigEntryAuthFailed(
+                translation_domain=DOMAIN,
+                translation_key="not_ready",
+            ) from error
+
+    async def _async_update_data(self) -> PlaystationNetworkData:
+        """Get the latest data from the PSN."""
+        try:
+            return await self.psn.get_data()
+        except PSNAWPAuthenticationError as error:
+            raise ConfigEntryAuthFailed(
+                translation_domain=DOMAIN,
+                translation_key="not_ready",
+            ) from error
+        except PSNAWPServerError as error:
+            raise UpdateFailed(
+                translation_domain=DOMAIN,
+                translation_key="update_failed",
+            ) from error

homeassistant/components/playstation_network/helpers.py

@@ -0,0 +1,154 @@
+"""Helper methods for common PlayStation Network integration operations."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from functools import partial
+from typing import Any
+
+from psnawp_api import PSNAWP
+from psnawp_api.models.client import Client
+from psnawp_api.models.trophies import PlatformType, TrophySummary
+from psnawp_api.models.user import User
+from pyrate_limiter import Duration, Rate
+
+from homeassistant.core import HomeAssistant
+
+from .const import SUPPORTED_PLATFORMS
+
+LEGACY_PLATFORMS = {PlatformType.PS3, PlatformType.PS4}
+
+
+@dataclass
+class SessionData:
+    """Dataclass representing console session data."""
+
+    platform: PlatformType = PlatformType.UNKNOWN
+    title_id: str | None = None
+    title_name: str | None = None
+    format: PlatformType | None = None
+    media_image_url: str | None = None
+    status: str = ""
+
+
+@dataclass
+class PlaystationNetworkData:
+    """Dataclass representing data retrieved from the Playstation Network api."""
+
+    presence: dict[str, Any] = field(default_factory=dict)
+    username: str = ""
+    account_id: str = ""
+    available: bool = False
+    active_sessions: dict[PlatformType, SessionData] = field(default_factory=dict)
+    registered_platforms: set[PlatformType] = field(default_factory=set)
+    trophy_summary: TrophySummary | None = None
+    profile: dict[str, Any] = field(default_factory=dict)
+
+
+class PlaystationNetwork:
+    """Helper Class to return playstation network data in an easy to use structure."""
+
+    def __init__(self, hass: HomeAssistant, npsso: str) -> None:
+        """Initialize the class with the npsso token."""
+        rate = Rate(300, Duration.MINUTE * 15)
+        self.psn = PSNAWP(npsso, rate_limit=rate)
+        self.client: Client | None = None
+        self.hass = hass
+        self.user: User
+        self.legacy_profile: dict[str, Any] | None = None
+
+    async def get_user(self) -> User:
+        """Get the user object from the PlayStation Network."""
+        self.user = await self.hass.async_add_executor_job(
+            partial(self.psn.user, online_id="me")
+        )
+        return self.user
+
+    def retrieve_psn_data(self) -> PlaystationNetworkData:
+        """Bundle api calls to retrieve data from the PlayStation Network."""
+        data = PlaystationNetworkData()
+
+        if not self.client:
+            self.client = self.psn.me()
+
+        data.registered_platforms = {
+            PlatformType(device["deviceType"])
+            for device in self.client.get_account_devices()
+        } & SUPPORTED_PLATFORMS
+
+        data.presence = self.user.get_presence()
+
+        data.trophy_summary = self.client.trophy_summary()
+        data.profile = self.user.profile()
+
+        # check legacy platforms if owned
+        if LEGACY_PLATFORMS & data.registered_platforms:
+            self.legacy_profile = self.client.get_profile_legacy()
+        return data
+
+    async def get_data(self) -> PlaystationNetworkData:
+        """Get title data from the PlayStation Network."""
+        data = await self.hass.async_add_executor_job(self.retrieve_psn_data)
+        data.username = self.user.online_id
+        data.account_id = self.user.account_id
+
+        data.available = (
+            data.presence.get("basicPresence", {}).get("availability")
+            == "availableToPlay"
+        )
+
+        session = SessionData()
+        session.platform = PlatformType(
+            data.presence["basicPresence"]["primaryPlatformInfo"]["platform"]
+        )
+
+        if session.platform in SUPPORTED_PLATFORMS:
+            session.status = data.presence.get("basicPresence", {}).get(
+                "primaryPlatformInfo"
+            )["onlineStatus"]
+
+            game_title_info = data.presence.get("basicPresence", {}).get(
+                "gameTitleInfoList"
+            )
+
+            if game_title_info:
+                session.title_id = game_title_info[0]["npTitleId"]
+                session.title_name = game_title_info[0]["titleName"]
+                session.format = PlatformType(game_title_info[0]["format"])
+                if session.format in {PlatformType.PS5, PlatformType.PSPC}:
+                    session.media_image_url = game_title_info[0]["conceptIconUrl"]
+                else:
+                    session.media_image_url = game_title_info[0]["npTitleIconUrl"]
+
+            data.active_sessions[session.platform] = session
+
+        if self.legacy_profile:
+            presence = self.legacy_profile["profile"].get("presences", [])
+            if (game_title_info := presence[0] if presence else {}) and game_title_info[
+                "onlineStatus"
+            ] == "online":
+                data.available = True
+
+                platform = PlatformType(game_title_info["platform"])
+
+                if platform is PlatformType.PS4:
+                    media_image_url = game_title_info.get("npTitleIconUrl")
+                elif platform is PlatformType.PS3 and game_title_info.get("npTitleId"):
+                    media_image_url = self.psn.game_title(
+                        game_title_info["npTitleId"],
+                        platform=PlatformType.PS3,
+                        account_id="me",
+                        np_communication_id="",
+                    ).get_title_icon_url()
+                else:
+                    media_image_url = None
+
+                data.active_sessions[platform] = SessionData(
+                    platform=platform,
+                    title_id=game_title_info.get("npTitleId"),
+                    title_name=game_title_info.get("titleName"),
+                    format=platform,
+                    media_image_url=media_image_url,
+                    status=game_title_info["onlineStatus"],
+                )
+        return data

homeassistant/components/playstation_network/icons.json

@@ -0,0 +1,32 @@
+{
+  "entity": {
+    "media_player": {
+      "playstation": {
+        "default": "mdi:sony-playstation"
+      }
+    },
+    "sensor": {
+      "trophy_level": {
+        "default": "mdi:trophy-award"
+      },
+      "trophy_level_progress": {
+        "default": "mdi:trending-up"
+      },
+      "earned_trophies_platinum": {
+        "default": "mdi:trophy"
+      },
+      "earned_trophies_gold": {
+        "default": "mdi:trophy-variant"
+      },
+      "earned_trophies_silver": {
+        "default": "mdi:trophy-variant"
+      },
+      "earned_trophies_bronze": {
+        "default": "mdi:trophy-variant"
+      },
+      "online_id": {
+        "default": "mdi:account"
+      }
+    }
+  }
+}

homeassistant/components/playstation_network/manifest.json

@@ -0,0 +1,70 @@
+{
+  "domain": "playstation_network",
+  "name": "PlayStation Network",
+  "codeowners": ["@jackjpowell", "@tr4nt0r"],
+  "config_flow": true,
+  "dhcp": [
+    {
+      "macaddress": "AC8995*"
+    },
+    {
+      "macaddress": "1C98C1*"
+    },
+    {
+      "macaddress": "5C843C*"
+    },
+    {
+      "macaddress": "605BB4*"
+    },
+    {
+      "macaddress": "8060B7*"
+    },
+    {
+      "macaddress": "78C881*"
+    },
+    {
+      "macaddress": "00D9D1*"
+    },
+    {
+      "macaddress": "00E421*"
+    },
+    {
+      "macaddress": "0CFE45*"
+    },
+    {
+      "macaddress": "2CCC44*"
+    },
+    {
+      "macaddress": "BC60A7*"
+    },
+    {
+      "macaddress": "C863F1*"
+    },
+    {
+      "macaddress": "F8461C*"
+    },
+    {
+      "macaddress": "70662A*"
+    },
+    {
+      "macaddress": "09E29*"
+    },
+    {
+      "macaddress": "B40AD8*"
+    },
+    {
+      "macaddress": "A8474A*"
+    },
+    {
+      "macaddress": "280DFC*"
+    },
+    {
+      "macaddress": "D44B5E*"
+    }
+  ],
+  "documentation": "https://www.home-assistant.io/integrations/playstation_network",
+  "integration_type": "service",
+  "iot_class": "cloud_polling",
+  "quality_scale": "bronze",
+  "requirements": ["PSNAWP==3.0.0", "pyrate-limiter==3.7.0"]
+}

homeassistant/components/playstation_network/media_player.py

@@ -0,0 +1,131 @@
+"""Media player entity for the PlayStation Network Integration."""
+
+import logging
+from typing import TYPE_CHECKING
+
+from psnawp_api.models.trophies import PlatformType
+
+from homeassistant.components.media_player import (
+    MediaPlayerDeviceClass,
+    MediaPlayerEntity,
+    MediaPlayerState,
+    MediaType,
+)
+from homeassistant.core import HomeAssistant, callback
+from homeassistant.helpers import device_registry as dr
+from homeassistant.helpers.device_registry import DeviceInfo
+from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
+from homeassistant.helpers.update_coordinator import CoordinatorEntity
+
+from . import PlaystationNetworkConfigEntry, PlaystationNetworkCoordinator
+from .const import DOMAIN, SUPPORTED_PLATFORMS
+
+_LOGGER = logging.getLogger(__name__)
+
+
+PLATFORM_MAP = {
+    PlatformType.PS5: "PlayStation 5",
+    PlatformType.PS4: "PlayStation 4",
+    PlatformType.PS3: "PlayStation 3",
+    PlatformType.PSPC: "PlayStation PC",
+}
+PARALLEL_UPDATES = 0
+
+
+async def async_setup_entry(
+    hass: HomeAssistant,
+    config_entry: PlaystationNetworkConfigEntry,
+    async_add_entities: AddConfigEntryEntitiesCallback,
+) -> None:
+    """Media Player Entity Setup."""
+    coordinator = config_entry.runtime_data
+    devices_added: set[PlatformType] = set()
+    device_reg = dr.async_get(hass)
+    entities = []
+
+    @callback
+    def add_entities() -> None:
+        nonlocal devices_added
+
+        if not SUPPORTED_PLATFORMS - devices_added:
+            remove_listener()
+
+        new_platforms = set(coordinator.data.active_sessions.keys()) - devices_added
+        if new_platforms:
+            async_add_entities(
+                PsnMediaPlayerEntity(coordinator, platform_type)
+                for platform_type in new_platforms
+            )
+            devices_added |= new_platforms
+
+    for platform in SUPPORTED_PLATFORMS:
+        if device_reg.async_get_device(
+            identifiers={
+                (DOMAIN, f"{coordinator.config_entry.unique_id}_{platform.value}")
+            }
+        ):
+            entities.append(PsnMediaPlayerEntity(coordinator, platform))
+            devices_added.add(platform)
+    if entities:
+        async_add_entities(entities)
+
+    remove_listener = coordinator.async_add_listener(add_entities)
+    add_entities()
+
+
+class PsnMediaPlayerEntity(
+    CoordinatorEntity[PlaystationNetworkCoordinator], MediaPlayerEntity
+):
+    """Media player entity representing currently playing game."""
+
+    _attr_media_image_remotely_accessible = True
+    _attr_media_content_type = MediaType.GAME
+    _attr_device_class = MediaPlayerDeviceClass.RECEIVER
+    _attr_translation_key = "playstation"
+    _attr_has_entity_name = True
+    _attr_name = None
+
+    def __init__(
+        self, coordinator: PlaystationNetworkCoordinator, platform: PlatformType
+    ) -> None:
+        """Initialize PSN MediaPlayer."""
+        super().__init__(coordinator)
+        if TYPE_CHECKING:
+            assert coordinator.config_entry.unique_id
+        self._attr_unique_id = f"{coordinator.config_entry.unique_id}_{platform.value}"
+        self.key = platform
+        self._attr_device_info = DeviceInfo(
+            identifiers={(DOMAIN, self._attr_unique_id)},
+            name=PLATFORM_MAP[platform],
+            manufacturer="Sony Interactive Entertainment",
+            model=PLATFORM_MAP[platform],
+            via_device=(DOMAIN, coordinator.config_entry.unique_id),
+        )
+
+    @property
+    def state(self) -> MediaPlayerState:
+        """Media Player state getter."""
+        session = self.coordinator.data.active_sessions.get(self.key)
+        if session and session.status == "online":
+            if self.coordinator.data.available and session.title_id is not None:
+                return MediaPlayerState.PLAYING
+            return MediaPlayerState.ON
+        return MediaPlayerState.OFF
+
+    @property
+    def media_title(self) -> str | None:
+        """Media title getter."""
+        session = self.coordinator.data.active_sessions.get(self.key)
+        return session.title_name if session else None
+
+    @property
+    def media_content_id(self) -> str | None:
+        """Content ID of current playing media."""
+        session = self.coordinator.data.active_sessions.get(self.key)
+        return session.title_id if session else None
+
+    @property
+    def media_image_url(self) -> str | None:
+        """Media image url getter."""
+        session = self.coordinator.data.active_sessions.get(self.key)
+        return session.media_image_url if session else None

homeassistant/components/playstation_network/quality_scale.yaml

@@ -0,0 +1,72 @@
+rules:
+  # Bronze
+  action-setup:
+    status: exempt
+    comment: Integration has no actions
+  appropriate-polling: done
+  brands: done
+  common-modules: done
+  config-flow-test-coverage: done
+  config-flow: done
+  dependency-transparency: done
+  docs-actions:
+    status: exempt
+    comment: Integration has no actions
+
+  docs-high-level-description: done
+  docs-installation-instructions: done
+  docs-removal-instructions: done
+  entity-event-setup:
+    status: exempt
+    comment: Integration does not register events.
+  entity-unique-id: done
+  has-entity-name: done
+  runtime-data: done
+  test-before-configure: done
+  test-before-setup: done
+  unique-config-entry: done
+
+  # Silver
+  action-exceptions:
+    status: exempt
+    comment: Integration has no actions
+  config-entry-unloading: done
+  docs-configuration-parameters:
+    status: exempt
+    comment: Integration has no configuration options
+  docs-installation-parameters: done
+  entity-unavailable: done
+  integration-owner: done
+  log-when-unavailable: done
+  parallel-updates: done
+  reauthentication-flow: done
+  test-coverage: todo
+
+  # Gold
+  devices: done
+  diagnostics: todo
+  discovery-update-info:
+    status: exempt
+    comment: Discovery flow is not applicable for this integration
+  discovery: done
+  docs-data-update: done
+  docs-examples: todo
+  docs-known-limitations: done
+  docs-supported-devices: done
+  docs-supported-functions: done
+  docs-troubleshooting: todo
+  docs-use-cases: done
+  dynamic-devices: todo
+  entity-category: done
+  entity-device-class: done
+  entity-disabled-by-default: done
+  entity-translations: done
+  exception-translations: done
+  icon-translations: done
+  reconfiguration-flow: todo
+  repair-issues: todo
+  stale-devices: todo
+  # Platinum
+  async-dependency: todo
+  inject-websession: todo
+  strict-typing: todo

homeassistant/components/playstation_network/sensor.py

@@ -0,0 +1,168 @@
+"""Sensor platform for PlayStation Network integration."""
+
+from __future__ import annotations
+
+from collections.abc import Callable
+from dataclasses import dataclass
+from enum import StrEnum
+from typing import TYPE_CHECKING
+
+from homeassistant.components.sensor import SensorEntity, SensorEntityDescription
+from homeassistant.const import PERCENTAGE
+from homeassistant.core import HomeAssistant
+from homeassistant.helpers.device_registry import DeviceEntryType, DeviceInfo
+from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
+from homeassistant.helpers.typing import StateType
+from homeassistant.helpers.update_coordinator import CoordinatorEntity
+
+from .const import DOMAIN
+from .coordinator import (
+    PlaystationNetworkConfigEntry,
+    PlaystationNetworkCoordinator,
+    PlaystationNetworkData,
+)
+
+PARALLEL_UPDATES = 0
+
+
+@dataclass(kw_only=True, frozen=True)
+class PlaystationNetworkSensorEntityDescription(SensorEntityDescription):
+    """PlayStation Network sensor description."""
+
+    value_fn: Callable[[PlaystationNetworkData], StateType]
+    entity_picture: str | None = None
+
+
+class PlaystationNetworkSensor(StrEnum):
+    """PlayStation Network sensors."""
+
+    TROPHY_LEVEL = "trophy_level"
+    TROPHY_LEVEL_PROGRESS = "trophy_level_progress"
+    EARNED_TROPHIES_PLATINUM = "earned_trophies_platinum"
+    EARNED_TROPHIES_GOLD = "earned_trophies_gold"
+    EARNED_TROPHIES_SILVER = "earned_trophies_silver"
+    EARNED_TROPHIES_BRONZE = "earned_trophies_bronze"
+    ONLINE_ID = "online_id"
+
+
+SENSOR_DESCRIPTIONS: tuple[PlaystationNetworkSensorEntityDescription, ...] = (
+    PlaystationNetworkSensorEntityDescription(
+        key=PlaystationNetworkSensor.TROPHY_LEVEL,
+        translation_key=PlaystationNetworkSensor.TROPHY_LEVEL,
+        value_fn=(
+            lambda psn: psn.trophy_summary.trophy_level if psn.trophy_summary else None
+        ),
+    ),
+    PlaystationNetworkSensorEntityDescription(
+        key=PlaystationNetworkSensor.TROPHY_LEVEL_PROGRESS,
+        translation_key=PlaystationNetworkSensor.TROPHY_LEVEL_PROGRESS,
+        value_fn=(
+            lambda psn: psn.trophy_summary.progress if psn.trophy_summary else None
+        ),
+        native_unit_of_measurement=PERCENTAGE,
+    ),
+    PlaystationNetworkSensorEntityDescription(
+        key=PlaystationNetworkSensor.EARNED_TROPHIES_PLATINUM,
+        translation_key=PlaystationNetworkSensor.EARNED_TROPHIES_PLATINUM,
+        value_fn=(
+            lambda psn: psn.trophy_summary.earned_trophies.platinum
+            if psn.trophy_summary
+            else None
+        ),
+    ),
+    PlaystationNetworkSensorEntityDescription(
+        key=PlaystationNetworkSensor.EARNED_TROPHIES_GOLD,
+        translation_key=PlaystationNetworkSensor.EARNED_TROPHIES_GOLD,
+        value_fn=(
+            lambda psn: psn.trophy_summary.earned_trophies.gold
+            if psn.trophy_summary
+            else None
+        ),
+    ),
+    PlaystationNetworkSensorEntityDescription(
+        key=PlaystationNetworkSensor.EARNED_TROPHIES_SILVER,
+        translation_key=PlaystationNetworkSensor.EARNED_TROPHIES_SILVER,
+        value_fn=(
+            lambda psn: psn.trophy_summary.earned_trophies.silver
+            if psn.trophy_summary
+            else None
+        ),
+    ),
+    PlaystationNetworkSensorEntityDescription(
+        key=PlaystationNetworkSensor.EARNED_TROPHIES_BRONZE,
+        translation_key=PlaystationNetworkSensor.EARNED_TROPHIES_BRONZE,
+        value_fn=(
+            lambda psn: psn.trophy_summary.earned_trophies.bronze
+            if psn.trophy_summary
+            else None
+        ),
+    ),
+    PlaystationNetworkSensorEntityDescription(
+        key=PlaystationNetworkSensor.ONLINE_ID,
+        translation_key=PlaystationNetworkSensor.ONLINE_ID,
+        value_fn=lambda psn: psn.username,
+    ),
+)
+
+
+async def async_setup_entry(
+    hass: HomeAssistant,
+    config_entry: PlaystationNetworkConfigEntry,
+    async_add_entities: AddConfigEntryEntitiesCallback,
+) -> None:
+    """Set up the sensor platform."""
+    coordinator = config_entry.runtime_data
+    async_add_entities(
+        PlaystationNetworkSensorEntity(coordinator, description)
+        for description in SENSOR_DESCRIPTIONS
+    )
+
+
+class PlaystationNetworkSensorEntity(
+    CoordinatorEntity[PlaystationNetworkCoordinator], SensorEntity
+):
+    """Representation of a PlayStation Network sensor entity."""
+
+    entity_description: PlaystationNetworkSensorEntityDescription
+    coordinator: PlaystationNetworkCoordinator
+
+    _attr_has_entity_name = True
+
+    def __init__(
+        self,
+        coordinator: PlaystationNetworkCoordinator,
+        description: PlaystationNetworkSensorEntityDescription,
+    ) -> None:
+        """Initialize a sensor entity."""
+        super().__init__(coordinator)
+        self.entity_description = description
+        if TYPE_CHECKING:
+            assert coordinator.config_entry.unique_id
+        self._attr_unique_id = f"{coordinator.config_entry.unique_id}_{description.key}"
+        self._attr_device_info = DeviceInfo(
+            identifiers={(DOMAIN, coordinator.config_entry.unique_id)},
+            name=coordinator.data.username,
+            entry_type=DeviceEntryType.SERVICE,
+            manufacturer="Sony Interactive Entertainment",
+        )
+
+    @property
+    def native_value(self) -> StateType:
+        """Return the state of the sensor."""
+
+        return self.entity_description.value_fn(self.coordinator.data)
+
+    @property
+    def entity_picture(self) -> str | None:
+        """Return the entity picture to use in the frontend, if any."""
+        if self.entity_description.key is PlaystationNetworkSensor.ONLINE_ID and (
+            profile_pictures := self.coordinator.data.profile["personalDetail"].get(
+                "profilePictures"
+            )
+        ):
+            return next(
+                (pic.get("url") for pic in profile_pictures if pic.get("size") == "xl"),
+                None,
+            )
+
+        return super().entity_picture