feat(python): add complete bindings for GeoRSS, Media RSS, Dublin Core, and Podcast 2.0

Phase 1: Python Bindings Implementation

New types:
- PyGeoLocation (geo_type, coordinates, srs_name)
- PyMediaThumbnail (url, width, height)
- PyMediaContent (url, type, filesize, width, height, duration)
- PyPodcastChapters (url, type)
- PyPodcastSoundbite (start_time, duration, title)
- PyPodcastEntryMeta (transcript, chapters, soundbite, person)

New Entry getters:
- geo, dc_creator, dc_date, dc_date_parsed, dc_rights, dc_subject
- media_thumbnails, media_content, podcast

New FeedMeta getters:
- geo

All types include __repr__ and __eq__ implementations.
Comprehensive test coverage with 23 new tests.

Author: bug-ops

crates/feedparser-rs-core/src/lib.rs

@@ -68,10 +68,10 @@ pub use options::ParseOptions;
 pub use parser::{detect_format, parse, parse_with_limits};
 pub use types::{
     Content, Enclosure, Entry, FeedMeta, FeedVersion, Generator, Image, ItunesCategory,
-    ItunesEntryMeta, ItunesFeedMeta, ItunesOwner, LimitedCollectionExt, Link, ParsedFeed, Person,
-    PodcastChapters, PodcastEntryMeta, PodcastFunding, PodcastMeta, PodcastPerson,
-    PodcastSoundbite, PodcastTranscript, PodcastValue, PodcastValueRecipient, Source, Tag,
-    TextConstruct, TextType, parse_duration, parse_explicit,
+    ItunesEntryMeta, ItunesFeedMeta, ItunesOwner, LimitedCollectionExt, Link, MediaContent,
+    MediaThumbnail, ParsedFeed, Person, PodcastChapters, PodcastEntryMeta, PodcastFunding,
+    PodcastMeta, PodcastPerson, PodcastSoundbite, PodcastTranscript, PodcastValue,
+    PodcastValueRecipient, Source, Tag, TextConstruct, TextType, parse_duration, parse_explicit,
 };
 
 pub use namespace::syndication::{SyndicationMeta, UpdatePeriod};

crates/feedparser-rs-py/pyproject.toml

@@ -34,3 +34,8 @@ Repository = "https://github.com/bug-ops/feedparser-rs"
 features = ["pyo3/extension-module"]
 python-source = "python"
 module-name = "feedparser_rs._feedparser_rs"
+
+[dependency-groups]
+dev = [
+    "pytest<9",
+]

crates/feedparser-rs-py/src/lib.rs

@@ -22,6 +22,20 @@ fn _feedparser_rs(m: &Bound<'_, PyModule>) -> PyResult<()> {
     m.add_function(wrap_pyfunction!(detect_format, m)?)?;
     m.add_class::<PyParsedFeed>()?;
     m.add_class::<PyParserLimits>()?;
+    m.add_class::<types::geo::PyGeoLocation>()?;
+    m.add_class::<types::media::PyMediaThumbnail>()?;
+    m.add_class::<types::media::PyMediaContent>()?;
+    m.add_class::<types::podcast::PyItunesFeedMeta>()?;
+    m.add_class::<types::podcast::PyItunesEntryMeta>()?;
+    m.add_class::<types::podcast::PyItunesOwner>()?;
+    m.add_class::<types::podcast::PyItunesCategory>()?;
+    m.add_class::<types::podcast::PyPodcastMeta>()?;
+    m.add_class::<types::podcast::PyPodcastTranscript>()?;
+    m.add_class::<types::podcast::PyPodcastFunding>()?;
+    m.add_class::<types::podcast::PyPodcastPerson>()?;
+    m.add_class::<types::podcast::PyPodcastChapters>()?;
+    m.add_class::<types::podcast::PyPodcastSoundbite>()?;
+    m.add_class::<types::podcast::PyPodcastEntryMeta>()?;
     m.add("__version__", env!("CARGO_PKG_VERSION"))?;
     Ok(())
 }

crates/feedparser-rs-py/src/types/entry.rs

@@ -3,7 +3,9 @@ use pyo3::prelude::*;
 
 use super::common::{PyContent, PyEnclosure, PyLink, PyPerson, PySource, PyTag, PyTextConstruct};
 use super::datetime::optional_datetime_to_struct_time;
-use super::podcast::{PyItunesEntryMeta, PyPodcastPerson, PyPodcastTranscript};
+use super::geo::PyGeoLocation;
+use super::media::{PyMediaContent, PyMediaThumbnail};
+use super::podcast::{PyItunesEntryMeta, PyPodcastEntryMeta, PyPodcastPerson, PyPodcastTranscript};
 
 #[pyclass(name = "Entry", module = "feedparser_rs")]
 #[derive(Clone)]
@@ -196,6 +198,13 @@ impl PyEntry {
             .map(|i| PyItunesEntryMeta::from_core(i.clone()))
     }
 
+    /// Returns podcast transcripts for this entry.
+    ///
+    /// Dual access pattern for feedparser compatibility:
+    /// - `entry.podcast_transcripts` - Direct access (this method)
+    /// - `entry.podcast.transcript` - Nested access via PodcastEntryMeta
+    ///
+    /// Both provide the same data. Use whichever pattern matches your code style.
     #[getter]
     fn podcast_transcripts(&self) -> Vec<PyPodcastTranscript> {
         self.inner
@@ -205,6 +214,13 @@ impl PyEntry {
             .collect()
     }
 
+    /// Returns podcast persons for this entry.
+    ///
+    /// Dual access pattern for feedparser compatibility:
+    /// - `entry.podcast_persons` - Direct access (this method)
+    /// - `entry.podcast.person` - Nested access via PodcastEntryMeta
+    ///
+    /// Both provide the same data. Use whichever pattern matches your code style.
     #[getter]
     fn podcast_persons(&self) -> Vec<PyPodcastPerson> {
         self.inner
@@ -219,6 +235,65 @@ impl PyEntry {
         self.inner.license.as_deref()
     }
 
+    #[getter]
+    fn geo(&self) -> Option<PyGeoLocation> {
+        self.inner
+            .geo
+            .as_ref()
+            .map(|g| PyGeoLocation::from_core(g.clone()))
+    }
+
+    #[getter]
+    fn dc_creator(&self) -> Option<&str> {
+        self.inner.dc_creator.as_deref()
+    }
+
+    #[getter]
+    fn dc_date(&self) -> Option<String> {
+        self.inner.dc_date.map(|dt| dt.to_rfc3339())
+    }
+
+    #[getter]
+    fn dc_date_parsed(&self, py: Python<'_>) -> PyResult<Option<Py<PyAny>>> {
+        optional_datetime_to_struct_time(py, &self.inner.dc_date)
+    }
+
+    #[getter]
+    fn dc_rights(&self) -> Option<&str> {
+        self.inner.dc_rights.as_deref()
+    }
+
+    #[getter]
+    fn dc_subject(&self) -> Vec<String> {
+        self.inner.dc_subject.clone()
+    }
+
+    #[getter]
+    fn media_thumbnails(&self) -> Vec<PyMediaThumbnail> {
+        self.inner
+            .media_thumbnails
+            .iter()
+            .map(|t| PyMediaThumbnail::from_core(t.clone()))
+            .collect()
+    }
+
+    #[getter]
+    fn media_content(&self) -> Vec<PyMediaContent> {
+        self.inner
+            .media_content
+            .iter()
+            .map(|c| PyMediaContent::from_core(c.clone()))
+            .collect()
+    }
+
+    #[getter]
+    fn podcast(&self) -> Option<PyPodcastEntryMeta> {
+        self.inner
+            .podcast
+            .as_ref()
+            .map(|p| PyPodcastEntryMeta::from_core(p.clone()))
+    }
+
     fn __repr__(&self) -> String {
         format!(
             "Entry(title='{}', id='{}')",

crates/feedparser-rs-py/src/types/feed_meta.rs

@@ -3,6 +3,7 @@ use pyo3::prelude::*;
 
 use super::common::{PyGenerator, PyImage, PyLink, PyPerson, PyTag, PyTextConstruct};
 use super::datetime::optional_datetime_to_struct_time;
+use super::geo::PyGeoLocation;
 use super::podcast::{PyItunesFeedMeta, PyPodcastMeta};
 use super::syndication::PySyndicationMeta;
 
@@ -236,6 +237,14 @@ impl PyFeedMeta {
         self.inner.dc_rights.as_deref()
     }
 
+    #[getter]
+    fn geo(&self) -> Option<PyGeoLocation> {
+        self.inner
+            .geo
+            .as_ref()
+            .map(|g| PyGeoLocation::from_core(g.clone()))
+    }
+
     fn __repr__(&self) -> String {
         format!(
             "FeedMeta(title='{}', link='{}')",

crates/feedparser-rs-py/src/types/geo.rs

@@ -0,0 +1,67 @@
+use feedparser_rs::namespace::georss::{GeoLocation as CoreGeoLocation, GeoType};
+use pyo3::prelude::*;
+
+/// Represents a GeoRSS geographic location.
+///
+/// GeoRSS is a namespace extension that adds geographic information to RSS feeds.
+/// Supports points, lines, polygons, and bounding boxes with coordinate data.
+#[pyclass(name = "GeoLocation", module = "feedparser_rs")]
+#[derive(Clone)]
+pub struct PyGeoLocation {
+    inner: CoreGeoLocation,
+}
+
+impl PyGeoLocation {
+    pub fn from_core(core: CoreGeoLocation) -> Self {
+        Self { inner: core }
+    }
+}
+
+#[pymethods]
+impl PyGeoLocation {
+    #[getter]
+    fn geo_type(&self) -> &str {
+        match self.inner.geo_type {
+            GeoType::Point => "point",
+            GeoType::Line => "line",
+            GeoType::Polygon => "polygon",
+            GeoType::Box => "box",
+        }
+    }
+
+    #[getter]
+    fn coordinates(&self) -> Vec<(f64, f64)> {
+        self.inner.coordinates.clone()
+    }
+
+    #[getter]
+    fn srs_name(&self) -> Option<&str> {
+        self.inner.srs_name.as_deref()
+    }
+
+    fn __repr__(&self) -> String {
+        match self.inner.geo_type {
+            GeoType::Point => {
+                if let Some(coord) = self.inner.coordinates.first() {
+                    format!(
+                        "GeoLocation(geo_type='point', coordinates=[({}, {})])",
+                        coord.0, coord.1
+                    )
+                } else {
+                    "GeoLocation(geo_type='point', coordinates=[])".to_string()
+                }
+            }
+            _ => format!(
+                "GeoLocation(geo_type='{}', coordinates={})",
+                self.geo_type(),
+                self.inner.coordinates.len()
+            ),
+        }
+    }
+
+    fn __eq__(&self, other: &Self) -> bool {
+        self.inner.geo_type == other.inner.geo_type
+            && self.inner.coordinates == other.inner.coordinates
+            && self.inner.srs_name == other.inner.srs_name
+    }
+}

crates/feedparser-rs-py/src/types/media.rs

@@ -0,0 +1,116 @@
+use feedparser_rs::{MediaContent as CoreMediaContent, MediaThumbnail as CoreMediaThumbnail};
+use pyo3::prelude::*;
+
+/// Represents a Media RSS thumbnail image.
+///
+/// Media RSS (MRSS) is a namespace extension for RSS that provides richer media
+/// content metadata. Thumbnails are preview images for media content.
+#[pyclass(name = "MediaThumbnail", module = "feedparser_rs")]
+#[derive(Clone)]
+pub struct PyMediaThumbnail {
+    inner: CoreMediaThumbnail,
+}
+
+impl PyMediaThumbnail {
+    pub fn from_core(core: CoreMediaThumbnail) -> Self {
+        Self { inner: core }
+    }
+}
+
+#[pymethods]
+impl PyMediaThumbnail {
+    #[getter]
+    fn url(&self) -> &str {
+        &self.inner.url
+    }
+
+    #[getter]
+    fn width(&self) -> Option<u32> {
+        self.inner.width
+    }
+
+    #[getter]
+    fn height(&self) -> Option<u32> {
+        self.inner.height
+    }
+
+    fn __repr__(&self) -> String {
+        format!(
+            "MediaThumbnail(url='{}', width={:?}, height={:?})",
+            self.inner.url, self.inner.width, self.inner.height
+        )
+    }
+
+    fn __eq__(&self, other: &Self) -> bool {
+        self.inner.url == other.inner.url
+            && self.inner.width == other.inner.width
+            && self.inner.height == other.inner.height
+    }
+}
+
+/// Represents a Media RSS content item.
+///
+/// Media RSS content elements describe actual media files (video, audio, images)
+/// with metadata like MIME type, file size, dimensions, and duration.
+#[pyclass(name = "MediaContent", module = "feedparser_rs")]
+#[derive(Clone)]
+pub struct PyMediaContent {
+    inner: CoreMediaContent,
+}
+
+impl PyMediaContent {
+    pub fn from_core(core: CoreMediaContent) -> Self {
+        Self { inner: core }
+    }
+}
+
+#[pymethods]
+impl PyMediaContent {
+    #[getter]
+    fn url(&self) -> &str {
+        &self.inner.url
+    }
+
+    #[getter]
+    #[pyo3(name = "type")]
+    fn content_type(&self) -> Option<&str> {
+        self.inner.content_type.as_deref()
+    }
+
+    #[getter]
+    fn filesize(&self) -> Option<u64> {
+        self.inner.filesize
+    }
+
+    #[getter]
+    fn width(&self) -> Option<u32> {
+        self.inner.width
+    }
+
+    #[getter]
+    fn height(&self) -> Option<u32> {
+        self.inner.height
+    }
+
+    #[getter]
+    fn duration(&self) -> Option<u64> {
+        self.inner.duration
+    }
+
+    fn __repr__(&self) -> String {
+        format!(
+            "MediaContent(url='{}', type='{}')",
+            self.inner.url,
+            self.inner.content_type.as_deref().unwrap_or("unknown")
+        )
+    }
+
+    fn __eq__(&self, other: &Self) -> bool {
+        self.inner.url == other.inner.url
+            && self.inner.content_type == other.inner.content_type
+            && self.inner.filesize == other.inner.filesize
+            && self.inner.width == other.inner.width
+            && self.inner.height == other.inner.height
+            && self.inner.duration == other.inner.duration
+    }
+}

crates/feedparser-rs-py/src/types/mod.rs

@@ -2,6 +2,8 @@ pub mod common;
 pub mod datetime;
 pub mod entry;
 pub mod feed_meta;
+pub mod geo;
+pub mod media;
 pub mod parsed_feed;
 pub mod podcast;
 pub mod syndication;