This lesson shows you how you can create a new package based on the given one, which you’ll publish later to PyPI!
The first source code file we’ll look at is __main__.py. The double underscores indicate that this file has a special meaning in Python. Indeed, when running a package as a script with -m as above, Python executes the contents of the __main__.py file.
In other words, __main__.py acts as the entry point of our program and takes care of the main flow, calling other parts as needed:
Notice that main() is called on the last line. If we do not call main(), then our program would not do anything. As you saw earlier, the program can either list all articles or print one specific article. This is handled by the if-else inside main().
To read the URL to the feed from the configuration file, we use configparser and importlib.resources. The latter is used to import non-code (or resource) files from a package without having to worry about the full file path. It is especially helpful when publishing packages to PyPI where resource files might end up inside binary archives.
importlib.resources became a part of the standard library in Python 3.7. If you are using an older version of Python, you can use importlib_resources instead. This is a backport compatible with Python 2.7, and 3.4 and above. importlib_resources can be installed from PyPI:
See Barry Warzaw’s presentation at PyCon 2018 for more information.
Looking at __main__.py, you’ll see that two modules, feed and viewer, are imported and used to read from the feed and show the results. These modules do most of the actual work.
First consider feed.py. This file contains functions for reading from a web feed and parsing the result. Luckily there are already great libraries available to do this. feed.py depends on two modules that are already available on PyPI: feedparser and html2text.
feed.py contains several functions. We’ll discuss them one at a time.
To avoid reading from the web feed more than necessary, we first create a function that remembers the feed the first time it’s read:
feedparser.parse() reads a feed from the web and returns it in a structure that looks like a dictionary. To avoid downloading the feed more than once, it’s stored in _CACHED_FEEDS and reused for later calls to _feed(). Both _CACHED_FEEDS and _feed() are prefixed by an underscore to indicate that they are support objects not meant to be used directly.
We can get some basic information about the feed by looking in the .feed metadata. The following function picks out the title and link to the web site containing the feed:
In addition to .title and .link, attributes like .subtitle, .updated, and .id are also available.
The articles available in the feed can be found inside the .entries list. Article titles can be found with a list comprehension:
.entries lists the articles in the feed sorted chronologically, so that the newest article is .entries[0].
In order to get the contents of one article, we use its index in the .entries list as an article ID:
After picking the correct article out of the .entries list, we find the text of the article as HTML on line 28. Next, html2text does a decent job of translating the HTML into much more readable text. As the HTML doesn’t contain the title of the article, the title is added before returning.
RetroSearch is an open source project built by @garambo | Open a GitHub Issue
Search and Browse the WWW like it's 1997 | Search results from DuckDuckGo
HTML:
3.2
| Encoding:
UTF-8
| Version:
0.7.4