%21Sargasso/py/sargasso.py

#
# This file is part of Sargasso, http://zamez.org/sargasso
# Licensed under the GNU General Public License,
#                http://www.opensource.org/licenses/gpl-license
# Copyright 2005 James Bursa <james@semichrome.net>
#

import sys
import asyncore
import feedparser
import http_client

feeds = []
STATUS_IDLE, STATUS_FETCHING, STATUS_DONE, STATUS_ERROR = range(4)

http_client.request_headers += ['User-Agent: Sargasso',
        'Accept: ' + feedparser.ACCEPT_HEADER]


class Feed:

    def __init__(self, url):
        self.url = url
        self.status = STATUS_IDLE
        self.data = ''
        self.feed = {}
        self.version = ''
        self.entries = []
        self.new_entries = []

    def poll(self):
        """Do some work on this feed."""
        if self.status == STATUS_IDLE:
            # start fetch
            try:
                self.fetch = http_client.do_request(self.url, self)
            except Exception, e:
                self.status = STATUS_ERROR
                self.error = str(e)
                return
            self.status = STATUS_FETCHING

    # http_client callbacks
    def http_header(self, client):
        print client.header
        if (client.status[1] != "200"):
            self.status = STATUS_ERROR
            self.error = '%s %s' % (client.status[1], client.status[2][:-2])
            raise http_client.CloseConnection
        self.host = client.host

    def http_failed(self, client):
        self.status = STATUS_ERROR
        self.error = 'Connection failed'

    def receive(self, data):
        self.data += data

    def close(self):
        self.feedparse = fp = feedparser.parse(self.data)
        self.feed = fp.feed
        self.version = fp.version
        for entry in fp.entries:
            if entry not in self.entries:
                self.new_entries.append(entry)
        entries = fp.entries
        for old_entry in self.entries:
            if old_entry not in entries:
                entries.append(old_entry)
        self.entries = entries
        self.status = STATUS_DONE

    # update this feed
    def update(self):
        if self.status != STATUS_DONE:
            return
        self.status = STATUS_IDLE
        self.data = ''

    # show current status
    def __repr__(self):
        if self.status == STATUS_IDLE:
            return '%s IDLE' % self.url
        elif self.status == STATUS_FETCHING:
            return '%s FETCHING (%i bytes)' % (self.url,
                    len(self.data))
        elif self.status == STATUS_DONE:
            return '%s DONE (%i bytes)' % (self.url,
                    len(self.data))
        elif self.status == STATUS_ERROR:
            return '%s ERROR (%s)' % (self.url, self.error)


def add_feed(url):
    """Add a feed to the set of feeds."""
    for feed in feeds:
        if feed.url == url:
            return
    feeds.append(Feed(url))


def poll():
    """Do some work on the set of feeds."""
    for feed in feeds:
        feed.poll()
    asyncore.poll()


def remove_feed(url):
    """Remove a feed from the set of feeds."""
    for feed in feeds:
        if feed.url == url:
            feeds.remove(feed)
            break


if __name__ == '__main__':
    from time import sleep
    from pprint import pprint
    map(add_feed, sys.argv[1:])
    while 1:
        poll()
        pprint(feeds)
        sleep(0.5)
1	#
2	# This file is part of Sargasso, http://zamez.org/sargasso
3	# Licensed under the GNU General Public License,
4	# http://www.opensource.org/licenses/gpl-license
5	# Copyright 2005 James Bursa <james@semichrome.net>
6	#
7
8	import sys
9	import asyncore
10	import feedparser
11	import http_client
12
13	feeds = []
14	STATUS_IDLE, STATUS_FETCHING, STATUS_DONE, STATUS_ERROR = range(4)
15
16	http_client.request_headers += ['User-Agent: Sargasso',
17	'Accept: ' + feedparser.ACCEPT_HEADER]
18
19
20	class Feed:
21
22	def __init__(self, url):
23	self.url = url
24	self.status = STATUS_IDLE
25	self.data = ''
26	self.feed = {}
27	self.version = ''
28	self.entries = []
29	self.new_entries = []
30
31	def poll(self):
32	"""Do some work on this feed."""
33	if self.status == STATUS_IDLE:
34	# start fetch
35	try:
36	self.fetch = http_client.do_request(self.url, self)
37	except Exception, e:
38	self.status = STATUS_ERROR
39	self.error = str(e)
40	return
41	self.status = STATUS_FETCHING
42
43	# http_client callbacks
44	def http_header(self, client):
45	print client.header
46	if (client.status[1] != "200"):
47	self.status = STATUS_ERROR
48	self.error = '%s %s' % (client.status[1], client.status[2][:-2])
49	raise http_client.CloseConnection
50	self.host = client.host
51
52	def http_failed(self, client):
53	self.status = STATUS_ERROR
54	self.error = 'Connection failed'
55
56	def receive(self, data):
57	self.data += data
58
59	def close(self):
60	self.feedparse = fp = feedparser.parse(self.data)
61	self.feed = fp.feed
62	self.version = fp.version
63	for entry in fp.entries:
64	if entry not in self.entries:
65	self.new_entries.append(entry)
66	entries = fp.entries
67	for old_entry in self.entries:
68	if old_entry not in entries:
69	entries.append(old_entry)
70	self.entries = entries
71	self.status = STATUS_DONE
72
73	# update this feed
74	def update(self):
75	if self.status != STATUS_DONE:
76	return
77	self.status = STATUS_IDLE
78	self.data = ''
79
80	# show current status
81	def __repr__(self):
82	if self.status == STATUS_IDLE:
83	return '%s IDLE' % self.url
84	elif self.status == STATUS_FETCHING:
85	return '%s FETCHING (%i bytes)' % (self.url,
86	len(self.data))
87	elif self.status == STATUS_DONE:
88	return '%s DONE (%i bytes)' % (self.url,
89	len(self.data))
90	elif self.status == STATUS_ERROR:
91	return '%s ERROR (%s)' % (self.url, self.error)
92
93
94	def add_feed(url):
95	"""Add a feed to the set of feeds."""
96	for feed in feeds:
97	if feed.url == url:
98	return
99	feeds.append(Feed(url))
100
101
102	def poll():
103	"""Do some work on the set of feeds."""
104	for feed in feeds:
105	feed.poll()
106	asyncore.poll()
107
108
109	def remove_feed(url):
110	"""Remove a feed from the set of feeds."""
111	for feed in feeds:
112	if feed.url == url:
113	feeds.remove(feed)
114	break
115
116
117
118
119	if __name__ == '__main__':
120	from time import sleep
121	from pprint import pprint
122	map(add_feed, sys.argv[1:])
123	while 1:
124	poll()
125	pprint(feeds)
126	sleep(0.5)