forkparser 2026.1.0__py3-none-any.whl

feedparser/namespaces/_base.py

@@ -0,0 +1,547 @@
+# Support for the Atom, RSS, RDF, and CDF feed formats
+# Copyright 2010-2025 Kurt McKee <contactme@kurtmckee.org>
+# Copyright 2002-2008 Mark Pilgrim
+# All rights reserved.
+#
+# This file is a part of feedparser.
+#
+# Redistribution and use in source and binary forms, with or without modification,
+# are permitted provided that the following conditions are met:
+#
+# * Redistributions of source code must retain the above copyright notice,
+#   this list of conditions and the following disclaimer.
+# * Redistributions in binary form must reproduce the above copyright notice,
+#   this list of conditions and the following disclaimer in the documentation
+#   and/or other materials provided with the distribution.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 'AS IS'
+# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+# ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+# LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+# CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+# SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+# INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+# CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+# ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+# POSSIBILITY OF SUCH DAMAGE.
+
+import copy
+
+from ..datetimes import _parse_date
+from ..urls import make_safe_absolute_uri
+from ..util import FeedParserDict
+
+
+class Namespace:
+    """Support for the Atom, RSS, RDF, and CDF feed formats.
+
+    The feed formats all share common elements, some of which have conflicting
+    interpretations. For simplicity, all of the base feed format support is
+    collected here.
+    """
+
+    supported_namespaces = {
+        "": "",
+        "http://backend.userland.com/rss": "",
+        "http://blogs.law.harvard.edu/tech/rss": "",
+        "http://purl.org/rss/1.0/": "",
+        "http://my.netscape.com/rdf/simple/0.9/": "",
+        "http://example.com/newformat#": "",
+        "http://example.com/necho": "",
+        "http://purl.org/echo/": "",
+        "uri/of/echo/namespace#": "",
+        "http://purl.org/pie/": "",
+        "http://purl.org/atom/ns#": "",
+        "http://www.w3.org/2005/Atom": "",
+        "http://purl.org/rss/1.0/modules/rss091#": "",
+    }
+
+    def _start_rss(self, attrs_d):
+        versionmap = {
+            "0.91": "rss091u",
+            "0.92": "rss092",
+            "0.93": "rss093",
+            "0.94": "rss094",
+        }
+
+        # If we're here then this is an RSS feed.
+        # If we don't have a version or have a version that starts with something
+        # other than RSS then there's been a mistake. Correct it.
+        if not self.version or not self.version.startswith("rss"):
+            attr_version = attrs_d.get("version", "")
+            version = versionmap.get(attr_version)
+            if version:
+                self.version = version
+            elif attr_version.startswith("2."):
+                self.version = "rss20"
+            else:
+                self.version = "rss"
+
+    def _start_channel(self, attrs_d):
+        self.infeed = 1
+        self._cdf_common(attrs_d)
+
+    def _cdf_common(self, attrs_d):
+        if "lastmod" in attrs_d:
+            self._start_modified({})
+            self.elementstack[-1][-1] = attrs_d["lastmod"]
+            self._end_modified()
+        if "href" in attrs_d:
+            self._start_link({})
+            self.elementstack[-1][-1] = attrs_d["href"]
+            self._end_link()
+
+    def _start_feed(self, attrs_d):
+        self.infeed = 1
+        versionmap = {"0.1": "atom01", "0.2": "atom02", "0.3": "atom03"}
+        if not self.version:
+            attr_version = attrs_d.get("version")
+            version = versionmap.get(attr_version)
+            if version:
+                self.version = version
+            else:
+                self.version = "atom"
+
+    def _end_channel(self):
+        self.infeed = 0
+
+    _end_feed = _end_channel
+
+    def _start_image(self, attrs_d):
+        context = self._get_context()
+        if not self.inentry:
+            context.setdefault("image", FeedParserDict())
+        self.inimage = 1
+        self.title_depth = -1
+        self.push("image", 0)
+
+    def _end_image(self):
+        self.pop("image")
+        self.inimage = 0
+
+    def _start_textinput(self, attrs_d):
+        context = self._get_context()
+        context.setdefault("textinput", FeedParserDict())
+        self.intextinput = 1
+        self.title_depth = -1
+        self.push("textinput", 0)
+
+    _start_textInput = _start_textinput
+
+    def _end_textinput(self):
+        self.pop("textinput")
+        self.intextinput = 0
+
+    _end_textInput = _end_textinput
+
+    def _start_author(self, attrs_d):
+        self.inauthor = 1
+        self.push("author", 1)
+        # Append a new FeedParserDict when expecting an author
+        context = self._get_context()
+        context.setdefault("authors", [])
+        context["authors"].append(FeedParserDict())
+
+    _start_managingeditor = _start_author
+
+    def _end_author(self):
+        self.pop("author")
+        self.inauthor = 0
+        self._sync_author_detail()
+
+    _end_managingeditor = _end_author
+
+    def _start_contributor(self, attrs_d):
+        self.incontributor = 1
+        context = self._get_context()
+        context.setdefault("contributors", [])
+        context["contributors"].append(FeedParserDict())
+        self.push("contributor", 0)
+
+    def _end_contributor(self):
+        self.pop("contributor")
+        self.incontributor = 0
+
+    def _start_name(self, attrs_d):
+        self.push("name", 0)
+
+    def _end_name(self):
+        value = self.pop("name")
+        if self.inpublisher:
+            self._save_author("name", value, "publisher")
+        elif self.inauthor:
+            self._save_author("name", value)
+        elif self.incontributor:
+            self._save_contributor("name", value)
+        elif self.intextinput:
+            context = self._get_context()
+            context["name"] = value
+
+    def _start_width(self, attrs_d):
+        self.push("width", 0)
+
+    def _end_width(self):
+        value = self.pop("width")
+        try:
+            value = int(value)
+        except ValueError:
+            value = 0
+        if self.inimage:
+            context = self._get_context()
+            context["width"] = value
+
+    def _start_height(self, attrs_d):
+        self.push("height", 0)
+
+    def _end_height(self):
+        value = self.pop("height")
+        try:
+            value = int(value)
+        except ValueError:
+            value = 0
+        if self.inimage:
+            context = self._get_context()
+            context["height"] = value
+
+    def _start_url(self, attrs_d):
+        self.push("href", 1)
+
+    _start_homepage = _start_url
+    _start_uri = _start_url
+
+    def _end_url(self):
+        value = self.pop("href")
+        if self.inauthor:
+            self._save_author("href", value)
+        elif self.incontributor:
+            self._save_contributor("href", value)
+
+    _end_homepage = _end_url
+    _end_uri = _end_url
+
+    def _start_email(self, attrs_d):
+        self.push("email", 0)
+
+    def _end_email(self):
+        value = self.pop("email")
+        if self.inpublisher:
+            self._save_author("email", value, "publisher")
+        elif self.inauthor:
+            self._save_author("email", value)
+        elif self.incontributor:
+            self._save_contributor("email", value)
+
+    def _start_subtitle(self, attrs_d):
+        self.push_content("subtitle", attrs_d, "text/plain", 1)
+
+    _start_tagline = _start_subtitle
+
+    def _end_subtitle(self):
+        self.pop_content("subtitle")
+
+    _end_tagline = _end_subtitle
+
+    def _start_rights(self, attrs_d):
+        self.push_content("rights", attrs_d, "text/plain", 1)
+
+    _start_copyright = _start_rights
+
+    def _end_rights(self):
+        self.pop_content("rights")
+
+    _end_copyright = _end_rights
+
+    def _start_item(self, attrs_d):
+        self.entries.append(FeedParserDict())
+        self.push("item", 0)
+        self.inentry = 1
+        self.guidislink = 0
+        self.title_depth = -1
+        id = self._get_attribute(attrs_d, "rdf:about")
+        if id:
+            context = self._get_context()
+            context["id"] = id
+        self._cdf_common(attrs_d)
+
+    _start_entry = _start_item
+
+    def _end_item(self):
+        self.pop("item")
+        self.inentry = 0
+        self.hasContent = 0
+
+    _end_entry = _end_item
+
+    def _start_language(self, attrs_d):
+        self.push("language", 1)
+
+    def _end_language(self):
+        self.lang = self.pop("language")
+
+    def _start_webmaster(self, attrs_d):
+        self.push("publisher", 1)
+
+    def _end_webmaster(self):
+        self.pop("publisher")
+        self._sync_author_detail("publisher")
+
+    def _start_published(self, attrs_d):
+        self.push("published", 1)
+
+    _start_issued = _start_published
+    _start_pubdate = _start_published
+
+    def _end_published(self):
+        value = self.pop("published")
+        self._save("published_parsed", _parse_date(value), overwrite=True)
+
+    _end_issued = _end_published
+    _end_pubdate = _end_published
+
+    def _start_updated(self, attrs_d):
+        self.push("updated", 1)
+
+    _start_modified = _start_updated
+    _start_lastbuilddate = _start_updated
+
+    def _end_updated(self):
+        value = self.pop("updated")
+        parsed_value = _parse_date(value)
+        self._save("updated_parsed", parsed_value, overwrite=True)
+
+    _end_modified = _end_updated
+    _end_lastbuilddate = _end_updated
+
+    def _start_created(self, attrs_d):
+        self.push("created", 1)
+
+    def _end_created(self):
+        value = self.pop("created")
+        self._save("created_parsed", _parse_date(value), overwrite=True)
+
+    def _start_expirationdate(self, attrs_d):
+        self.push("expired", 1)
+
+    def _end_expirationdate(self):
+        self._save("expired_parsed", _parse_date(self.pop("expired")), overwrite=True)
+
+    def _start_category(self, attrs_d):
+        term = attrs_d.get("term")
+        scheme = attrs_d.get("scheme", attrs_d.get("domain"))
+        label = attrs_d.get("label")
+        self._add_tag(term, scheme, label)
+        self.push("category", 1)
+
+    _start_keywords = _start_category
+
+    def _end_category(self):
+        value = self.pop("category")
+        if not value:
+            return
+        context = self._get_context()
+        tags = context["tags"]
+        if value and len(tags) and not tags[-1]["term"]:
+            tags[-1]["term"] = value
+        else:
+            self._add_tag(value, None, None)
+
+    _end_keywords = _end_category
+
+    def _start_cloud(self, attrs_d):
+        self._get_context()["cloud"] = FeedParserDict(attrs_d)
+
+    def _start_link(self, attrs_d):
+        attrs_d.setdefault("rel", "alternate")
+        if attrs_d["rel"] == "self":
+            attrs_d.setdefault("type", "application/atom+xml")
+        else:
+            attrs_d.setdefault("type", "text/html")
+        context = self._get_context()
+        attrs_d = self._enforce_href(attrs_d)
+        if "href" in attrs_d:
+            attrs_d["href"] = self.resolve_uri(attrs_d["href"])
+        if (
+            attrs_d.get("rel") == "alternate"
+            and self.map_content_type(attrs_d.get("type")) in self.html_types
+        ):
+            self.isentrylink = 1
+        expecting_text = self.infeed or self.inentry or self.insource
+        context.setdefault("links", [])
+        if not (self.inentry and self.inimage):
+            context["links"].append(FeedParserDict(attrs_d))
+        if "href" in attrs_d:
+            if self.isentrylink:
+                context["link"] = attrs_d["href"]
+        else:
+            self.push("link", expecting_text)
+
+    def _end_link(self):
+        self.pop("link")
+        self.isentrylink = 0
+
+    def _start_guid(self, attrs_d):
+        self.guidislink = attrs_d.get("ispermalink", "true") == "true"
+        self.push("id", 1)
+
+    _start_id = _start_guid
+
+    def _end_guid(self):
+        value = self.pop("id")
+        self._save("guidislink", self.guidislink and "link" not in self._get_context())
+        if self.guidislink:
+            # guid acts as link, but only if 'ispermalink' is not present or is 'true',
+            # and only if the item doesn't already have a link element
+            self._save("link", value)
+
+    _end_id = _end_guid
+
+    def _start_title(self, attrs_d):
+        if self.svgOK:
+            return self.unknown_starttag("title", list(attrs_d.items()))
+        self.push_content(
+            "title", attrs_d, "text/plain", self.infeed or self.inentry or self.insource
+        )
+
+    def _end_title(self):
+        if self.svgOK:
+            return
+        value = self.pop_content("title")
+        if not value:
+            return
+        self.title_depth = self.depth
+
+    def _start_description(self, attrs_d):
+        context = self._get_context()
+        if "summary" in context and not self.hasContent:
+            self._summaryKey = "content"
+            self._start_content(attrs_d)
+        else:
+            self.push_content(
+                "description",
+                attrs_d,
+                "text/html",
+                self.infeed or self.inentry or self.insource,
+            )
+
+    def _start_abstract(self, attrs_d):
+        self.push_content(
+            "description",
+            attrs_d,
+            "text/plain",
+            self.infeed or self.inentry or self.insource,
+        )
+
+    def _end_description(self):
+        if self._summaryKey == "content":
+            self._end_content()
+        else:
+            self.pop_content("description")
+        self._summaryKey = None
+
+    _end_abstract = _end_description
+
+    def _start_info(self, attrs_d):
+        self.push_content("info", attrs_d, "text/plain", 1)
+
+    _start_feedburner_browserfriendly = _start_info
+
+    def _end_info(self):
+        self.pop_content("info")
+
+    _end_feedburner_browserfriendly = _end_info
+
+    def _start_generator(self, attrs_d):
+        if attrs_d:
+            attrs_d = self._enforce_href(attrs_d)
+            if "href" in attrs_d:
+                attrs_d["href"] = self.resolve_uri(attrs_d["href"])
+        self._get_context()["generator_detail"] = FeedParserDict(attrs_d)
+        self.push("generator", 1)
+
+    def _end_generator(self):
+        value = self.pop("generator")
+        context = self._get_context()
+        if "generator_detail" in context:
+            context["generator_detail"]["name"] = value
+
+    def _start_summary(self, attrs_d):
+        context = self._get_context()
+        if "summary" in context and not self.hasContent:
+            self._summaryKey = "content"
+            self._start_content(attrs_d)
+        else:
+            self._summaryKey = "summary"
+            self.push_content(self._summaryKey, attrs_d, "text/plain", 1)
+
+    def _end_summary(self):
+        if self._summaryKey == "content":
+            self._end_content()
+        else:
+            self.pop_content(self._summaryKey or "summary")
+        self._summaryKey = None
+
+    def _start_enclosure(self, attrs_d):
+        attrs_d = self._enforce_href(attrs_d)
+        context = self._get_context()
+        attrs_d["rel"] = "enclosure"
+        context.setdefault("links", []).append(FeedParserDict(attrs_d))
+
+    def _start_source(self, attrs_d):
+        if "url" in attrs_d:
+            # This means that we're processing a source element from an RSS 2.0 feed
+            self.sourcedata["href"] = attrs_d["url"]
+        self.push("source", 1)
+        self.insource = 1
+        self.title_depth = -1
+
+    def _end_source(self):
+        self.insource = 0
+        value = self.pop("source")
+        if value:
+            self.sourcedata["title"] = value
+        self._get_context()["source"] = copy.deepcopy(self.sourcedata)
+        self.sourcedata.clear()
+
+    def _start_content(self, attrs_d):
+        self.hasContent = 1
+        self.push_content("content", attrs_d, "text/plain", 1)
+        src = attrs_d.get("src")
+        if src:
+            self.contentparams["src"] = src
+        self.push("content", 1)
+
+    def _start_body(self, attrs_d):
+        self.push_content("content", attrs_d, "application/xhtml+xml", 1)
+
+    _start_xhtml_body = _start_body
+
+    def _start_content_encoded(self, attrs_d):
+        self.hasContent = 1
+        self.push_content("content", attrs_d, "text/html", 1)
+
+    _start_fullitem = _start_content_encoded
+
+    def _end_content(self):
+        copyToSummary = self.map_content_type(self.contentparams.get("type")) in (
+            {"text/plain"} | self.html_types
+        )
+        value = self.pop_content("content")
+        if copyToSummary:
+            self._save("summary", value)
+
+    _end_body = _end_content
+    _end_xhtml_body = _end_content
+    _end_content_encoded = _end_content
+    _end_fullitem = _end_content
+
+    def _start_newlocation(self, attrs_d):
+        self.push("newlocation", 1)
+
+    def _end_newlocation(self):
+        url = self.pop("newlocation")
+        context = self._get_context()
+        # don't set newlocation if the context isn't right
+        if context is not self.feeddata:
+            return
+        context["newlocation"] = make_safe_absolute_uri(self.baseuri, url.strip())

feedparser/namespaces/admin.py

@@ -0,0 +1,53 @@
+# Support for the administrative elements extension
+# Copyright 2010-2025 Kurt McKee <contactme@kurtmckee.org>
+# Copyright 2002-2008 Mark Pilgrim
+# All rights reserved.
+#
+# This file is a part of feedparser.
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are met:
+#
+# * Redistributions of source code must retain the above copyright notice,
+#   this list of conditions and the following disclaimer.
+# * Redistributions in binary form must reproduce the above copyright notice,
+#   this list of conditions and the following disclaimer in the documentation
+#   and/or other materials provided with the distribution.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 'AS IS'
+# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+# ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+# LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+# CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+# SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+# INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+# CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+# ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+# POSSIBILITY OF SUCH DAMAGE.
+
+from ..util import FeedParserDict
+
+
+class Namespace:
+    # RDF Site Summary 1.0 Modules: Administrative
+    # http://web.resource.org/rss/1.0/modules/admin/
+
+    supported_namespaces = {
+        "http://webns.net/mvcb/": "admin",
+    }
+
+    def _start_admin_generatoragent(self, attrs_d):
+        self.push("generator", 1)
+        value = self._get_attribute(attrs_d, "rdf:resource")
+        if value:
+            self.elementstack[-1][2].append(value)
+        self.pop("generator")
+        self._get_context()["generator_detail"] = FeedParserDict({"href": value})
+
+    def _start_admin_errorreportsto(self, attrs_d):
+        self.push("errorreportsto", 1)
+        value = self._get_attribute(attrs_d, "rdf:resource")
+        if value:
+            self.elementstack[-1][2].append(value)
+        self.pop("errorreportsto")

feedparser/namespaces/cc.py

@@ -0,0 +1,70 @@
+# Support for the Creative Commons licensing extensions
+# Copyright 2010-2025 Kurt McKee <contactme@kurtmckee.org>
+# Copyright 2002-2008 Mark Pilgrim
+# All rights reserved.
+#
+# This file is a part of feedparser.
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are met:
+#
+# * Redistributions of source code must retain the above copyright notice,
+#   this list of conditions and the following disclaimer.
+# * Redistributions in binary form must reproduce the above copyright notice,
+#   this list of conditions and the following disclaimer in the documentation
+#   and/or other materials provided with the distribution.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 'AS IS'
+# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+# ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+# LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+# CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+# SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+# INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+# CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+# ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+# POSSIBILITY OF SUCH DAMAGE.
+
+from ..util import FeedParserDict
+
+
+class Namespace:
+    supported_namespaces = {
+        # RDF-based namespace
+        "http://creativecommons.org/ns#license": "cc",
+        # Old RDF-based namespace
+        "http://web.resource.org/cc/": "cc",
+        # RSS-based namespace
+        "http://cyber.law.harvard.edu/rss/creativeCommonsRssModule.html": (
+            "creativecommons"
+        ),
+        # Old RSS-based namespace
+        "http://backend.userland.com/creativeCommonsRssModule": "creativecommons",
+    }
+
+    def _start_cc_license(self, attrs_d):
+        context = self._get_context()
+        value = self._get_attribute(attrs_d, "rdf:resource")
+        attrs_d = FeedParserDict()
+        attrs_d["rel"] = "license"
+        if value:
+            attrs_d["href"] = value
+        context.setdefault("links", []).append(attrs_d)
+
+    def _start_creativecommons_license(self, attrs_d):
+        self.push("license", 1)
+
+    _start_creativeCommons_license = _start_creativecommons_license
+
+    def _end_creativecommons_license(self):
+        value = self.pop("license")
+        context = self._get_context()
+        attrs_d = FeedParserDict()
+        attrs_d["rel"] = "license"
+        if value:
+            attrs_d["href"] = value
+        context.setdefault("links", []).append(attrs_d)
+        del context["license"]
+
+    _end_creativeCommons_license = _end_creativecommons_license