Started (incomplete) implementation of stream verification scheduler and endpoints

app/iptv/stream_manager.py

@@ -0,0 +1,151 @@
+import logging
+import random
+from typing import Optional
+
+from sqlalchemy.orm import Session
+
+from app.models.db import ChannelURL
+from app.utils.check_streams import StreamValidator
+from app.utils.database import get_db_session
+
+logger = logging.getLogger(__name__)
+
+
+class StreamManager:
+    """Service for managing and validating channel streams."""
+
+    def __init__(self, db_session: Optional[Session] = None):
+        """
+        Initialize StreamManager with optional database session.
+
+        Args:
+            db_session: Optional SQLAlchemy session. If None, will create a new one.
+        """
+        self.db = db_session if db_session else get_db_session()
+        self.validator = StreamValidator()
+
+    def get_streams_for_channel(self, channel_id: str) -> list[ChannelURL]:
+        """
+        Get all streams for a channel ordered by priority (lowest first),
+        with same-priority streams randomized.
+
+        Args:
+            channel_id: UUID of the channel to get streams for
+
+        Returns:
+            List of ChannelURL objects ordered by priority
+        """
+        try:
+            # Get all streams for channel ordered by priority
+            streams = (
+                self.db.query(ChannelURL)
+                .filter(ChannelURL.channel_id == channel_id)
+                .order_by(ChannelURL.priority_id)
+                .all()
+            )
+
+            # Group streams by priority and randomize same-priority streams
+            grouped = {}
+            for stream in streams:
+                if stream.priority_id not in grouped:
+                    grouped[stream.priority_id] = []
+                grouped[stream.priority_id].append(stream)
+
+            # Randomize same-priority streams and flatten
+            randomized_streams = []
+            for priority in sorted(grouped.keys()):
+                random.shuffle(grouped[priority])
+                randomized_streams.extend(grouped[priority])
+
+            return randomized_streams
+
+        except Exception as e:
+            logger.error(f"Error getting streams for channel {channel_id}: {str(e)}")
+            raise
+
+    def validate_and_select_stream(self, channel_id: str) -> Optional[str]:
+        """
+        Find and validate a working stream for the given channel.
+
+        Args:
+            channel_id: UUID of the channel to find a stream for
+
+        Returns:
+            URL of the first working stream found, or None if none found
+        """
+        try:
+            streams = self.get_streams_for_channel(channel_id)
+            if not streams:
+                logger.warning(f"No streams found for channel {channel_id}")
+                return None
+
+            working_stream = None
+
+            for stream in streams:
+                logger.info(f"Validating stream {stream.url} for channel {channel_id}")
+                is_valid, _ = self.validator.validate_stream(stream.url)
+
+                if is_valid:
+                    working_stream = stream
+                    break
+
+            if working_stream:
+                self._update_stream_status(working_stream, streams)
+                return working_stream.url
+            else:
+                logger.warning(f"No valid streams found for channel {channel_id}")
+                return None
+
+        except Exception as e:
+            logger.error(f"Error validating streams for channel {channel_id}: {str(e)}")
+            raise
+
+    def _update_stream_status(
+        self, working_stream: ChannelURL, all_streams: list[ChannelURL]
+    ) -> None:
+        """
+        Update in_use status for streams (True for working stream, False for others).
+
+        Args:
+            working_stream: The stream that was validated as working
+            all_streams: All streams for the channel
+        """
+        try:
+            for stream in all_streams:
+                stream.in_use = stream.id == working_stream.id
+
+            self.db.commit()
+            logger.info(
+                f"Updated stream status - set in_use=True for {working_stream.url}"
+            )
+
+        except Exception as e:
+            self.db.rollback()
+            logger.error(f"Error updating stream status: {str(e)}")
+            raise
+
+    def __del__(self):
+        """Close database session when StreamManager is destroyed."""
+        if hasattr(self, "db"):
+            self.db.close()
+
+
+def get_working_stream(
+    channel_id: str, db_session: Optional[Session] = None
+) -> Optional[str]:
+    """
+    Convenience function to get a working stream for a channel.
+
+    Args:
+        channel_id: UUID of the channel to get a stream for
+        db_session: Optional SQLAlchemy session
+
+    Returns:
+        URL of the first working stream found, or None if none found
+    """
+    manager = StreamManager(db_session)
+    try:
+        return manager.validate_and_select_stream(channel_id)
+    finally:
+        if db_session is None:  # Only close if we created the session
+            manager.__del__()