# Support for the Atom, RSS, RDF, and CDF feed formats # Copyright 2010-2023 Kurt McKee # 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())