Merge branch 'master' into feature/IHRACP-9133-ppp-python-dateutil

Author: jcarneyIHM

pypodcastparser/Item.py

@@ -174,7 +174,7 @@ def __init__(self, soup):
                 continue
             try:
                 # Using get instead of pop since there can be multiple transcript tags (meaning we don't want to get rid of method after use)
-                if c.name == "transcript":
+                if c.name == "transcript" or c.name == "alternateEnclosure":
                     tag_method = tag_methods.get((c.prefix, c.name))
                 else:
                     # Pop method to skip duplicated tag on invalid feeds
@@ -230,7 +230,10 @@ def to_dict(self):
         item["episode_title"] = self.title
         item["interactive"] = self.interactive
         item["external_url"] = self.enclosure_url
+        item["enclosure_type"] = self.enclosure_type
+        item["enclosure_length"] = self.enclosure_length
         item["transcription"] = self.podcast_transcript
+        item["alternate_enclosures"] = self.alternate_enclosures
 
         return item
 
@@ -536,7 +539,7 @@ def set_interactive(self, tag):
             raise InvalidPodcastFeed(
                 f"Invalid Podcast Feed, episode level ihr:interactive: {tag.string}, could not be parsed"
             )
-        
+
     def set_alternate_enclosure(self, tag):
         """Parses podcast:alternateEnclosure and its nested podcast:source elements.
 
@@ -611,4 +614,4 @@ def set_alternate_enclosure(self, tag):
         except Exception:
             raise InvalidPodcastFeed(
                 "Invalid Podcast Feed, episode level podcast:alternateEnclosure could not be parsed"
-            )
+            )

tests/test_feeds/alternate_enclosure.rss

@@ -0,0 +1,115 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<rss version="2.0" 
+     xmlns:itunes="http://www.itunes.com/dtds/podcast-1.0.dtd"
+     xmlns:podcast="https://podcastindex.org/namespace/1.0">
+    <channel>
+        <title>Alternate Enclosure Test Podcast</title>
+        <description>Test podcast for alternateEnclosure parsing</description>
+        <link>https://example.com</link>
+        <language>en-us</language>
+        <itunes:author>Test Author</itunes:author>
+        <itunes:explicit>no</itunes:explicit>
+        
+        <item>
+            <title>Episode with Multiple Alternate Enclosures</title>
+            <description>This episode has multiple media versions</description>
+            <pubDate>Tue, 07 Jan 2025 10:00:00 EST</pubDate>
+            <guid>episode-001</guid>
+            
+            <!-- Standard enclosure (required for backward compatibility) -->
+            <enclosure url="https://example.com/episode001.mp3" length="43200000" type="audio/mpeg" />
+            
+            <!-- Same content via multiple transports -->
+            <podcast:alternateEnclosure 
+                type="audio/mpeg" 
+                length="43200000" 
+                bitrate="128000" 
+                default="true" 
+                title="Standard MP3">
+                <podcast:source uri="https://example.com/episode001.mp3" />
+                <podcast:source uri="ipfs://QmdwGqd3d2gFPGeJNLLCshdiPert45fMu84552Y4XHTy4y" />
+                <podcast:source uri="https://example.com/episode001.torrent" contentType="application/x-bittorrent" />
+                <podcast:integrity type="sri" value="sha384-ExVqijpSE+cRZuKN5LoVBBsPA6dyjmRH5cXjqfiDD8fmtXi3pdb+qOiFvQdkWh1R" />
+            </podcast:alternateEnclosure>
+            
+            <!-- High quality Opus version -->
+            <podcast:alternateEnclosure 
+                type="audio/opus" 
+                length="32400000" 
+                bitrate="96000" 
+                title="High Quality Opus">
+                <podcast:source uri="https://example.com/episode001.opus" />
+                <podcast:source uri="ipfs://QmHighQualityOpusFile123456789" />
+            </podcast:alternateEnclosure>
+            
+            <!-- Video version at 1080p -->
+            <podcast:alternateEnclosure 
+                type="video/mp4" 
+                length="10562995" 
+                bitrate="681483.55" 
+                height="1080"
+                codecs="avc1.64001f, mp4a.40.2"
+                lang="en">
+                <podcast:source uri="https://example.com/episode001-1080.mp4" />
+                <podcast:source uri="ipfs://QmVideoFile1080pHashHere" />
+                <podcast:source uri="http://example.onion/episode001-1080.mp4" />
+            </podcast:alternateEnclosure>
+            
+            <!-- HLS streaming version -->
+            <podcast:alternateEnclosure 
+                type="application/x-mpegURL" 
+                length="10562995"
+                title="HLS Stream">
+                <podcast:source uri="https://example.com/episode001/master.m3u8" />
+            </podcast:alternateEnclosure>
+            
+            <itunes:duration>45:00</itunes:duration>
+            <itunes:explicit>no</itunes:explicit>
+        </item>
+        
+        <item>
+            <title>Episode with Behind the Scenes Content</title>
+            <description>This episode has main content plus bonus material</description>
+            <pubDate>Mon, 06 Jan 2025 10:00:00 EST</pubDate>
+            <guid>episode-002</guid>
+            
+            <!-- Standard enclosure -->
+            <enclosure url="https://example.com/episode002.mp3" length="36000000" type="audio/mpeg" />
+            
+            <!-- Main episode content -->
+            <podcast:alternateEnclosure 
+                type="audio/mpeg" 
+                length="36000000" 
+                bitrate="128000" 
+                default="true">
+                <podcast:source uri="https://example.com/episode002.mp3" />
+            </podcast:alternateEnclosure>
+            
+            <!-- Behind the scenes bonus content (different rel) -->
+            <podcast:alternateEnclosure 
+                type="audio/mpeg" 
+                length="12000000" 
+                bitrate="128000"
+                title="Behind the Scenes" 
+                rel="bonus">
+                <podcast:source uri="https://example.com/episode002-bts.mp3" />
+            </podcast:alternateEnclosure>
+            
+            <itunes:duration>37:30</itunes:duration>
+            <itunes:explicit>no</itunes:explicit>
+        </item>
+        
+        <item>
+            <title>Episode with No Alternate Enclosures</title>
+            <description>This episode only has standard enclosure</description>
+            <pubDate>Sun, 05 Jan 2025 10:00:00 EST</pubDate>
+            <guid>episode-003</guid>
+            
+            <!-- Only standard enclosure, no alternateEnclosure -->
+            <enclosure url="https://example.com/episode003.mp3" length="28800000" type="audio/mpeg" />
+            
+            <itunes:duration>30:00</itunes:duration>
+            <itunes:explicit>no</itunes:explicit>
+        </item>
+    </channel>
+</rss>

tests/test_pyPodcastParser.py

@@ -654,5 +654,160 @@ def test_invalid_episode_dates(self):
         )
 
 
+class TestAlternateEnclosureFeed(unittest.TestCase):
+    def setUp(self):
+        test_dir = os.path.dirname(__file__)
+        test_feeds_dir = os.path.join(test_dir, "test_feeds")
+        alt_enclosure_path = os.path.join(test_feeds_dir, "alternate_enclosure.rss")
+        alt_enclosure_file = open(alt_enclosure_path, "rb")
+        self.alt_enclosure_feed = alt_enclosure_file.read()
+        self.podcast = Podcast.Podcast(self.alt_enclosure_feed)
+
+    def test_item_count(self):
+        """Test that all three items are parsed"""
+        self.assertEqual(len(self.podcast.items), 3)
+
+    def test_first_item_has_alternate_enclosures(self):
+        """Test that first item has multiple alternate enclosures"""
+        item = self.podcast.items[0]
+        self.assertIsNotNone(item.alternate_enclosures)
+        self.assertEqual(len(item.alternate_enclosures), 4)
+
+    def test_standard_enclosure_still_works(self):
+        """Test that standard enclosure attributes are still parsed"""
+        item = self.podcast.items[0]
+        self.assertEqual(item.enclosure_url, "https://example.com/episode001.mp3")
+        self.assertEqual(item.enclosure_type, "audio/mpeg")
+        self.assertEqual(item.enclosure_length, 43200000)
+
+    def test_mp3_alternate_enclosure_attributes(self):
+        """Test MP3 alternate enclosure with default=true"""
+        item = self.podcast.items[0]
+        mp3_enclosure = item.alternate_enclosures[0]
+        
+        self.assertEqual(mp3_enclosure["mime_type"], "audio/mpeg")
+        self.assertEqual(mp3_enclosure["length"], 43200000)
+        self.assertEqual(mp3_enclosure["bitrate"], 128000.0)
+        self.assertEqual(mp3_enclosure["default"], True)
+        self.assertEqual(mp3_enclosure["title"], "Standard MP3")
+
+    def test_mp3_alternate_enclosure_sources(self):
+        """Test MP3 alternate enclosure has multiple sources"""
+        item = self.podcast.items[0]
+        mp3_enclosure = item.alternate_enclosures[0]
+        
+        self.assertEqual(len(mp3_enclosure["sources"]), 3)
+        
+        # Check HTTPS source - all sources should have the same integrity
+        self.assertEqual(mp3_enclosure["sources"][0]["uri"], "https://example.com/episode001.mp3")
+        self.assertIsNone(mp3_enclosure["sources"][0]["content_type"])
+        self.assertEqual(mp3_enclosure["sources"][0]["integrity_type"], "sri")
+        self.assertEqual(mp3_enclosure["sources"][0]["integrity_value"], "sha384-ExVqijpSE+cRZuKN5LoVBBsPA6dyjmRH5cXjqfiDD8fmtXi3pdb+qOiFvQdkWh1R")
+        
+        # Check IPFS source - should also have integrity
+        self.assertEqual(mp3_enclosure["sources"][1]["uri"], "ipfs://QmdwGqd3d2gFPGeJNLLCshdiPert45fMu84552Y4XHTy4y")
+        self.assertEqual(mp3_enclosure["sources"][1]["integrity_type"], "sri")
+        self.assertEqual(mp3_enclosure["sources"][1]["integrity_value"], "sha384-ExVqijpSE+cRZuKN5LoVBBsPA6dyjmRH5cXjqfiDD8fmtXi3pdb+qOiFvQdkWh1R")
+        
+        # Check torrent source - should also have integrity
+        self.assertEqual(mp3_enclosure["sources"][2]["uri"], "https://example.com/episode001.torrent")
+        self.assertEqual(mp3_enclosure["sources"][2]["content_type"], "application/x-bittorrent")
+        self.assertEqual(mp3_enclosure["sources"][2]["integrity_type"], "sri")
+        self.assertEqual(mp3_enclosure["sources"][2]["integrity_value"], "sha384-ExVqijpSE+cRZuKN5LoVBBsPA6dyjmRH5cXjqfiDD8fmtXi3pdb+qOiFvQdkWh1R")
+
+    def test_mp3_alternate_enclosure_integrity(self):
+        """Test MP3 alternate enclosure has integrity in all sources"""
+        item = self.podcast.items[0]
+        mp3_enclosure = item.alternate_enclosures[0]
+        
+        # Check that all sources have the same integrity values
+        for source in mp3_enclosure["sources"]:
+            self.assertIsNotNone(source["integrity_type"])
+            self.assertIsNotNone(source["integrity_value"])
+            self.assertEqual(source["integrity_type"], "sri")
+            self.assertEqual(source["integrity_value"], "sha384-ExVqijpSE+cRZuKN5LoVBBsPA6dyjmRH5cXjqfiDD8fmtXi3pdb+qOiFvQdkWh1R")
+
+    def test_opus_alternate_enclosure(self):
+        """Test Opus alternate enclosure parsing"""
+        item = self.podcast.items[0]
+        opus_enclosure = item.alternate_enclosures[1]
+        
+        self.assertEqual(opus_enclosure["mime_type"], "audio/opus")
+        self.assertEqual(opus_enclosure["length"], 32400000)
+        self.assertEqual(opus_enclosure["bitrate"], 96000.0)
+        self.assertEqual(opus_enclosure["title"], "High Quality Opus")
+        self.assertEqual(len(opus_enclosure["sources"]), 2)
+
+    def test_video_alternate_enclosure(self):
+        """Test video alternate enclosure with height, codecs, and lang"""
+        item = self.podcast.items[0]
+        video_enclosure = item.alternate_enclosures[2]
+        
+        self.assertEqual(video_enclosure["mime_type"], "video/mp4")
+        self.assertEqual(video_enclosure["length"], 10562995)
+        self.assertEqual(video_enclosure["bitrate"], 681483.55)
+        self.assertEqual(video_enclosure["height"], 1080)
+        self.assertEqual(video_enclosure["codecs"], "avc1.64001f, mp4a.40.2")
+        self.assertEqual(video_enclosure["lang"], "en")
+        self.assertEqual(len(video_enclosure["sources"]), 3)
+        
+        # Check Tor source
+        self.assertIn("example.onion", video_enclosure["sources"][2]["uri"])
+
+    def test_hls_alternate_enclosure(self):
+        """Test HLS streaming alternate enclosure"""
+        item = self.podcast.items[0]
+        hls_enclosure = item.alternate_enclosures[3]
+        
+        self.assertEqual(hls_enclosure["mime_type"], "application/x-mpegURL")
+        self.assertEqual(hls_enclosure["title"], "HLS Stream")
+        self.assertEqual(len(hls_enclosure["sources"]), 1)
+        self.assertIn("master.m3u8", hls_enclosure["sources"][0]["uri"])
+
+    def test_second_item_with_rel_attribute(self):
+        """Test second item with bonus content (different rel)"""
+        item = self.podcast.items[1]
+        self.assertEqual(len(item.alternate_enclosures), 2)
+        
+        # Check main content
+        main_enclosure = item.alternate_enclosures[0]
+        self.assertEqual(main_enclosure["default"], True)
+        self.assertIsNone(main_enclosure["rel"])
+        
+        # Check bonus content
+        bonus_enclosure = item.alternate_enclosures[1]
+        self.assertEqual(bonus_enclosure["title"], "Behind the Scenes")
+        self.assertEqual(bonus_enclosure["rel"], "bonus")
+        self.assertEqual(bonus_enclosure["length"], 12000000)
+
+    def test_third_item_no_alternate_enclosures(self):
+        """Test third item has no alternate enclosures"""
+        item = self.podcast.items[2]
+        self.assertEqual(len(item.alternate_enclosures), 0)
+        
+        # But standard enclosure should still work
+        self.assertEqual(item.enclosure_url, "https://example.com/episode003.mp3")
+        self.assertEqual(item.enclosure_length, 28800000)
+
+    def test_to_dict_includes_alternate_enclosures(self):
+        """Test that to_dict() includes alternate_enclosures"""
+        item = self.podcast.items[0]
+        item_dict = item.to_dict()
+        
+        self.assertIn("alternate_enclosures", item_dict)
+        self.assertEqual(len(item_dict["alternate_enclosures"]), 4)
+
+    def test_optional_attributes_can_be_none(self):
+        """Test that optional attributes are None when not present"""
+        item = self.podcast.items[0]
+        mp3_enclosure = item.alternate_enclosures[0]
+        
+        # These attributes weren't specified for MP3 enclosure
+        self.assertIsNone(mp3_enclosure["height"])
+        self.assertIsNone(mp3_enclosure["lang"])
+        self.assertIsNone(mp3_enclosure["codecs"])
+        self.assertIsNone(mp3_enclosure["rel"])
+
+
 if __name__ == "__main__":
     unittest.main()