Fix: differentiate shorts, lives and long videos

CHANGELOG.md

@@ -7,6 +7,11 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+### Fixed
+
+- Diffrentiate user uploaded shorts, lives, & long videos (#367)
+- corrected the short video resolution in the UI (#366)
+
 ### Changed
 
 - Raise exception if there are no videos in the playlists (#347)

scraper/src/youtube2zim/schemas.py

@@ -107,6 +107,9 @@
     joined_date: str
     collection_type: str
     main_playlist: str | None = None
+    user_long_uploads_playlist: str | None=None
+    user_short_uploads_playlist: str | None=None
+    user_lives_playlist: str | None=None
     playlist_count: int
 
 

scraper/src/youtube2zim/scraper.py

@@ -179,6 +179,9 @@
         # process-related
         self.playlists = []
         self.uploads_playlist_id = None
+        self.user_long_uploads_playlist_id = None
+        self.user_short_uploads_playlist_id = None
+        self.user_lives_playlist_id = None
         self.videos_ids = []
         self.video_ids_count = 0
         self.videos_processed = 0
@@ -590,6 +593,9 @@
             self.playlists,
             self.main_channel_id,
             self.uploads_playlist_id,
+            self.user_long_uploads_playlist_id,
+            self.user_short_uploads_playlist_id,
+            self.user_lives_playlist_id,
         ) = extract_playlists_details_from(self.collection_type, self.youtube_id)
 
     def extract_videos_list(self):
@@ -1077,6 +1083,7 @@
             author = videos_channels[video_id]
             subtitles_list = get_subtitles(video_id)
             channel_data = get_channel_json(author["channelId"])
+
             return Video(
                 id=video_id,
                 title=video["snippet"]["title"],
@@ -1187,6 +1194,9 @@
         home_playlist_list = []
 
         main_playlist_slug = None
+        user_long_uploads_playlist_slug = None
+        user_short_uploads_playlist_slug = None
+        user_lives_playlist_slug = None
         if len(self.playlists) > 0:
             main_playlist_slug = get_playlist_slug(
                 self.playlists[0]
@@ -1216,6 +1226,16 @@
             # modify playlist object for preview on homepage
             playlist_obj.videos = playlist_obj.videos[:12]
 
+            if playlist.playlist_id == self.user_long_uploads_playlist_id:
+                user_long_uploads_playlist_slug = (playlist_slug)
+
+            if playlist.playlist_id == self.user_short_uploads_playlist_id:
+                user_short_uploads_playlist_slug = (playlist_slug)
+
+            if playlist.playlist_id == self.user_lives_playlist_id:
+                user_lives_playlist_slug= (playlist_slug)
+
+
             if playlist.playlist_id == self.uploads_playlist_id:
                 main_playlist_slug = (
                     playlist_slug  # set uploads playlist as main playlist
@@ -1251,22 +1271,33 @@
 
         # write channel.json file
         channel_data = get_channel_json(self.main_channel_id)
+        channel_data_dict = {
+            "id":str(self.main_channel_id),
+            "title":str(self.title),
+            "description":str(self.description),
+            "channel_name":channel_data["snippet"]["title"],
+            "channel_description":channel_data["snippet"]["description"],
+            "profile_path":"profile.jpg",
+            "banner_path":"banner.jpg",
+            "collection_type":self.collection_type,
+            "main_playlist":main_playlist_slug,
+            "playlist_count":len(self.playlists),
+            "joined_date":channel_data["snippet"]["publishedAt"],
+            }
+
+        if user_long_uploads_playlist_slug is not None : 
+            channel_data_dict["user_long_uploads_playlist"] = user_long_uploads_playlist_slug
+
+        if user_short_uploads_playlist_slug is not None : 
+            channel_data_dict["user_short_uploads_playlist"] = user_short_uploads_playlist_slug
+
+        if user_lives_playlist_slug is not None : 
+            channel_data_dict["user_lives_playlist"] = user_lives_playlist_slug
+
         self.zim_file.add_item_for(
             path="channel.json",
             title=self.title,
-            content=Channel(
-                id=str(self.main_channel_id),
-                title=str(self.title),
-                description=str(self.description),
-                channel_name=channel_data["snippet"]["title"],
-                channel_description=channel_data["snippet"]["description"],
-                profile_path="profile.jpg",
-                banner_path="banner.jpg",
-                collection_type=self.collection_type,
-                main_playlist=main_playlist_slug,
-                playlist_count=len(self.playlists),
-                joined_date=channel_data["snippet"]["publishedAt"],
-            ).model_dump_json(by_alias=True, indent=2),
+            content = Channel(**channel_data_dict).model_dump_json(by_alias=True, indent=2, exclude_none=True),
             mimetype="application/json",
             is_front=False,
         )

scraper/src/youtube2zim/youtube.py

@@ -2,6 +2,7 @@
 # vim: ai ts=4 sts=4 et sw=4 nu
 
 from http import HTTPStatus
+from datetime import datetime
 
 import requests
 from dateutil import parser as dt_parser
@@ -80,6 +81,7 @@
         return False
 
 
+
 def get_channel_json(channel_id):
     """fetch or retieve-save and return the Youtube ChannelResult JSON"""
     fname = f"channel_{channel_id}"
@@ -319,6 +321,128 @@
     return dt_parser.parse(item["snippet"]["publishedAt"]).date() in date_range
 
 
+def get_user_short_uploads_playlist_id(channel_id):
+    '''Return the user's uploaded short playlist ID, or None if shorts are not available or if an error occurs'''
+
+    user_short_uploads_playlist_id = "UUSH" + channel_id[2:] # Generate the short playlist ID
+
+    '''Make the API request to get the playlist details to determine whether shorts are available on the channel'''
+
+    try:
+        req = requests.get(
+            PLAYLIST_API,
+            params={"id": user_short_uploads_playlist_id, "part": "snippet", "key": YOUTUBE.api_key},
+            timeout=REQUEST_TIMEOUT,
+        )
+
+        # Check for HTTP error response
+        if req.status_code >= HTTPStatus.BAD_REQUEST:
+            logger.error(f"HTTP {req.status_code} Error response: {req.text}")
+            req.raise_for_status()  # Raises an HTTPError if the status code is 4xx or 5xx
+
+        # Parse the response
+        response_json = req.json()
+        total_results = response_json.get("pageInfo", {}).get("totalResults", 0)
+        playlist_items = response_json.get("items", [])
+
+        # Check if there are no items or totalResults is 0 if yes then shorts not available
+        if total_results == 0 or not playlist_items:
+            logger.error(f"Short Playlist `{user_short_uploads_playlist_id}`: Not Found or No Shorts Available")
+            return None
+
+        # If everything is successful, return the short playlist ID
+        return user_short_uploads_playlist_id
+
+    except IndexError:
+        logger.error(f"User short uploads Playlist `{user_short_uploads_playlist_id}`: Not Found or No uploaded Shorts Available")
+        return None
+
+    except requests.RequestException as e:
+        logger.error(f"Request failed: {e}")
+        return None
+
+def get_user_long_uploads_playlist_id(channel_id):
+    '''Return the user's uploaded long videos playlist ID, or None if long videos are not available or if an error occurs'''
+
+    user_long_uploads_playlist_id = "UULF" + channel_id[2:] # Generate the long videos playlist ID
+
+    '''Make the API request to get the playlist details to determine whether long videos are available on the channel'''
+
+    try:
+        req = requests.get(
+            PLAYLIST_API,
+            params={"id": user_long_uploads_playlist_id, "part": "snippet", "key": YOUTUBE.api_key},
+            timeout=REQUEST_TIMEOUT,
+        )
+
+        # Check for HTTP error response
+        if req.status_code >= HTTPStatus.BAD_REQUEST:
+            logger.error(f"HTTP {req.status_code} Error response: {req.text}")
+            req.raise_for_status()  # Raises an HTTPError if the status code is 4xx or 5xx
+
+
+        # Parse the response
+        response_json = req.json()
+        total_results = response_json.get("pageInfo", {}).get("totalResults", 0)
+        playlist_items = response_json.get("items", [])
+
+        # Check if there are no items or totalResults is 0 if yes then long videos not available
+        if total_results == 0 or not playlist_items:
+            logger.error(f"User Long uploads Playlist `{user_long_uploads_playlist_id}`: Not Found or No uploaded long videos Available")
+            return None
+
+        # If everything is successful, return the long videos playlist ID
+        return user_long_uploads_playlist_id
+
+    except IndexError:
+        logger.error(f"Long videos Playlist `{user_long_uploads_playlist_id}`: Not Found or No long videos Available")
+        return None
+
+    except requests.RequestException as e:
+        logger.error(f"Request failed: {e}")
+        return None
+
+def get_user_lives_playlist_id(channel_id):
+    '''Return the user's lives playlist ID, or None if lives are not available or if an error occurs'''
+
+    user_lives_playlist_id = "UULV" + channel_id[2:] # Generate the lives playlist ID
+
+    '''Make the API request to get the playlist details to determine whether Lives are available on the channel'''
+
+    try:
+        req = requests.get(
+            PLAYLIST_API,
+            params={"id": user_lives_playlist_id, "part": "snippet", "key": YOUTUBE.api_key},
+            timeout=REQUEST_TIMEOUT,
+        )
+
+        # Check for HTTP error response
+        if req.status_code >= HTTPStatus.BAD_REQUEST:
+            logger.error(f"HTTP {req.status_code} Error response: {req.text}")
+            req.raise_for_status()  # Raises an HTTPError if the status code is 4xx or 5xx
+
+        # Parse the response
+        response_json = req.json()
+        total_results = response_json.get("pageInfo", {}).get("totalResults", 0)
+        playlist_items = response_json.get("items", [])
+
+        # Check if there are no items or totalResults is 0 if yes then lives not available
+        if total_results == 0 or not playlist_items:
+            logger.error(f"User lives Playlist `{user_lives_playlist_id}`: Not Found or No lives Available")
+            return None
+
+        # If everything is successful, return the live playlist ID
+        return user_lives_playlist_id
+
+    except IndexError:
+        logger.error(f"Live Playlist `{user_lives_playlist_id}`: Not Found or No lives Available")
+        return None
+
+    except requests.RequestException as e:
+        logger.error(f"Request failed: {e}")
+        return None
+
+
 def extract_playlists_details_from(collection_type, youtube_id):
     """prepare a list of Playlist from user request
 
@@ -335,6 +459,25 @@
 
         # retrieve list of playlists for that channel
         playlist_ids = [p["id"] for p in get_channel_playlists_json(main_channel_id)]
+
+        # Retrieve the shorts,long videos and lives playlist ID
+        user_long_uploads_playlist_id = get_user_long_uploads_playlist_id(main_channel_id)
+        user_short_uploads_playlist_id = get_user_short_uploads_playlist_id(main_channel_id)
+        user_lives_playlist_id = get_user_lives_playlist_id(main_channel_id)
+
+
+        if user_long_uploads_playlist_id is not None:
+            # include uploads long videos playlist (contains every long videos)
+            playlist_ids += [user_long_uploads_playlist_id] 
+
+        if user_short_uploads_playlist_id is not None:
+            # include uploads short playlist (contains every shorts)
+            playlist_ids += [user_short_uploads_playlist_id] 
+
+        if user_lives_playlist_id is not None:
+            # include lives playlist (contains every lives)
+            playlist_ids += [user_lives_playlist_id] 
+
         # we always include uploads playlist (contains everything)
         playlist_ids += [channel_json["contentDetails"]["relatedPlaylists"]["uploads"]]
         uploads_playlist_id = playlist_ids[-1]
@@ -349,4 +492,7 @@
         [Playlist.from_id(playlist_id) for playlist_id in dict.fromkeys(playlist_ids)],
         main_channel_id,
         uploads_playlist_id,
+        user_long_uploads_playlist_id,
+        user_short_uploads_playlist_id,
+        user_lives_playlist_id,
     )

zimui/src/assets/vjs-youtube.css

@@ -54,3 +54,38 @@
 .vjs-youtube .vjs-tech canvas {
   border-radius: 8px;
 }
+
+
+.video-js.vjs-fluid,
+.video-js.vjs-16-9,
+.video-js.vjs-4-3,
+video.video-js,
+video.vjs-tech {
+  max-height: calc(100vh - 64px);
+  position: relative !important;
+  width: 100%;
+  height: auto !important;
+  max-width: 100% !important;
+  padding-top: 0 !important;
+  line-height: 0;
+}
+.vjs-control-bar {
+  line-height: 1;
+}
+
+/* Fullscreen styles */
+.video-js.vjs-fullscreen {
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  background-color: black;
+  text-align: center;
+}
+
+.video-js.vjs-fullscreen video {
+  margin: auto;
+  width: auto !important;
+  height: 100% !important;
+  max-height: 100vh;
+  object-fit: contain;
+}

zimui/src/components/channel/ChannelHeader.vue

@@ -20,23 +20,34 @@ onMounted(async () => {
   }
 })
 
-const tabs = [
-  {
-    id: 0,
-    title: 'Videos',
-    to: { name: 'videos' }
-  },
-  {
-    id: 1,
-    title: 'Playlists',
-    to: { name: 'playlists' }
+// Computed tabs array based on store data
+const tabs = computed(() => {
+  const baseTabs = [
+    { id: 0, title: 'Home', to: { name: 'home' } }
+  ];
+
+  if (main.channel?.userLongUploadsPlaylist) {
+    baseTabs.push({ id: 1, title: 'Videos', to: { name: 'videos' } });
+  }
+
+  if (main.channel?.userShortUploadsPlaylist) {
+    baseTabs.push({ id: 2, title: 'Shorts', to: { name: 'shorts' } });
+  }
+
+  if (main.channel?.userLivesPlaylist) {
+    baseTabs.push({ id: 3, title: 'Lives', to: { name: 'lives' } });
   }
-]
+
+  baseTabs.push({ id: 4, title: 'Playlists', to: { name: 'playlists' } });
+
+  return baseTabs;
+});
+
 
 // Hide tabs if there is only one playlist
 const hideTabs = computed(() => main.channel?.playlistCount === 1)
 
-const tab = ref<number>(tabs[0].id)
+const tab = ref<number>(tabs.value[0]?.id || 0);
 </script>
 
 <template>