Update

- rewriten to work with config flow
- added support for multiple instances
- added name parameter which is used for instance name and id (the unique id is generated from apikey)
- removed necessity to download images (also because of that removed "img_dir", "image_resolution", "download_images")
- removed "ssl_cert" because it was just bypass for ssl
- rewrited data parsing to work with xml instead of json

Author: Makhuta

README.md

@@ -17,33 +17,31 @@ Read through these two resources before posting issues to GitHub or the forums.
 ## Installation:
 1. Install this component by copying [these files](https://github.com/custom-components/sensor.plex_recently_added/tree/master/custom_components/plex_recently_added) to `custom_components/plex_recently_added/`.
 2. Install the card: [Upcoming Media Card](https://github.com/custom-cards/upcoming-media-card)
-3. Add the code to your `configuration.yaml` using the config options below.
-4. Add the code for the card to your `ui-lovelace.yaml`.
-5. **You will need to restart after installation for the component to start working.**
-
-### Options
-
-| key              | default                             | required | description                                                                                                                                    |
-| ---------------- | ----------------------------------- | -------- | ---------------------------------------------------------------------------------------------------------------------------------------------- |
-| name             | Plex_Recently_Added                 | no       | Name of the sensor. Useful to make multiple sensors with different libraries.                                                                  |
-| token            |                                     | yes      | Your Plex token [(Find your Plex token)](https://support.plex.tv/articles/204059436-finding-an-authentication-token-x-plex-token/)             |
-| host             | localhost                           | yes      | The host Plex is running on.                                                                                                                   |
-| port             | 32400                               | yes      | The port Plex is running on.                                                                                                                   |
-| ssl              | false                               | no       | Set to true if you use SSL to access Plex.                                                                                                     |
-| max              | 5                                   | no       | Max number of items to show in sensor.                                                                                                         |
-| on_deck          | False                               | no       | Set to true to show "on deck" items.                                                                                                           |
-| download_images  | true                                | no       | Setting this to false will turn off downloading of images, but will require certain Plex settings to work. See below.                          |
-| img_dir          | '/upcoming-media-card-images/plex/' | no       | This option allows you to choose a custom directory to store images in if you enable download_images. Directory must start and end with a `/`. |
-| ssl_cert         | false                               | no       | If you provide your own SSL certificate in Plex's network settings set this to true.                                                           |
-| section_types    | movie, show                         | no       | Allows you to specify which section types to consider [movie, show].                                                                           |
-| image_resolution | 200                                 | no       | Allows you to change the resolution of the generated images (in px), useful to display higher quality images as a background somewhere.        |
-| exclude_keywords |                                     | no       | Allows you to specify a list of keywords to be exclude from the sensor if in the title.                                                        |
-
-#### By default this addon automatically downloads images from Plex to your /www/custom-lovelace/upcoming-media-card/ directory. The directory is automatically created & only images reported in the upcoming list are downloaded. Images are small in size and are removed automatically when no longer needed. Currently & unfortunately, this may not work on all systems.
-
-#### If you prefer to not download the images you may set download_images to false, but you either have to set "Secure connections" to "preferred" or "disabled" (no SSL) or have a custom certificate set (these options are found in your Plex server's network settings). This is needed because the default SSL certificate supplied by Plex is for their own domain and not for your Plex server. Your server also needs to be "fully accessible outside your network" if you wish to be able to see images remotely. If your Plex server provides it's own certificate you only need to set ssl_cert to true and download_images to false.
-
-</br></br>
+3. Add the code for the card to your `ui-lovelace.yaml`.
+4. **You will need to restart after installation for the component to start working.**
+
+### Adding device
+To add the **Plex Recently added** integration to your Home Assistant, use this My button:
+
+<a href="https://my.home-assistant.io/redirect/config_flow_start?domain=plex_recently_added" class="my badge" target="_blank"><img src="https://my.home-assistant.io/badges/config_flow_start.svg"></a>
+
+<details><summary style="list-style: none"><h3><b style="cursor: pointer">Manual configuration steps</b></h3></summary>
+
+If the above My button doesn’t work, you can also perform the following steps manually:
+
+- Browse to your Home Assistant instance.
+
+- Go to [Settings > Devices & Services](https://my.home-assistant.io/redirect/integrations/).
+
+- In the bottom right corner, select the [Add Integration button.](https://my.home-assistant.io/redirect/config_flow_start?domain=plex_recently_added)
+
+- From the list, select **Plex Recently added**.
+
+- Follow the instructions on screen to complete the setup.
+</details>
+
+The number of items in sensor, library types, libraries in general, excluded words and show "on deck" options can be changed later.
+
 **Do not just copy examples, please use config options above to build your own!**
 ### Sample for minimal config needed in configuration.yaml:
 ```yaml

custom_components/plex_recently_added/__init__.py

@@ -1 +1,75 @@
+from homeassistant.config_entries import ConfigEntry
+from homeassistant.const import Platform
+from homeassistant.core import HomeAssistant
+from homeassistant.exceptions import ConfigEntryNotReady
+from homeassistant.const import (
+    CONF_API_KEY, 
+    CONF_HOST, 
+    CONF_PORT, 
+    CONF_SSL
+    )
 
+from .const import (
+    DOMAIN, 
+    CONF_TOKEN,
+    CONF_MAX,
+    CONF_SECTION_TYPES,
+    CONF_SECTION_LIBRARIES,
+    CONF_EXCLUDE_KEYWORDS,
+    CONF_ON_DECK,
+    CONF_LOCAL
+    )
+
+
+from .coordinator import PlexDataCoordinator
+from .helpers import setup_client
+from .plex_api import (
+    FailedToLogin,
+)
+
+
+PLATFORMS = [
+    Platform.SENSOR
+]
+
+async def async_setup_entry(hass: HomeAssistant, config_entry: ConfigEntry) -> bool:
+    try:
+        client = await hass.async_add_executor_job(
+            setup_client,
+            hass,
+            config_entry.data[CONF_SSL],
+            config_entry.data[CONF_API_KEY],
+            config_entry.data[CONF_MAX],
+            config_entry.data[CONF_ON_DECK],
+            config_entry.data[CONF_HOST],
+            config_entry.data[CONF_PORT],
+            config_entry.data.get(CONF_SECTION_TYPES, []),
+            config_entry.data.get(CONF_SECTION_LIBRARIES, []),
+            config_entry.data.get(CONF_EXCLUDE_KEYWORDS, []),
+            config_entry.data[CONF_LOCAL],
+        )
+    except FailedToLogin as err:
+        raise ConfigEntryNotReady("Failed to Log-in") from err
+    coordinator = PlexDataCoordinator(hass, client)
+
+    await coordinator.async_config_entry_first_refresh()
+    hass.data.setdefault(DOMAIN, {})[config_entry.entry_id] = coordinator
+
+    await hass.config_entries.async_forward_entry_setups(config_entry, PLATFORMS)
+    config_entry.async_on_unload(config_entry.add_update_listener(update_listener))
+
+    return True
+
+async def async_unload_entry(hass: HomeAssistant, config_entry: ConfigEntry) -> bool:
+    """Unload Plex config entry."""
+    if unload_ok := await hass.config_entries.async_unload_platforms(
+        config_entry, PLATFORMS
+    ):
+        del hass.data[DOMAIN][config_entry.entry_id]
+        if not hass.data[DOMAIN]:
+            del hass.data[DOMAIN]
+    return unload_ok
+
+async def update_listener(hass: HomeAssistant, config_entry: ConfigEntry) -> None:
+    """Handle options update."""
+    await hass.config_entries.async_reload(config_entry.entry_id)

custom_components/plex_recently_added/config_flow.py

@@ -0,0 +1,90 @@
+from typing import Any
+
+import voluptuous as vol
+
+from homeassistant.helpers.selector import (
+    SelectSelector,
+    SelectSelectorConfig,
+    SelectSelectorMode,
+    TextSelector,
+    TextSelectorConfig
+)
+from homeassistant.config_entries import ConfigEntry
+from homeassistant.core import callback
+from homeassistant.config_entries import ConfigFlow
+from homeassistant.const import (
+    CONF_API_KEY, 
+    CONF_NAME, 
+    CONF_HOST, 
+    CONF_PORT, 
+    CONF_SSL
+    )
+
+from .const import (
+    DOMAIN, 
+    DEFAULT_NAME,
+    CONF_MAX,
+    CONF_SECTION_TYPES,
+    ALL_SECTION_TYPES,
+    CONF_SECTION_LIBRARIES,
+    CONF_EXCLUDE_KEYWORDS,
+    CONF_ON_DECK,
+    CONF_LOCAL
+    )
+
+from .helpers import setup_client
+from .plex_api import (
+    FailedToLogin,
+)
+from .options_flow import PlexOptionFlow
+
+PLEX_SCHEMA = vol.Schema({
+    vol.Optional(CONF_NAME, default=''): vol.All(str),
+    vol.Required(CONF_HOST, default='localhost'): vol.All(str),
+    vol.Required(CONF_PORT, default=32400): vol.All(vol.Coerce(int), vol.Range(min=0)),
+    vol.Required(CONF_API_KEY): vol.All(str),
+    vol.Optional(CONF_SSL, default=False): vol.All(bool),
+    vol.Optional(CONF_LOCAL, default=False): vol.All(bool),
+    vol.Optional(CONF_MAX, default=5): vol.All(vol.Coerce(int), vol.Range(min=0)),
+    vol.Optional(CONF_ON_DECK, default=False): vol.All(bool),
+    vol.Optional(CONF_SECTION_TYPES, default={"movie", "show"}): SelectSelector(SelectSelectorConfig(options=ALL_SECTION_TYPES, mode=SelectSelectorMode.DROPDOWN ,multiple=True)),
+    vol.Optional(CONF_SECTION_LIBRARIES): TextSelector(TextSelectorConfig(multiple=True, multiline=False)),
+    vol.Optional(CONF_EXCLUDE_KEYWORDS): TextSelector(TextSelectorConfig(multiple=True, multiline=False)),
+})
+
+class PlexConfigFlow(ConfigFlow, domain=DOMAIN):
+    """Config flow for the Plex integration."""
+    @staticmethod
+    @callback
+    def async_get_options_flow(config_entry: ConfigEntry) -> PlexOptionFlow:
+        return PlexOptionFlow(config_entry)
+
+    async def async_step_user(
+        self, user_input: dict[str, Any] | None = None
+    ):
+        errors = {}
+
+        if user_input is not None:
+            self._async_abort_entries_match({CONF_API_KEY: user_input[CONF_API_KEY]})
+            try:
+                await self.hass.async_add_executor_job(
+                    setup_client,
+                    self.hass,
+                    user_input[CONF_SSL],
+                    user_input[CONF_API_KEY],
+                    user_input[CONF_MAX],
+                    user_input[CONF_ON_DECK],
+                    user_input[CONF_HOST],
+                    user_input[CONF_PORT],
+                    user_input.get(CONF_SECTION_TYPES, []),
+                    user_input.get(CONF_SECTION_LIBRARIES, []),
+                    user_input.get(CONF_EXCLUDE_KEYWORDS, []),
+                    user_input[CONF_LOCAL],
+                )
+            except FailedToLogin as err:
+                errors = {'base': 'failed_to_login'}
+            else:
+                return self.async_create_entry(title=user_input[CONF_NAME] if len(user_input[CONF_NAME]) > 0 else DEFAULT_NAME, data=user_input)
+
+        schema = self.add_suggested_values_to_schema(PLEX_SCHEMA, user_input)
+        return self.async_show_form(step_id="user", data_schema=schema, errors=errors)

custom_components/plex_recently_added/const.py

@@ -0,0 +1,24 @@
+from typing import Final
+
+DOMAIN: Final = "plex_recently_added"
+
+
+DEFAULT_NAME: Final = 'Plex Recently Added'
+CONF_TOKEN: Final = 'token'
+CONF_MAX: Final = 'max'
+CONF_SECTION_TYPES: Final = 'section_types'
+ALL_SECTION_TYPES: Final = ["movie", "show", "artist", "photo"]
+CONF_SECTION_LIBRARIES: Final = 'section_libraries'
+CONF_EXCLUDE_KEYWORDS: Final = 'exclude_keywords'
+CONF_ON_DECK: Final = 'on_deck'
+CONF_LOCAL: Final = 'is_local'
+
+
+DEFAULT_PARSE_DICT: Final = {
+    'title_default': '$title',
+    'line1_default': '$episode',
+    'line2_default': '$release',
+    'line3_default': '$number - $rating - $runtime',
+    'line4_default': '$genres',
+    'icon': 'mdi:eye-off'
+}

custom_components/plex_recently_added/coordinator.py

@@ -0,0 +1,33 @@
+from datetime import timedelta
+import logging
+from typing import Dict, Any
+
+from homeassistant.helpers.update_coordinator import DataUpdateCoordinator
+from homeassistant.core import HomeAssistant
+from homeassistant.exceptions import ConfigEntryError
+
+from .const import DOMAIN
+from .plex_api import (
+    PlexApi,
+    FailedToLogin,
+)
+
+_LOGGER = logging.getLogger(__name__)
+
+class PlexDataCoordinator(DataUpdateCoordinator[Dict[str, Any]]):
+    def __init__(self, hass: HomeAssistant, client: PlexApi):
+        self._client = client
+
+        super().__init__(
+            hass,
+            _LOGGER,
+            name=DOMAIN,
+            update_method=self._async_update_data,
+            update_interval=timedelta(minutes=10),
+        )
+    
+    async def _async_update_data(self) -> Dict[str, Any]:
+        try:
+            return await self.hass.async_add_executor_job(self._client.update)
+        except FailedToLogin:
+            raise ConfigEntryError("Failed to Log-in") from err

custom_components/plex_recently_added/helpers.py

@@ -0,0 +1,20 @@
+from homeassistant.core import HomeAssistant
+from .plex_api import PlexApi
+
+def setup_client(
+    hass: HomeAssistant,
+    ssl: bool,
+    token: str,
+    max: int,
+    on_deck: bool,
+    host: str,
+    port: int,
+    section_types: list,
+    section_libraries: list,
+    exclude_keywords: list,
+    is_local: bool,
+    ):
+    client = PlexApi(hass, ssl, token, max, on_deck, host, port, section_types, section_libraries, exclude_keywords, is_local)
+
+    client.update()
+    return client

custom_components/plex_recently_added/manifest.json

@@ -2,6 +2,7 @@
   "domain": "plex_recently_added",
   "name": "Plex Recently Added",
   "codeowners": ["@maykar"],
+  "config_flow": true,
   "dependencies": [],
   "documentation": "https://github.com/custom-components/sensor.plex_recently_added",
   "iot_class": "local_polling",

custom_components/plex_recently_added/options_flow.py

@@ -0,0 +1,60 @@
+from typing import Any
+from homeassistant.config_entries import OptionsFlow, ConfigEntry, ConfigFlowResult
+import voluptuous as vol
+
+from homeassistant.helpers.selector import (
+    SelectSelector,
+    SelectSelectorConfig,
+    SelectSelectorMode,
+    TextSelector,
+    TextSelectorConfig
+)
+
+from .const import (
+    DOMAIN, 
+    CONF_SECTION_TYPES,
+    CONF_SECTION_LIBRARIES,
+    ALL_SECTION_TYPES,
+    CONF_EXCLUDE_KEYWORDS,
+    CONF_MAX,
+    CONF_ON_DECK,
+    )
+
+
+class PlexOptionFlow(OptionsFlow):
+    def __init__(self, config_entry: ConfigEntry) -> None:
+        self._config_entry = config_entry
+
+
+    async def async_step_init(self, user_input: dict[str, Any] | None = None) -> ConfigFlowResult:
+        errors = {}
+
+        coordinator = self.hass.data[DOMAIN][self._config_entry.entry_id]
+
+        if user_input is not None:
+            # Validate and process user input here
+            updated_data = {
+                **self._config_entry.data,
+                CONF_MAX: user_input.get(CONF_MAX, 5),
+                CONF_SECTION_TYPES: user_input.get(CONF_SECTION_TYPES, []),
+                CONF_SECTION_LIBRARIES: user_input.get(CONF_SECTION_LIBRARIES, []),
+                CONF_EXCLUDE_KEYWORDS: user_input.get(CONF_EXCLUDE_KEYWORDS, []),
+                CONF_ON_DECK: user_input.get(CONF_ON_DECK, False),
+            }
+            self._config_entry.data = updated_data
+
+            return self.async_create_entry(title="", data=updated_data)
+
+        PLEX_SCHEMA = vol.Schema({
+            vol.Optional(CONF_MAX, default=self._config_entry.data[CONF_MAX]): vol.All(vol.Coerce(int), vol.Range(min=0)),
+            vol.Optional(CONF_SECTION_TYPES, default=self._config_entry.data.get(CONF_SECTION_TYPES, [])): SelectSelector(SelectSelectorConfig(options=ALL_SECTION_TYPES ,multiple=True, mode=SelectSelectorMode.DROPDOWN)),
+            vol.Optional(CONF_SECTION_LIBRARIES, default=self._config_entry.data.get(CONF_SECTION_LIBRARIES, [])): SelectSelector(SelectSelectorConfig(options=[str(item) for item in coordinator.data["libraries"]] ,multiple=True, mode=SelectSelectorMode.DROPDOWN)),
+            vol.Optional(CONF_EXCLUDE_KEYWORDS, default=self._config_entry.data.get(CONF_EXCLUDE_KEYWORDS, [])): TextSelector(TextSelectorConfig(multiple=True, multiline=False)),
+            vol.Optional(CONF_ON_DECK, default=self._config_entry.data.get(CONF_ON_DECK, False)): vol.All(bool),
+        })
+
+        # Display a form to gather user input
+        return self.async_show_form(step_id="init", data_schema=PLEX_SCHEMA, errors=errors)
+
+def keys(d) -> list:
+    return [i for i in d.keys()]