Provided by: feed2exec_0.15.0_all bug


       feed2exec - The programmable feed reader


       feed2exec {add,ls,rm,fetch,import,export}


       This  command  will  take a configured set of feeds and fire specific plugin for every new
       item found in the feed.


                 Show the version and exit.

                 choose specific log level [default: WARNING]

          -v, --verbose
                 show what is happening (loglevel: VERBOSE)

          -d, --debug
                 show debugging information (loglevel: DEBUG)

          --syslog LEVEL
                 send LEVEL logs to syslog

          --config TEXT
                 use a different configuration file

          --database DB
                 use a different database

          -h, --help
                 Show this message and exit.


       Simple run with no side effects:

          feed2exec parse --output echo --args '{item.title}'

       Saving feed items to a Maildir folder:

          feed2exec add "NASA breaking news" --folder nasa
          feed2exec fetch

       This creates the equivalent of this configuration file in ~/.config/feed2exec.ini:

          output = feed2exec.plugins.maildir
          mailbox = '~/Maildir'

          [NASA breaking news]
          folder = nasa
          url =

       Send new feed items to Transmission:

          feed2exec add "Example torrent list" --output transmission --folder /srv/incoming

       Send new feed items to Mastodon, using the toot commandline client:

          feed2exec add "My site" --output exec --args 'toot post "{item.title} {}"'

       Send new feed items to Twitter, using the tweet commandline client from python-twitter:

          feed2exec add "My site on twitter" --output exec --args 'tweet "{item.title:40s} {}"'

       Show feed contents:

          feed2exec add "NASA breaking news" --output echo --args "{item.title} {}"
          feed2exec fetch


       · parse

       · fetch

       · add

       · ls

       · rm

       · import

       · export


          parse URL
              [--output PLUGIN [--args ARG [ARG [...]]]
              [--filter PLUGIN] [--filter_args ARG [ARG [...]]]
              [--mailbox PATH] [--folder PATH]

       The parse command loads and parses a single feed, without touching the database.  This  is
       similar  to  calling  add  then  fetch  on  a single feed, but the feed is not kept in the
       configuration. This is designed to make quick tests with a new feed. The arguments are the
       same as the add command.


          fetch [--parallel | -p | --jobs N | -j N] [--force | -f] [--pattern pattern]

       The  fetch command iterates through all the configured feeds or those matching the pattern
       substring if provided.


          --pattern TEXT
                 only fetch feeds matchin name or URL

                 parse feeds in the background to improve performance

          -j,--jobs N
                 start N jobs in parallel, implies --parallel which defaults  to  the  number  of
                 CPUs detected on the machine

          -f, --force
                 skip reading and writing the cache and will consider all entries as new

          -n, --catchup
                 tell output plugins plugins to simulate their actions


          add NAME URL
              [--output PLUGIN [--args ARG [ARG [...]]]
              [--filter PLUGIN] [--filter_args ARG [ARG [...]]]
              [--mailbox PATH] [--folder PATH]

       The add command adds the given feed NAME that will be fetched from the provided URL.


          --output PLUGIN
                 use  PLUGIN  as an output module. defaults to maildir to store in a mailbox. use
                 null or echo to just fetch the feed without doing anything. Modules are searched
                 in  the  feed2exec.plugins  package unless the name contains a dot in which case
                 the whole Python search path is used.

          --args ARGS
                 pass arguments ARGS  to  the  output  plugin.  supports  interpolation  of  feed
                 parameters using, for example {title}

          --filter PLUGIN
                 filter feed items through the PLUGIN filter plugin

          --filter_args ARGS
                 arguments passed to the filter plugin

          --mailbox PATH
                 folder to store email into, defaults to ~/Maildir.

          --folder PATH
                 subfolder to store the email into

       Those  parameters  are  documented  more  extensively  in their equivalent settings in the
       configuration file, see below.

       The ls command lists all configured feeds as JSON packets.


          rm NAME

       Remove the feed named NAME from the configuration.


          import PATH

       Import feeds from the file named PATH. The file is expected to have outline  elements  and
       only the title and xmlUrl elements are imported, as NAME and URL parameters, respectively.


          export PATH

       Export  feeds  into the file named PATH. The file will use the feed NAME elements as title
       and the URL as xmlUrl.


   Configuration file
       The configuration file is loaded from (and written to, by add) ~/.config/feed2exec.ini  or
       $XDG_CONFIG_HOME/feed2exec.ini.  It  can  also  be specified with the --config commandline
       parameter. This is an example configuration snippet:

          [NASA breaking news]
          url =
          output = feed2exec.plugins.echo
          args = {title} {link}

       Naturally, those settings can be changed directly in the config file. Note that there is a
       [DEFAULT]  section that can be used to apply settings to all feeds. For example, this will
       make all feeds store new items in a maildir subfolder:

          output = feed2exec.plugins.maildir
          folder = feeds

       This way individual feeds do not need to be individually configured.

          feed2exec does not take care of adding the folder to “subscriptions” in the mailbox. it
          is  assumed  that folders are auto-susbcribed or the user ignores subscription. if that
          is a problem, you should subscribe to the folder by hand in your email client when  you
          add  a  new config. you can also subscribe to a folder (say feeds above) directly using
          the doveadm mailbox subscribe feeds command in Dovecot, for example.

       The following configuration parameters are supported:

          name   Human readable name for the feed. Equivalent to the NAME  argument  in  the  add

          url    Address to fetch the feed from. Can be HTTP or HTTPS, but also file:// resources
                 for test purposes.

          output Output plugin to use. Equivalent to the --output option in the add command.

          args   Arguments to pass to the output plugin. Equivalent to the --args option  in  the
                 add command.

          filter Filter plugin to use. Equivalent to the --filter option in the add command.

                 Store emails in that mailbox prefix. Defaults to ~/Maildir.

          folder Subfolder  to  use when writing to a mailbox. By default, a slugified version of
                 the feed name (where spaces and special character are replaced by  -)  is  used.
                 For   example,   the  feed  named  “NASA  breaking  news”  would  be  stored  in

                 Skip to the latest feed items. The feed is still read and parsed, and  new  feed
                 items are added to the database, but output plugins are never called.

          pause  Completely  skip  feed  during  fetch  or parse. Similar to catchup, but doesn’t
                 fetch the feed at all and doesn’t touch the cache.

       Here is a more complete example configuration with all the settings used:

          # this section will apply to all feeds
          # special folder location for maildir. I use this when I have multiple
          # accounts synchronized with Offlineimap
          mailbox = ~/Maildir/Remote/

          # a feed to store NASA breaking news entry in a "nasa" subfolder
          # this also demonstrates the droptitle filter
          [NASA breaking news]
          url =
          folder = nasa
          filter = feed2exec.plugins.droptitle
          filter_args = trump

          # some maildir storage require dots to get subfolders. for example,
          # this will store messages in INBOX/feeds/images/ on Dovecot
          [NASA image of the day]
          url =
          folder = .feeds.images

          # same feed, but save to wayback machine
          [NASA IOTD wayback]
          url =
          output = feed2exec.plugins.wayback

          # this demonstrates the emptysummary filter, which fixes GitHub feeds
          # that lack a proper summary
          url =
          filter = feed2exec.plugins.emptysummary

          # saving to a mbox folder, one file per feed instead of one file per item
          [International Space Station Reports]
          url =
          mailbox = ~/Mail/
          folder = stationreport.mbx

          # simple generic exec call example: check for broken links using linkchecker
          [NASA linkchecker]
          url =
          output = feed2exec.plugins.exec
          args = linkchecker --check-extern --no-robots --recursion-level 1 --quiet '{}'

          # same, but with a Ikiwiki RSS feed, which needs fixing
          [Ikiwiki linkchecker]
          url =
          output = feed2exec.plugins.exec
          filter = feed2exec.plugins.ikiwiki_recentchanges
          args = linkchecker --check-extern --no-robots --recursion-level 1 --quiet '{}'

          # retweet hurricane news
          [NASA Hurricane breaking news]
          url =
          output = feed2exec.plugins.exec
          args = tweet "{item.title:.40s} {}"

          # same, but on the mastodon network
          # we can have multiple entries with the same URL without problems, as
          # long as the feed name is different. it does mean that the feed will
          # be fetched and parsed multiple times, unfortunately.
          # this could be improved to include the '{item.summary}' and extra markup,
          # for example.
          [NASA Hurricane breaking news - Mastodon]
          url =
          output = feed2exec.plugins.exec
          # unfortunately, this will noisily report the URL of the posted link,
          # which you may not want. to avoid that, encourage upstream to do the
          # right thing: ... or use
          # another tool listed here:
          args = toot post "{item.title} {}"
          # output is disabled here. feed will be fetched and parsed, but no
          # toot will be sent
          catchup = True

          # same, but on the network
          [NASA Hurricane breaking news - Pump]
          url =
          output = feed2exec.plugins.exec
          args = p post note "{item.title} {}"

          # crude podcast client
          [NASA Whats up?]
          url =
          output = feed2exec.plugins.exec
          # XXX: this doesn't handle errors properly: if there is a feed without
          # enclosures, the whole thing will crash.
          args = wget -P /srv/podcasts/nasa/ "{item.enclosures[0].href}"
          # feed is paused here. feed will not be fetched and parsed at all and
          # no post will be sent.
          pause = True

          # download torrents linked from a RSS feed
          url =
          output = feed2exec.plugins.exec
          args = transmission-remote -a '{}' -w '/srv/incoming'

          # same thing with an actual plugin
          url =
          output = feed2exec.plugins.transmission
          args =
          folder = /srv/incoming

   Cache database
       The feeds cache is stored in a feed2exec.db file. It is  a  SQLite  database  and  can  be
       inspected  using  standard sqlite tools. It is used to keep track of which feed items have
       been processed. To clear the cache, you can simply remove the file, which  will  make  the
       program  process  all  feeds  items  from  scratch again. In this case, you should use the
       --catchup argument to avoid duplicate processing. You can also use the null output  plugin
       to the same effect.


       Feed  support is only as good as feedparser library which isn’t as solid as I expected. In
       particular, I had issues with feeds without dates and without guid.

       Unit test coverage is incomplete, but still pretty decent, above 90%.

       The exec plugin itself is not well tested and may have serious security issues.

       API, commandline interface, configuration file syntax and database format can  be  changed
       until  the  1.0  release is published, at which point normal Semantic Versioning semantics

       The program is written mainly targeting Python 3.5 and should work in 3.6. Python  2.7  is
       not supported anymore.

       The  SQL storage layer is badly written and is known to trigger locking issues with SQLite
       when doing multiprocessing. The global LOCK object could be used to work around this issue
       but  that  could mean pretty bad coupling. A good inspiration may be the beets story about
       this problem. And of course, another alternative would be to  considering  something  like
       SQLalchemy instead of rolling our own ORM.

       Older feed items are not purged from the database when they disappear from the feed, which
       may lead to database bloat in the long term. Similarly, there is no  way  for  plugins  to
       remove old entry that expire from the feed.


       feed2exec-plugins(1), feed2imap(1), rss2email(1)


       Antoine Beaupré


       Copyright (C) 2016  Antoine Beaupré