Add files via upload

Author: Vansmak

custom_components/mediarr/manager/radarr2.py

@@ -0,0 +1,114 @@
+"""Radarr2 integration for Mediarr."""
+from ..common.sensor import MediarrSensor 
+from datetime import datetime, timedelta 
+import async_timeout 
+import logging
+
+
+_LOGGER = logging.getLogger(__name__)
+
+class Radarr2MediarrSensor(MediarrSensor):
+    def __init__(self, session, api_key, url, max_items, days_to_check):
+        """Initialize the sensor."""
+        self._session = session
+        self._radarr2_api_key = api_key
+        self._url = url.rstrip('/')
+        self._max_items = max_items
+        self._days_to_check = days_to_check
+        self._name = "Radarr2 Mediarr"
+        self._state = 0
+        
+        
+
+    @property
+    def name(self):
+        """Return the name of the sensor."""
+        return self._name
+
+    @property
+    def unique_id(self):
+        """Return a unique ID."""
+        return f"radarr2_mediarr_{self._url}"
+
+    async def async_update(self):
+        """Update the sensor."""
+        try:
+            headers = {'X-Api-Key': self._radarr2_api_key}
+            now = datetime.now().astimezone()
+            max_date = now + timedelta(days=self._days_to_check)
+            
+            async with async_timeout.timeout(10):
+                async with self._session.get(
+                    f"{self._url}/api/v3/movie",
+                    headers=headers
+                ) as response:
+                    if response.status != 200:
+                        raise Exception(f"Failed to connect to Radarr2. Status: {response.status}")
+                    
+                    movies = await response.json()
+                    card_json = []
+                    upcoming_movies = []
+
+                    for movie in movies:
+                        release_dates = []
+                        for date_field, date_type in [
+                            ('digitalRelease', 'Digital'),
+                            ('physicalRelease', 'Physical'),
+                            ('inCinemas', 'Theaters')
+                        ]:
+                            if movie.get(date_field):
+                                try:
+                                    release_date = datetime.fromisoformat(
+                                        movie[date_field].replace('Z', '+00:00')
+                                    )
+                                    if not release_date.tzinfo:
+                                        release_date = release_date.replace(tzinfo=now.tzinfo)
+                                    if now < release_date <= max_date:
+                                        release_dates.append((date_type, release_date))
+                                except ValueError:
+                                    continue
+
+                        if release_dates:
+                            release_dates.sort(key=lambda x: x[1])
+                            release_type, release_date = release_dates[0]
+
+                            images = {img['coverType']: img['remoteUrl'] for img in movie.get('images', [])}
+                            
+                            movie_data = {
+                                "title": str(movie["title"]),
+                                "release": f"{release_type} - {release_date.strftime('%Y-%m-%d')}",
+                                "aired": release_date.strftime("%Y-%m-%d"),
+                                "year": str(movie["year"]),
+                                "poster": images.get('poster', ''),
+                                "fanart": images.get('fanart', ''),
+                                "banner": images.get('banner', ''),
+                                "genres": ", ".join(str(g) for g in movie.get("genres", [])[:3]),
+                                "runtime": str(movie.get("runtime", 0)),
+                                "rating": str(movie.get("ratings", {}).get("value", "")),
+                                "studio": str(movie.get("studio", "N/A")),
+                                "flag": 1
+                            }
+                            upcoming_movies.append(movie_data)
+
+                    upcoming_movies.sort(key=lambda x: x['aired'])
+                    card_json.extend(upcoming_movies[:self._max_items])
+
+                    if not card_json:
+                        card_json.append({
+                            'title_default': '$title',
+                            'line1_default': '$release',
+                            'line2_default': '$genres',
+                            'line3_default': '$rating - $runtime',
+                            'line4_default': '$studio',
+                            'icon': 'mdi:arrow-down-circle'
+                        })
+
+                    self._state = len(upcoming_movies)
+                    self._attributes = {'data': card_json}
+                    self._available = True
+
+        except Exception as err:
+            _LOGGER.error("Error updating Radarr2 sensor: %s", err)
+            self._state = 0
+            self._attributes = {'data': []}
+            self._available = False

custom_components/mediarr/manager/sonarr2.py

@@ -0,0 +1,116 @@
+"""Sonarr2 integration for Mediarr."""
+from ..common.sensor import MediarrSensor 
+from datetime import datetime, timedelta 
+import async_timeout 
+from zoneinfo import ZoneInfo 
+import logging
+
+
+_LOGGER = logging.getLogger(__name__)
+
+class Sonarr2MediarrSensor(MediarrSensor):
+    def __init__(self, session, api_key, url, max_items, days_to_check):
+        """Initialize the sensor."""
+        self._session = session
+        self._sonarr2_api_key = api_key
+        self._url = url.rstrip('/')
+        self._max_items = max_items
+        self._days_to_check = days_to_check
+        self._name = "Sonarr2 Mediarr"
+        self._state = 0
+        
+        
+
+    @property
+    def name(self):
+        """Return the name of the sensor."""
+        return self._name
+
+    @property
+    def unique_id(self):
+        """Return a unique ID."""
+        return f"sonarr2_mediarr_{self._url}"
+
+    def _format_date(self, date_str: str) -> str:
+        """Format date string."""
+        try:
+            return datetime.strptime(date_str, '%Y-%m-%d').strftime('%Y-%m-%d')
+        except ValueError:
+            return 'Unknown'
+
+    async def async_update(self):
+        """Update the sensor."""
+        try:
+            headers = {'X-Api-Key': self._sonarr2_api_key}
+            now = datetime.now(ZoneInfo('UTC'))
+            params = {
+                'start': now.strftime('%Y-%m-%d'),
+                'end': (now + timedelta(days=self._days_to_check)).strftime('%Y-%m-%d'),
+                'includeSeries': 'true'
+            }
+
+            async with async_timeout.timeout(10):
+                async with self._session.get(
+                    f"{self._url}/api/v3/calendar",
+                    headers=headers,
+                    params=params
+                ) as response:
+                    if response.status == 200:
+                        upcoming_episodes = await response.json()
+                        card_json = []
+                        shows_dict = {}
+
+                        for episode in upcoming_episodes:
+                            series = episode.get('series', {})
+                            air_date = self._format_date(episode['airDate'])
+                            
+                            if air_date == 'Unknown':
+                                continue
+
+                            series_id = series['id']
+                            images = {img['coverType']: img['remoteUrl'] for img in series.get('images', [])}
+                            
+                            show_data = {
+                                'title': f"{series['title']} - {episode.get('seasonNumber', 0):02d}x{episode.get('episodeNumber', 0):02d}",
+                                'episode': str(episode.get('title', 'Unknown')),
+                                'release': air_date,
+                                'number': f"S{episode.get('seasonNumber', 0):02d}E{episode.get('episodeNumber', 0):02d}",
+                                'runtime': str(series.get('runtime', 0)),
+                                'network': str(series.get('network', 'N/A')),
+                                'poster': images.get('poster', ''),
+                                'fanart': images.get('fanart', ''),
+                                'banner': images.get('banner', ''),
+                                'season': str(episode.get('seasonNumber', 0)),
+                                'details': f"{series['title']}\n{episode.get('title', 'Unknown')}\nS{episode.get('seasonNumber', 0):02d}E{episode.get('episodeNumber', 0):02d}",
+                                'flag': 1
+                            }
+
+                            # Take earliest episode air date for each series
+                            if series_id not in shows_dict or air_date < shows_dict[series_id]['release']:
+                                shows_dict[series_id] = show_data
+
+                        upcoming_shows = list(shows_dict.values())
+                        upcoming_shows.sort(key=lambda x: x['release'])
+                        card_json.extend(upcoming_shows[:self._max_items])
+
+                        if not card_json:
+                            card_json.append({
+                                'title_default': '$title',
+                                'line1_default': '$episode',
+                                'line2_default': '$release',
+                                'line3_default': '$number',
+                                'line4_default': '$runtime - $network',
+                                'icon': 'mdi:arrow-down-circle'
+                            })
+
+                        self._state = len(upcoming_shows)
+                        self._attributes = {'data': card_json}
+                        self._available = True
+                    else:
+                        raise Exception(f"Failed to connect to Sonarr2. Status: {response.status}")
+
+        except Exception as err:
+            _LOGGER.error("Error updating Sonarr2 sensor: %s", err)
+            self._state = 0
+            self._attributes = {'data': []}
+            self._available = False