Commits

Janto Dreijer committed 2f208fe

removed unused rss module

Comments (0)

Files changed (4)

code/PyRSS2Gen.py

-"""PyRSS2Gen - A Python library for generating RSS 2.0 feeds."""
-
-__name__ = "PyRSS2Gen"
-__version__ = (1, 0, 0)
-__author__ = "Andrew Dalke <dalke@dalkescientific.com>"
-
-_generator_name = __name__ + "-" + ".".join(map(str, __version__))
-
-import datetime
-
-# Could make this the base class; will need to add 'publish'
-class WriteXmlMixin:
-    def write_xml(self, outfile, encoding = "iso-8859-1"):
-        from xml.sax import saxutils
-        handler = saxutils.XMLGenerator(outfile, encoding)
-        handler.startDocument()
-        self.publish(handler)
-        handler.endDocument()
-
-    def to_xml(self, encoding = "iso-8859-1"):
-        try:
-            import cStringIO as StringIO
-        except ImportError:
-            import StringIO
-        f = StringIO.StringIO()
-        self.write_xml(f, encoding)
-        return f.getvalue()
-
-
-def _element(handler, name, obj, d = {}):
-    if isinstance(obj, basestring) or obj is None:
-        # special-case handling to make the API easier
-        # to use for the common case.
-        handler.startElement(name, d)
-        if obj is not None:
-            handler.characters(obj)
-        handler.endElement(name)
-    else:
-        # It better know how to emit the correct XML.
-        obj.publish(handler)
-
-def _opt_element(handler, name, obj):
-    if obj is None:
-        return
-    _element(handler, name, obj)
-
-
-def _format_date(dt):
-    """convert a datetime into an RFC 822 formatted date
-
-    Input date must be in GMT.
-    """
-    # Looks like:
-    #   Sat, 07 Sep 2002 00:00:01 GMT
-    # Can't use strftime because that's locale dependent
-    #
-    # Isn't there a standard way to do this for Python?  The
-    # rfc822 and email.Utils modules assume a timestamp.  The
-    # following is based on the rfc822 module.
-    return "%s, %02d %s %04d %02d:%02d:%02d GMT" % (
-            ["Mon", "Tue", "Wed", "Thu", "Fri", "Sat", "Sun"][dt.weekday()],
-            dt.day,
-            ["Jan", "Feb", "Mar", "Apr", "May", "Jun",
-             "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"][dt.month-1],
-            dt.year, dt.hour, dt.minute, dt.second)
-
-        
-##
-# A couple simple wrapper objects for the fields which
-# take a simple value other than a string.
-class IntElement:
-    """implements the 'publish' API for integers
-
-    Takes the tag name and the integer value to publish.
-    
-    (Could be used for anything which uses str() to be published
-    to text for XML.)
-    """
-    element_attrs = {}
-    def __init__(self, name, val):
-        self.name = name
-        self.val = val
-    def publish(self, handler):
-        handler.startElement(self.name, self.element_attrs)
-        handler.characters(str(self.val))
-        handler.endElement(self.name)
-
-class DateElement:
-    """implements the 'publish' API for a datetime.datetime
-
-    Takes the tag name and the datetime to publish.
-
-    Converts the datetime to RFC 2822 timestamp (4-digit year).
-    """
-    def __init__(self, name, dt):
-        self.name = name
-        self.dt = dt
-    def publish(self, handler):
-        _element(handler, self.name, _format_date(self.dt))
-####
-
-class Category:
-    """Publish a category element"""
-    def __init__(self, category, domain = None):
-        self.category = category
-        self.domain = domain
-    def publish(self, handler):
-        d = {}
-        if self.domain is not None:
-            d["domain"] = self.domain
-        _element(handler, "category", self.category, d)
-
-class Cloud:
-    """Publish a cloud"""
-    def __init__(self, domain, port, path,
-                 registerProcedure, protocol):
-        self.domain = domain
-        self.port = port
-        self.path = path
-        self.registerProcedure = registerProcedure
-        self.protocol = protocol
-    def publish(self, handler):
-        _element(handler, "cloud", None, {
-            "domain": self.domain,
-            "port": str(self.port),
-            "path": self.path,
-            "registerProcedure": self.registerProcedure,
-            "protocol": self.protocol})
-
-class Image:
-    """Publish a channel Image"""
-    element_attrs = {}
-    def __init__(self, url, title, link,
-                 width = None, height = None, description = None):
-        self.url = url
-        self.title = title
-        self.link = link
-        self.width = width
-        self.height = height
-        self.description = description
-        
-    def publish(self, handler):
-        handler.startElement("image", self.element_attrs)
-
-        _element(handler, "url", self.url)
-        _element(handler, "title", self.title)
-        _element(handler, "link", self.link)
-
-        width = self.width
-        if isinstance(width, int):
-            width = IntElement("width", width)
-        _opt_element(handler, "width", width)
-        
-        height = self.height
-        if isinstance(height, int):
-            height = IntElement("height", height)
-        _opt_element(handler, "height", height)
-
-        _opt_element(handler, "description", self.description)
-
-        handler.endElement("image")
-
-class Guid:
-    """Publish a guid
-
-    Defaults to being a permalink, which is the assumption if it's
-    omitted.  Hence strings are always permalinks.
-    """
-    def __init__(self, guid, isPermaLink = 1):
-        self.guid = guid
-        self.isPermaLink = isPermaLink
-    def publish(self, handler):
-        d = {}
-        if self.isPermaLink:
-            d["isPermaLink"] = "true"
-        else:
-            d["isPermaLink"] = "false"
-        _element(handler, "guid", self.guid, d)
-
-class TextInput:
-    """Publish a textInput
-
-    Apparently this is rarely used.
-    """
-    element_attrs = {}
-    def __init__(self, title, description, name, link):
-        self.title = title
-        self.description = description
-        self.name = name
-        self.link = link
-
-    def publish(self, handler):
-        handler.startElement("textInput", self.element_attrs)
-        _element(handler, "title", self.title)
-        _element(handler, "description", self.description)
-        _element(handler, "name", self.name)
-        _element(handler, "link", self.link)
-        handler.endElement("textInput")
-        
-
-class Enclosure:
-    """Publish an enclosure"""
-    def __init__(self, url, length, type):
-        self.url = url
-        self.length = length
-        self.type = type
-    def publish(self, handler):
-        _element(handler, "enclosure", None,
-                 {"url": self.url,
-                  "length": str(self.length),
-                  "type": self.type,
-                  })
-
-class Source:
-    """Publish the item's original source, used by aggregators"""
-    def __init__(self, name, url):
-        self.name = name
-        self.url = url
-    def publish(self, handler):
-        _element(handler, "source", self.name, {"url": self.url})
-
-class SkipHours:
-    """Publish the skipHours
-
-    This takes a list of hours, as integers.
-    """
-    element_attrs = {}
-    def __init__(self, hours):
-        self.hours = hours
-    def publish(self, handler):
-        if self.hours:
-            handler.startElement("skipHours", self.element_attrs)
-            for hour in self.hours:
-                _element(handler, "hour", str(hour))
-            handler.endElement("skipHours")
-
-class SkipDays:
-    """Publish the skipDays
-
-    This takes a list of days as strings.
-    """
-    element_attrs = {}
-    def __init__(self, days):
-        self.days = days
-    def publish(self, handler):
-        if self.days:
-            handler.startElement("skipDays", self.element_attrs)
-            for day in self.days:
-                _element(handler, "day", day)
-            handler.endElement("skipDays")
-
-class RSS2(WriteXmlMixin):
-    """The main RSS class.
-
-    Stores the channel attributes, with the "category" elements under
-    ".categories" and the RSS items under ".items".
-    """
-    
-    rss_attrs = {"version": "2.0"}
-    element_attrs = {}
-    def __init__(self,
-                 title,
-                 link,
-                 description,
-
-                 language = None,
-                 copyright = None,
-                 managingEditor = None,
-                 webMaster = None,
-                 pubDate = None,  # a datetime, *in* *GMT*
-                 lastBuildDate = None, # a datetime
-                 
-                 categories = None, # list of strings or Category
-                 generator = _generator_name,
-                 docs = "http://blogs.law.harvard.edu/tech/rss",
-                 cloud = None,    # a Cloud
-                 ttl = None,      # integer number of minutes
-
-                 image = None,     # an Image
-                 rating = None,    # a string; I don't know how it's used
-                 textInput = None, # a TextInput
-                 skipHours = None, # a SkipHours with a list of integers
-                 skipDays = None,  # a SkipDays with a list of strings
-
-                 items = None,     # list of RSSItems
-                 ):
-        self.title = title
-        self.link = link
-        self.description = description
-        self.language = language
-        self.copyright = copyright
-        self.managingEditor = managingEditor
-
-        self.webMaster = webMaster
-        self.pubDate = pubDate
-        self.lastBuildDate = lastBuildDate
-        
-        if categories is None:
-            categories = []
-        self.categories = categories
-        self.generator = generator
-        self.docs = docs
-        self.cloud = cloud
-        self.ttl = ttl
-        self.image = image
-        self.rating = rating
-        self.textInput = textInput
-        self.skipHours = skipHours
-        self.skipDays = skipDays
-
-        if items is None:
-            items = []
-        self.items = items
-
-    def publish(self, handler):
-        handler.startElement("rss", self.rss_attrs)
-        handler.startElement("channel", self.element_attrs)
-        _element(handler, "title", self.title)
-        _element(handler, "link", self.link)
-        _element(handler, "description", self.description)
-
-        self.publish_extensions(handler)
-        
-        _opt_element(handler, "language", self.language)
-        _opt_element(handler, "copyright", self.copyright)
-        _opt_element(handler, "managingEditor", self.managingEditor)
-        _opt_element(handler, "webMaster", self.webMaster)
-
-        pubDate = self.pubDate
-        if isinstance(pubDate, datetime.datetime):
-            pubDate = DateElement("pubDate", pubDate)
-        _opt_element(handler, "pubDate", pubDate)
-
-        lastBuildDate = self.lastBuildDate
-        if isinstance(lastBuildDate, datetime.datetime):
-            lastBuildDate = DateElement("lastBuildDate", lastBuildDate)
-        _opt_element(handler, "lastBuildDate", lastBuildDate)
-
-        for category in self.categories:
-            if isinstance(category, basestring):
-                category = Category(category)
-            category.publish(handler)
-
-        _opt_element(handler, "generator", self.generator)
-        _opt_element(handler, "docs", self.docs)
-
-        if self.cloud is not None:
-            self.cloud.publish(handler)
-
-        ttl = self.ttl
-        if isinstance(self.ttl, int):
-            ttl = IntElement("ttl", ttl)
-        _opt_element(handler, "tt", ttl)
-
-        if self.image is not None:
-            self.image.publish(handler)
-
-        _opt_element(handler, "rating", self.rating)
-        if self.textInput is not None:
-            self.textInput.publish(handler)
-        if self.skipHours is not None:
-            self.skipHours.publish(handler)
-        if self.skipDays is not None:
-            self.skipDays.publish(handler)
-
-        for item in self.items:
-            item.publish(handler)
-
-        handler.endElement("channel")
-        handler.endElement("rss")
-
-    def publish_extensions(self, handler):
-        # Derived classes can hook into this to insert
-        # output after the three required fields.
-        pass
-
-    
-    
-class RSSItem(WriteXmlMixin):
-    """Publish an RSS Item"""
-    element_attrs = {}
-    def __init__(self,
-                 title = None,  # string
-                 link = None,   # url as string
-                 description = None, # string
-                 author = None,      # email address as string
-                 categories = None,  # list of string or Category
-                 comments = None,  # url as string
-                 enclosure = None, # an Enclosure
-                 guid = None,    # a unique string
-                 pubDate = None, # a datetime
-                 source = None,  # a Source
-                 ):
-        
-        if title is None and description is None:
-            raise TypeError(
-                "must define at least one of 'title' or 'description'")
-        self.title = title
-        self.link = link
-        self.description = description
-        self.author = author
-        if categories is None:
-            categories = []
-        self.categories = categories
-        self.comments = comments
-        self.enclosure = enclosure
-        self.guid = guid
-        self.pubDate = pubDate
-        self.source = source
-        # It sure does get tedious typing these names three times...
-
-    def publish(self, handler):
-        handler.startElement("item", self.element_attrs)
-        _opt_element(handler, "title", self.title)
-        _opt_element(handler, "link", self.link)
-        self.publish_extensions(handler)
-        _opt_element(handler, "description", self.description)
-        _opt_element(handler, "author", self.author)
-
-        for category in self.categories:
-            if isinstance(category, basestring):
-                category = Category(category)
-            category.publish(handler)
-        
-        _opt_element(handler, "comments", self.comments)
-        if self.enclosure is not None:
-            self.enclosure.publish(handler)
-        _opt_element(handler, "guid", self.guid)
-
-        pubDate = self.pubDate
-        if isinstance(pubDate, datetime.datetime):
-            pubDate = DateElement("pubDate", pubDate)
-        _opt_element(handler, "pubDate", pubDate)
-
-        if self.source is not None:
-            self.source.publish(handler)
-        
-        handler.endElement("item")
-
-    def publish_extensions(self, handler):
-        # Derived classes can hook into this to insert
-        # output after the title and link elements
-        pass
 
 from __future__ import division
 
-from google.appengine.api import users, urlfetch, memcache, mail
-from google.appengine.ext import webapp, db
-from google.appengine.api import users
-
 from tools import *
 
 import templates
 		self.write(get_template("about") % locals())
 		self.print_footer()
 
+class DebugPage(Page):
+	name = "debug"
+	def get(self):
+		self.print_header()
+		self.print_menu()
+		server = xmlrpclib.ServerProxy('http://pypi.python.org/pypi', transport=GoogleXMLRPCTransport())
+		result = server.package_releases('roundup')
+		self.write(result)
+		self.print_footer()
 
 application = webapp.WSGIApplication([
 	('/', MainPage),
 	#~ ('/recent_changes', RecentChangesPage),
 	('/search', SearchPage),
 	('/admin', AdminPage),
+	('/debug', DebugPage),
 
 	('/(.+)', PackageInfoPage),
 	], debug=True)

code/templates.py

 
 <p>
 <img src="/static/images/download_large.png" width="16" border="0" /> Download:  %(download_link)s <br />
-Homepage: <a href="%(homepage)s">%(homepage)s</a> </br>
-PyPI: <a href="http://pypi.python.org/pypi/%(name)s">http://pypi.python.org/pypi/%(name)s</a> </br>
-People: %(people)s </br>
+Homepage: <a href="%(homepage)s">%(homepage)s</a> <br />
+PyPI: <a href="http://pypi.python.org/pypi/%(name)s">http://pypi.python.org/pypi/%(name)s</a> <br />
+Source: <a href="%(repo_url)s">%(repo_url)s</a> <br />
+People: %(people)s <br />
 </p>
 
 <h3>Description</h3>
 import re
 import os.path
 
+from google.appengine.api import users, urlfetch, memcache, mail
+from google.appengine.ext import webapp, db
+from google.appengine.api import users
+
+import xmlrpclib
+
 #~ import xml.etree.ElementTree as ET
 
 # set up locations
 
 REPO_PATH = "http://svn.scipy.org/svn/scikits/trunk"
 
-#~ import rdfxml
-#~ class Sink(object):
-	#~ def __init__(self):
-		#~ self.result = []
-	#~ def triple(self, s, p, o):
-		#~ self.result.append((s, p, o))
-#~ def rdfToPython(s, base=None):
-	#~ sink = Sink()
-	#~ return rdfxml.parseRDF(s, base=None, sink=sink).result
-
-#~ text = file("/home/janto/download/scikits.ann-0.2.dev-r803(4).xml").read()
-#~ print rdfxml.parseRDF(text).result
-#~ print rdfToPython(text)
-
-#~ import PyRSS2Gen as RSS2
-
 import time
 
 # set up logging system
 	format=log_format,
 	)
 logger = logging.getLogger("")
+
+class GoogleXMLRPCTransport(object):
+	"""Handles an HTTP transaction to an XML-RPC server."""
+
+	def __init__(self, use_datetime=0):
+		self._use_datetime = use_datetime
+
+	def request(self, host, handler, request_body, verbose=0):
+		"""
+		Send a complete request, and parse the response. See xmlrpclib.py.
+
+		:Parameters:
+			host : str
+				target host
+
+			handler : str
+				RPC handler on server (i.e., path to handler)
+
+			request_body : str
+				XML-RPC request body
+
+			verbose : bool/int
+				debugging flag. Ignored by this implementation
+
+		:rtype: dict
+		:return: parsed response, as key/value pairs
+		"""
+
+		# issue XML-RPC request
+
+		result = None
+		url = 'http://%s%s' % (host, handler)
+		try:
+			response = urlfetch.fetch(url,
+				payload=request_body,
+				method=urlfetch.POST,
+				headers={'Content-Type': 'text/xml'})
+		except:
+			msg = 'Failed to fetch %s' % url
+			raise xmlrpclib.ProtocolError(host + handler, 500, msg, {})
+
+		if response.status_code != 200:
+			logging.error('%s returned status code %s' % (url, response.status_code))
+			raise xmlrpclib.ProtocolError(host + handler,
+				  response.status_code,
+				  "",
+				  response.headers)
+		else:
+			result = self.__parse_response(response.content)
+
+		return result
+
+	def __parse_response(self, response_body):
+		p, u = xmlrpclib.getparser(use_datetime=self._use_datetime)
+		p.feed(response_body)
+		return u.close()