feat: working-ish app

Author: JacobCoffee

code/planet.py

@@ -72,7 +72,7 @@ def main():
             config_file = arg
 
     # Read the configuration file
-    config = configparser()
+    config = configparser.ConfigParser()
     config.read(config_file)
     if not config.has_section("Planet"):
         print("Configuration missing [Planet] section.", file=sys.stderr)

code/planet/__init__.py

@@ -10,36 +10,32 @@
 __authors__ = ["Scott James Remnant <scott@netsplit.com>", "Jeff Waugh <jdub@perkypants.org>"]
 __license__ = "Python"
 
-
 # Modules available without separate import
-import cache
-import feedparser
-import htmltmpl
-import sanitize
-
-try:
-    import logging
-except:
-    import compat_logging as logging
-
-# Limit the effect of "from planet import *"
-__all__ = ("cache", "feedparser", "htmltmpl", "logging", "Planet", "Channel", "NewsItem")
-
-
 import dbm
 import os
 import re
+import sys
 import time
 from hashlib import md5
 from html.parser import HTMLParser
 
+try:
+    import logging
+except:
+    import compat_logging as logging
+
 try:
     from xml.sax.saxutils import escape
 except:
 
     def escape(data):
         return data.replace("&", "&amp;").replace(">", "&gt;").replace("<", "&lt;")
 
+sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+from . import cache, feedparser, htmltmpl, sanitize
+
+# Limit the effect of "from planet import *"
+__all__ = ("cache", "feedparser", "htmltmpl", "logging", "Planet", "Channel", "NewsItem")
 
 # Version information (for generator headers)
 VERSION = "Planet/%s +http://www.planetplanet.org" % __version__
@@ -57,7 +53,6 @@ def escape(data):
 TIMEFMT_ISO = "%Y-%m-%dT%H:%M:%S+00:00"
 TIMEFMT_822 = "%a, %d %b %Y %H:%M:%S +0000"
 
-
 # Log instance to use here
 log = logging.getLogger("planet")
 try:
@@ -602,14 +597,18 @@ def update(self):
         updates the cached information about the feed and entries within it.
         """
         info = feedparser.parse(self.url, etag=self.url_etag, modified=self.url_modified, agent=self._planet.user_agent)
-        if info.has_key("status"):
+
+        if hasattr(info, "status"):
             self.url_status = str(info.status)
-        elif info.has_key("entries") and len(info.entries) > 0:
-            self.url_status = str(200)
-        elif info.bozo and info.bozo_exception.__class__.__name__ == "Timeout":
-            self.url_status = str(408)
+        elif hasattr(info, "entries") and info.entries:
+            self.url_status = "200"
+        elif hasattr(info, "bozo") and info.bozo and hasattr(info, "bozo_exception"):
+            if info.bozo_exception.__class__.__name__ == "Timeout":
+                self.url_status = "408"
+            else:
+                self.url_status = "500"
         else:
-            self.url_status = str(500)
+            self.url_status = "500"
 
         if self.url_status == "301" and (info.has_key("entries") and len(info.entries) > 0):
             log.warning("Feed has moved from <%s> to <%s>", self.url, info.url)
@@ -751,9 +750,9 @@ def update_entries(self, entries):
 
             # Hide excess items the first time through
             if (
-                self.last_updated is None
-                and self._planet.new_feed_items
-                and len(feed_items) > self._planet.new_feed_items
+                    self.last_updated is None
+                    and self._planet.new_feed_items
+                    and len(feed_items) > self._planet.new_feed_items
             ):
                 item.hidden = "yes"
                 log.debug("Marked <%s> as hidden (new feed)", entry_id)
@@ -853,9 +852,9 @@ def update(self, entry):
                 if entry[key].has_key("email") and entry[key].email:
                     self.set_as_string(key.replace("_detail", "_email"), entry[key].email)
                 if (
-                    entry[key].has_key("language")
-                    and entry[key].language
-                    and (not self._channel.has_key("language") or entry[key].language != self._channel.language)
+                        entry[key].has_key("language")
+                        and entry[key].language
+                        and (not self._channel.has_key("language") or entry[key].language != self._channel.language)
                 ):
                     self.set_as_string(key.replace("_detail", "_language"), entry[key].language)
             elif key.endswith("_parsed"):
@@ -877,9 +876,9 @@ def update(self, entry):
                     elif item.type == "text/plain":
                         item.value = escape(item.value)
                     if (
-                        item.has_key("language")
-                        and item.language
-                        and (not self._channel.has_key("language") or item.language != self._channel.language)
+                            item.has_key("language")
+                            and item.language
+                            and (not self._channel.has_key("language") or item.language != self._channel.language)
                     ):
                         self.set_as_string(key + "_language", item.language)
                     value += cache.utf8(item.value)

code/planet/cache.py

@@ -55,22 +55,19 @@ def cache_key(self, key):
 
     def cache_read(self):
         """Read information from the cache."""
-        if self._root:
-            keys_key = " keys"
-        else:
-            keys_key = self._id
+        keys_key = " keys" if self._root else self._id
 
-        if self._cache.has_key(keys_key):
+        if keys_key in self._cache:
             keys = self._cache[keys_key].split(" ")
         else:
             return
 
         for key in keys:
             cache_key = self.cache_key(key)
-            if not self._cached.has_key(key) or self._cached[key]:
+            if key not in self._cached or self._cached[key]:
                 # Key either hasn't been loaded, or is one for the cache
                 self._value[key] = self._cache[cache_key]
-                self._type[key] = self._cache[cache_key + " type"]
+                self._type[key] = self._cache[f"{cache_key} type"]
                 self._cached[key] = 1
 
     def cache_write(self, sync=1):
@@ -81,50 +78,42 @@ def cache_write(self, sync=1):
         for key in self.keys():
             cache_key = self.cache_key(key)
             if not self._cached[key]:
-                if self._cache.has_key(cache_key):
+                if cache_key in self._cache:
                     # Non-cached keys need to be cleared
                     del self._cache[cache_key]
-                    del self._cache[cache_key + " type"]
+                    del self._cache[f"{cache_key} type"]
                 continue
 
             keys.append(key)
             self._cache[cache_key] = self._value[key]
-            self._cache[cache_key + " type"] = self._type[key]
-
-        if self._root:
-            keys_key = " keys"
-        else:
-            keys_key = self._id
+            self._cache[f"{cache_key} type"] = self._type[key]
 
+        keys_key = " keys" if self._root else self._id
         self._cache[keys_key] = " ".join(keys)
         if sync:
             self._cache.sync()
 
     def cache_clear(self, sync=1):
         """Remove information from the cache."""
-        if self._root:
-            keys_key = " keys"
-        else:
-            keys_key = self._id
+        keys_key = " keys" if self._root else self._id
 
-        if self._cache.has_key(keys_key):
-            keys = self._cache[keys_key].split(" ")
-            del self._cache[keys_key]
-        else:
+        if keys_key not in self._cache:
             return
 
+        keys = self._cache[keys_key].split(" ")
+        del self._cache[keys_key]
         for key in keys:
             cache_key = self.cache_key(key)
             del self._cache[cache_key]
-            del self._cache[cache_key + " type"]
+            del self._cache[f"{cache_key} type"]
 
         if sync:
             self._cache.sync()
 
     def has_key(self, key):
         """Check whether the key exists."""
         key = key.replace(" ", "_")
-        return self._value.has_key(key)
+        return key in self._value
 
     def key_type(self, key):
         """Return the key type."""
@@ -196,9 +185,8 @@ def set_as_string(self, key, value, cached=1):
     def get_as_string(self, key):
         """Return the key as a string value."""
         key = key.replace(" ", "_")
-        if not self.has_key(key):
+        if key not in self._value:
             raise KeyError(key)
-
         return self._value[key]
 
     def set_as_date(self, key, value, cached=1):
@@ -216,11 +204,10 @@ def set_as_date(self, key, value, cached=1):
     def get_as_date(self, key):
         """Return the key as a date value."""
         key = key.replace(" ", "_")
-        if not self.has_key(key):
+        if key not in self._value:
             raise KeyError(key)
-
         value = self._value[key]
-        return tuple([int(i) for i in value.split(" ")])
+        return tuple(int(i) for i in value.split(" "))
 
     def set_as_null(self, key, value, cached=1):
         """Set the key to the null value.
@@ -235,13 +222,13 @@ def set_as_null(self, key, value, cached=1):
     def get_as_null(self, key):
         """Return the key as the null value."""
         key = key.replace(" ", "_")
-        if not self.has_key(key):
+        if key not in self._value:
             raise KeyError(key)
 
     def del_key(self, key):
         """Delete the given key."""
         key = key.replace(" ", "_")
-        if not self.has_key(key):
+        if key not in self._value:
             raise KeyError(key)
 
         del self._value[key]
@@ -270,10 +257,9 @@ def __setattr__(self, key, value):
             self.set(key, value)
 
     def __getattr__(self, key):
-        if self.has_key(key):
+        if key in self._value:
             return self.get(key)
-        else:
-            raise AttributeError(key)
+        raise AttributeError(key)
 
 
 def filename(directory, filename):
@@ -292,13 +278,6 @@ def filename(directory, filename):
 
 def utf8(value):
     """Return the value as a UTF-8 string."""
-    if type(value) == str:
-        return value.encode("utf-8")
-    else:
-        try:
-            return str(value, "utf-8").encode("utf-8")
-        except UnicodeError:
-            try:
-                return str(value, "iso-8859-1").encode("utf-8")
-            except UnicodeError:
-                return str(value, "ascii", "replace").encode("utf-8")
+    if isinstance(value, str):
+        return value
+    return value.decode("utf-8") if isinstance(value, bytes) else str(value)